feat(personen): Personen und Self-Service Meine Schluessel (#013)

Personen lassen sich anlegen, bearbeiten und archivieren; ihr Detail
zeigt ihre Schluessel. Unter "Meine Schluessel" hinterlegt jede Rolle
eigene Public Keys (Freigabe Frage 4), wirksam erst nach Zuweisung
durch einen Operator oder Admin.

Warum so:
- Die eigene Person entsteht beim ersten Aufruf oder wird verknuepft:
  per benutzerId, sonst per E-Mail - aber nur, wenn der OIDC-Anbieter
  die Adresse bestaetigt hat. Dafuer merkt sich Benutzer jetzt
  emailBestaetigt (Migration); sonst koennte jemand mit selbst
  gewaehlter Adresse die Keys einer fremden Person sehen.
- Die Self-Service-Services nehmen nur den angemeldeten Benutzer und
  leiten die Person selbst ab; fremde Schluessel-IDs gelten als nicht
  vorhanden.
- Entfernen nur fuer eigene, selbst hinterlegte Keys ohne Verwendung,
  bedingt geloescht, damit eine gleichzeitige Zuweisung nicht per
  Cascade verschwindet.
- Archivieren statt Loeschen: wer bis wann welchen Key hatte, bleibt
  nachvollziehbar.

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

docs/issues/013-personen-selbstauskunft.md

@@ -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).

prisma/migrations/20261012103000_benutzer_email_bestaetigt/migration.sql

@@ -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;

prisma/schema.prisma

@@ -135,6 +135,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

scripts/screenshots.ts

@@ -35,6 +35,8 @@ const SEITEN: { name: string; pfad: string; oeffentlich?: boolean; folgen?: stri
     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/"]' },
 ];

src/app/(app)/meine-schluessel/page.tsx

@@ -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>
+  );
+}

src/app/(app)/personen/[id]/bearbeiten/page.tsx

@@ -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>
+  );
+}

src/app/(app)/personen/[id]/page.tsx

@@ -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>
+  );
+}

src/app/(app)/personen/neu/page.tsx

@@ -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>
+  );
+}

src/app/(app)/personen/page.tsx

@@ -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>
   );
 }

src/app/(app)/schluessel/[id]/page.tsx

@@ -170,7 +170,10 @@ export default async function SchluesselSeite({ params }: { params: Promise<{ id
         untertitel={
           s.person ? (
             <>
-              Person: <span className="text-text">{s.person.name}</span>
+              Person:{" "}
+              <Link href={`/personen/${s.person.id}`} className="text-accent hover:underline">
+                {s.person.name}
+              </Link>
             </>
           ) : undefined
         }

src/components/huelle/nav-punkte.ts

@@ -1,6 +1,7 @@
 import {
   Boxes,
   KeyRound,
+  KeySquare,
   LayoutDashboard,
   LayoutTemplate,
   Network,
@@ -20,6 +21,8 @@ export const HAUPTNAVIGATION: NavPunkt[] = [
   { href: "/hostgruppen", titel: "Hostgruppen", icon: Boxes },
   { href: "/schluessel", titel: "Schlüssel", icon: KeyRound },
   { href: "/personen", titel: "Personen", icon: Users },
+  // Self-Service fuer jede Rolle (#013): eigene Public Keys hinterlegen.
+  { href: "/meine-schluessel", titel: "Meine Schlüssel", icon: KeySquare },
   { href: "/zuweisungen", titel: "Zuweisungen", icon: Network },
   { href: "/vorlagen", titel: "Vorlagen", icon: LayoutTemplate },
 ];

src/components/personen/MeineSchluessel.tsx

@@ -0,0 +1,115 @@
+"use client";
+
+import { Plus, Trash2 } from "lucide-react";
+import { useActionState, useEffect, useRef } from "react";
+import { useFormularAktion } from "@/components/hosts/useFormularAktion";
+import { Button, Feld, Formularfehler, Karte, Textbereich } from "@/components/ui";
+import type { FormularZustand } from "@/server/actions/formular";
+import {
+  eigenenKeyEntfernenAktion,
+  eigenenKeyHinterlegenAktion,
+  type HinterlegenZustand,
+} from "@/server/actions/meine-schluessel";
+
+/** Eigenen Public Key hinterlegen (#013). Nach Erfolg leert sich das Formular. */
+export function KeyHinterlegen() {
+  const formular = useRef<HTMLFormElement>(null);
+  const { zustand, absenden, laeuft } = useFormularAktion(
+    eigenenKeyHinterlegenAktion as (v: FormularZustand, f: FormData) => Promise<HinterlegenZustand>,
+  );
+  const erfolg = (zustand as HinterlegenZustand).erfolg;
+  useEffect(() => {
+    if (erfolg) formular.current?.reset();
+  }, [erfolg]);
+  const f = zustand.feldfehler ?? {};
+  return (
+    <Karte
+      titel="Public Key hinterlegen"
+      untertitel="Eine Zeile im OpenSSH-Format, z. B. aus ~/.ssh/id_ed25519.pub"
+    >
+      <form ref={formular} onSubmit={absenden} noValidate className="flex flex-col gap-4">
+        <Formularfehler text={zustand.fehler} />
+        {erfolg && (
+          <p role="status" className="text-ok text-[14px] break-all">
+            {erfolg}
+          </p>
+        )}
+        <Feld
+          beschriftung="Bezeichnung"
+          name="name"
+          required
+          maxLength={120}
+          placeholder="Laptop, Workstation …"
+          autoComplete="off"
+          fehler={f["name"]}
+        />
+        <Textbereich
+          beschriftung="Public Key"
+          name="publicKey"
+          required
+          rows={3}
+          spellCheck={false}
+          placeholder="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA… name@rechner"
+          fehler={f["publicKey"]}
+          className="[&_textarea]:font-mono [&_textarea]:text-[13px]"
+        />
+        <p className="text-muted text-[13.5px]">
+          Wirksam erst, wenn ein Operator oder Admin den Schlüssel einem Host zuweist. Den Private Key
+          behalten Sie bei sich – sshkv fragt nie danach.
+        </p>
+        <div>
+          <Button
+            type="submit"
+            variante="primaer"
+            disabled={laeuft}
+            icon={<Plus className="size-4" strokeWidth={2.4} />}
+          >
+            {laeuft ? "Speichere …" : "Hinterlegen"}
+          </Button>
+        </div>
+      </form>
+    </Karte>
+  );
+}
+
+/** Eigenen, noch nirgends zugewiesenen Key entfernen – mit Rueckfrage. */
+export function KeyEntfernen({ schluesselId, name }: { schluesselId: string; name: string }) {
+  const dialog = useRef<HTMLDialogElement>(null);
+  const [zustand, aktion, laeuft] = useActionState<FormularZustand, FormData>(eigenenKeyEntfernenAktion, {});
+  return (
+    <>
+      <Button
+        variante="gefahr"
+        klein
+        icon={<Trash2 className="size-4" />}
+        onClick={() => dialog.current?.showModal()}
+        aria-label={`${name} entfernen`}
+      >
+        Entfernen
+      </Button>
+      <dialog
+        ref={dialog}
+        aria-labelledby={`entfernen-${schluesselId}`}
+        className="border-border-strong bg-surface text-text rounded-karte m-auto w-[calc(100%-32px)] max-w-md border p-5 backdrop:bg-black/70 sm:p-6"
+      >
+        <form action={aktion} className="flex flex-col gap-4">
+          <input type="hidden" name="id" value={schluesselId} />
+          <h2 id={`entfernen-${schluesselId}`} className="text-[17px] font-semibold">
+            „{name}“ entfernen?
+          </h2>
+          <p className="text-muted text-[14.5px]">
+            Der Public Key verschwindet aus sshkv. Er ist noch keinem Host zugewiesen; auf keinem Server
+            ändert sich etwas.
+          </p>
+          <Formularfehler text={zustand.fehler} />
+          <div className="flex flex-wrap justify-end gap-2.5">
+            <Button onClick={() => dialog.current?.close()}>Abbrechen</Button>
+            <Button type="submit" variante="gefahr" disabled={laeuft}>
+              {laeuft ? "Entferne …" : "Entfernen"}
+            </Button>
+          </div>
+        </form>
+      </dialog>
+    </>
+  );
+}

src/components/personen/PersonFormular.tsx

@@ -0,0 +1,151 @@
+"use client";
+
+import { Archive } from "lucide-react";
+import { useActionState, useRef } from "react";
+import { useFormularAktion } from "@/components/hosts/useFormularAktion";
+import { Auswahlliste, Button, Feld, Formularfehler, Karte, Textbereich } from "@/components/ui";
+import type { FormularZustand } from "@/server/actions/formular";
+import {
+  personAnlegenAktion,
+  personArchivierenAktion,
+  personBearbeitenAktion,
+} from "@/server/actions/personen";
+
+export type PersonFormularVorgabe = {
+  id?: string;
+  name: string;
+  email: string;
+  organisation: string;
+  notiz: string;
+  benutzerId: string;
+};
+
+export const LEERE_PERSON: PersonFormularVorgabe = {
+  name: "",
+  email: "",
+  organisation: "",
+  notiz: "",
+  benutzerId: "",
+};
+
+/** Formular fuer neue und bestehende Personen (#013). Regeln prueft der Server. */
+export function PersonFormular({
+  vorgabe,
+  konten,
+  abbrechenZiel,
+}: {
+  vorgabe: PersonFormularVorgabe;
+  konten: { id: string; name: string; email: string | null }[];
+  abbrechenZiel: string;
+}) {
+  const bearbeiten = Boolean(vorgabe.id);
+  const { zustand, absenden, laeuft } = useFormularAktion(
+    bearbeiten ? personBearbeitenAktion : personAnlegenAktion,
+  );
+  const f = zustand.feldfehler ?? {};
+  return (
+    <form onSubmit={absenden} noValidate className="flex flex-col gap-6">
+      {vorgabe.id && <input type="hidden" name="id" value={vorgabe.id} />}
+      <Formularfehler text={zustand.fehler} />
+      <Karte titel="Person">
+        <div className="grid gap-4 sm:grid-cols-2">
+          <Feld
+            beschriftung="Name"
+            name="name"
+            defaultValue={vorgabe.name}
+            required
+            maxLength={120}
+            autoComplete="off"
+            fehler={f["name"]}
+            className="sm:col-span-2"
+          />
+          <Feld
+            beschriftung="E-Mail (optional)"
+            name="email"
+            type="email"
+            defaultValue={vorgabe.email}
+            maxLength={254}
+            autoComplete="off"
+            fehler={f["email"]}
+          />
+          <Feld
+            beschriftung="Organisation (optional)"
+            name="organisation"
+            defaultValue={vorgabe.organisation}
+            maxLength={120}
+            placeholder="z. B. Dienstleister"
+            fehler={f["organisation"]}
+          />
+          <Auswahlliste
+            beschriftung="Verknüpftes Konto (optional)"
+            name="benutzerId"
+            defaultValue={vorgabe.benutzerId}
+            className="sm:col-span-2"
+          >
+            <option value="">keines</option>
+            {konten.map((k) => (
+              <option key={k.id} value={k.id}>
+                {k.email ? `${k.name} (${k.email})` : k.name}
+              </option>
+            ))}
+          </Auswahlliste>
+          {f["benutzerId"] && <p className="text-danger text-[13px] sm:col-span-2">{f["benutzerId"]}</p>}
+          <Textbereich
+            beschriftung="Notiz (optional)"
+            name="notiz"
+            defaultValue={vorgabe.notiz}
+            maxLength={1000}
+            fehler={f["notiz"]}
+            className="sm:col-span-2"
+          />
+        </div>
+      </Karte>
+      <div className="flex flex-wrap gap-2.5">
+        <Button type="submit" variante="primaer" disabled={laeuft}>
+          {laeuft ? "Speichere …" : bearbeiten ? "Änderungen speichern" : "Person anlegen"}
+        </Button>
+        <Button href={abbrechenZiel}>Abbrechen</Button>
+      </div>
+    </form>
+  );
+}
+
+/** Archivieren mit Rueckfrage, nativer `<dialog>` wie bei Hosts (#008). */
+export function PersonArchivieren({ personId, name }: { personId: string; name: string }) {
+  const dialog = useRef<HTMLDialogElement>(null);
+  const [zustand, aktion, laeuft] = useActionState<FormularZustand, FormData>(personArchivierenAktion, {});
+  return (
+    <>
+      <Button
+        variante="gefahr"
+        icon={<Archive className="size-4" />}
+        onClick={() => dialog.current?.showModal()}
+      >
+        Person archivieren
+      </Button>
+      <dialog
+        ref={dialog}
+        aria-labelledby="person-archivieren-titel"
+        className="border-border-strong bg-surface text-text rounded-karte m-auto w-[calc(100%-32px)] max-w-md border p-5 backdrop:bg-black/70 sm:p-6"
+      >
+        <form action={aktion} className="flex flex-col gap-4">
+          <input type="hidden" name="id" value={personId} />
+          <h2 id="person-archivieren-titel" className="text-[17px] font-semibold">
+            {name} archivieren?
+          </h2>
+          <p className="text-muted text-[14.5px]">
+            Die Person verschwindet aus Listen und Auswahlfeldern, die Verknüpfung zum Konto entfällt. Ihre
+            Schlüssel bleiben zugeordnet und unverändert – widerrufen ist ein eigener Schritt.
+          </p>
+          <Formularfehler text={zustand.fehler} />
+          <div className="flex flex-wrap justify-end gap-2.5">
+            <Button onClick={() => dialog.current?.close()}>Abbrechen</Button>
+            <Button type="submit" variante="gefahr" disabled={laeuft}>
+              {laeuft ? "Archiviere …" : "Archivieren"}
+            </Button>
+          </div>
+        </form>
+      </dialog>
+    </>
+  );
+}

src/lib/personen.ts

@@ -0,0 +1,52 @@
+import { z } from "@/lib/validierung";
+
+/**
+ * Eingaben fuer Personen und den Self-Service (#013) – framework-frei, damit Service,
+ * Actions und Tests dieselben Regeln teilen.
+ */
+
+const optionalerText = (max: number) =>
+  z
+    .string()
+    .trim()
+    .max(max, `Höchstens ${max} Zeichen.`)
+    .nullish()
+    .transform((wert) => (wert ? wert : null));
+
+export const personEingabeSchema = z.object({
+  name: z.string().trim().min(1, "Bitte einen Namen angeben.").max(120, "Höchstens 120 Zeichen."),
+  email: z
+    .string()
+    .trim()
+    .toLowerCase()
+    .max(254)
+    .nullish()
+    .transform((wert) => (wert ? wert : null))
+    .refine(
+      (wert) => wert === null || z.email().safeParse(wert).success,
+      "Bitte eine gültige E-Mail-Adresse.",
+    ),
+  organisation: optionalerText(120),
+  notiz: optionalerText(1000),
+  benutzerId: z
+    .string()
+    .trim()
+    .max(64)
+    .nullish()
+    .transform((wert) => (wert ? wert : null)),
+});
+
+export type PersonEingabe = z.input<typeof personEingabeSchema>;
+export type PersonDaten = z.output<typeof personEingabeSchema>;
+
+/** Eigener Public Key im Self-Service: Zweck und die Zeile, sonst nichts. */
+export const eigenerKeySchema = z.object({
+  name: z.string().trim().min(1, "Bitte eine Bezeichnung angeben.").max(120, "Höchstens 120 Zeichen."),
+  publicKey: z
+    .string()
+    .trim()
+    .min(1, "Bitte den Public Key einfügen.")
+    .max(16 * 1024, "Der Text ist zu lang für einen Public Key."),
+});
+
+export type EigenerKeyEingabe = z.input<typeof eigenerKeySchema>;

src/server/actions/meine-schluessel.ts

@@ -0,0 +1,43 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { fehlerZustand, textfeld, type FormularZustand } from "@/server/actions/formular";
+import { rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { eigenenPublicKeyHinterlegen, eigenenSchluesselEntfernen } from "@/server/services/meine-schluessel";
+
+/**
+ * Self-Service (#013). Recht `eigeneSchluesselHinterlegen` hat jede Rolle; der Service
+ * arbeitet ausschliesslich mit der Person des angemeldeten Kontos.
+ */
+export type HinterlegenZustand = FormularZustand & { readonly erfolg?: string };
+
+export async function eigenenKeyHinterlegenAktion(
+  _vorher: HinterlegenZustand,
+  formular: FormData,
+): Promise<HinterlegenZustand> {
+  try {
+    const { benutzer } = await rechtErforderlich("eigeneSchluesselHinterlegen");
+    const neu = await eigenenPublicKeyHinterlegen(benutzer, {
+      name: textfeld(formular, "name") ?? "",
+      publicKey: textfeld(formular, "publicKey") ?? "",
+    });
+    revalidatePath("/meine-schluessel");
+    return { erfolg: `Hinterlegt: ${neu.fingerprint}` };
+  } catch (fehler) {
+    return fehlerZustand(fehler);
+  }
+}
+
+export async function eigenenKeyEntfernenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  try {
+    const { benutzer } = await rechtErforderlich("eigeneSchluesselHinterlegen");
+    await eigenenSchluesselEntfernen(benutzer, textfeld(formular, "id") ?? "");
+    revalidatePath("/meine-schluessel");
+    return {};
+  } catch (fehler) {
+    return fehlerZustand(fehler);
+  }
+}

src/server/actions/personen.ts

@@ -0,0 +1,68 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import type { PersonEingabe } from "@/lib/personen";
+import { akteurVon, fehlerZustand, textfeld, type FormularZustand } from "@/server/actions/formular";
+import { rechtErforderlich } from "@/server/auth/sitzungspflicht";
+import { personAnlegen, personArchivieren, personBearbeiten } from "@/server/services/personen";
+
+/**
+ * Formular-Aktionen fuer Personen (#013). Personen pflegt, wer Schluessel verwaltet (Admin,
+ * Operator) – eine Person ist die Klammer um Personen-Keys.
+ */
+
+function personFelder(formular: FormData): PersonEingabe {
+  return {
+    name: textfeld(formular, "name") ?? "",
+    email: textfeld(formular, "email"),
+    organisation: textfeld(formular, "organisation"),
+    notiz: textfeld(formular, "notiz"),
+    benutzerId: textfeld(formular, "benutzerId"),
+  };
+}
+
+export async function personAnlegenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  let id: string;
+  try {
+    const { benutzer } = await rechtErforderlich("schluesselVerwalten");
+    ({ id } = await personAnlegen(personFelder(formular), akteurVon(benutzer)));
+  } catch (fehler) {
+    return fehlerZustand(fehler);
+  }
+  revalidatePath("/personen");
+  redirect(`/personen/${id}`);
+}
+
+export async function personBearbeitenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  const id = textfeld(formular, "id") ?? "";
+  try {
+    const { benutzer } = await rechtErforderlich("schluesselVerwalten");
+    await personBearbeiten(id, personFelder(formular), akteurVon(benutzer));
+  } catch (fehler) {
+    return fehlerZustand(fehler);
+  }
+  revalidatePath("/personen", "layout");
+  redirect(`/personen/${id}`);
+}
+
+export async function personArchivierenAktion(
+  _vorher: FormularZustand,
+  formular: FormData,
+): Promise<FormularZustand> {
+  const id = textfeld(formular, "id") ?? "";
+  try {
+    const { benutzer } = await rechtErforderlich("schluesselVerwalten");
+    await personArchivieren(id, akteurVon(benutzer));
+  } catch (fehler) {
+    return fehlerZustand(fehler);
+  }
+  revalidatePath("/personen", "layout");
+  redirect("/personen");
+}

src/server/queries/personen.ts

@@ -0,0 +1,103 @@
+import type { Prisma } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+
+/**
+ * Lesemodelle fuer Personen (#013). Jede angemeldete Rolle darf sie sehen; Schluessel nur mit
+ * festem `select` ohne Chiffrat-Felder.
+ */
+
+export type PersonFilter = { readonly q?: string; readonly archivierte?: boolean };
+
+export async function personenListe(filter: PersonFilter = {}) {
+  const q = filter.q?.trim().slice(0, 100);
+  const where: Prisma.PersonWhereInput = {
+    ...(filter.archivierte ? {} : { archiviertAm: null }),
+    ...(q
+      ? {
+          OR: [
+            { name: { contains: q, mode: "insensitive" } },
+            { email: { contains: q, mode: "insensitive" } },
+            { organisation: { contains: q, mode: "insensitive" } },
+          ],
+        }
+      : {}),
+  };
+  const personen = await prisma.person.findMany({
+    where,
+    orderBy: { name: "asc" },
+    select: {
+      id: true,
+      name: true,
+      email: true,
+      organisation: true,
+      archiviertAm: true,
+      benutzer: { select: { id: true, name: true } },
+      _count: { select: { schluessel: { where: { status: "AKTIV" } } } },
+    },
+  });
+  return personen.map(({ _count, ...rest }) => ({ ...rest, aktiveSchluessel: _count.schluessel }));
+}
+
+export type PersonListenEintrag = Awaited<ReturnType<typeof personenListe>>[number];
+
+export async function personDetail(id: string) {
+  const person = await prisma.person.findUnique({
+    where: { id },
+    select: {
+      id: true,
+      name: true,
+      email: true,
+      organisation: true,
+      notiz: true,
+      archiviertAm: true,
+      angelegtAm: true,
+      benutzerId: true,
+      benutzer: { select: { id: true, name: true, email: true, rolle: true } },
+      schluessel: {
+        orderBy: [{ status: "asc" }, { name: "asc" }],
+        select: {
+          id: true,
+          name: true,
+          typ: true,
+          kategorie: true,
+          status: true,
+          publicKey: true,
+          fingerprint: true,
+          ablaufAm: true,
+          selbstHinterlegt: true,
+          _count: {
+            select: {
+              publicVerwendungen: { where: { zustand: { not: "ENTFERNT" } } },
+              privateVerwendungen: { where: { zustand: { not: "ENTFERNT" } } },
+            },
+          },
+        },
+      },
+    },
+  });
+  if (!person) return null;
+  return {
+    ...person,
+    schluessel: person.schluessel.map(({ _count, ...rest }) => ({
+      ...rest,
+      verwendungen: _count.publicVerwendungen + _count.privateVerwendungen,
+    })),
+  };
+}
+
+export type PersonDetail = NonNullable<Awaited<ReturnType<typeof personDetail>>>;
+
+/**
+ * Konten, die sich mit einer Person verknuepfen lassen: noch keiner Person zugeordnet, oder
+ * der Person `personId` selbst. Der Notfall-Admin ist kein Mensch mit eigenen Keys.
+ */
+export async function kontenAuswahl(personId?: string) {
+  return prisma.benutzer.findMany({
+    where: {
+      istNotfall: false,
+      OR: [{ person: null }, ...(personId ? [{ person: { id: personId } }] : [])],
+    },
+    orderBy: { name: "asc" },
+    select: { id: true, name: true, email: true },
+  });
+}

src/server/services/anmeldung.ts

@@ -73,6 +73,8 @@ export async function oidcBenutzerUebernehmen(anspruecke: OidcAnspruecke): Promi
   const daten = {
     oidcSub: anspruecke.sub,
     email: anspruecke.email,
+    // Fuer die Verknuepfung im Self-Service (#013).
+    emailBestaetigt: anspruecke.emailBestaetigt,
     name: anspruecke.name,
     rolle,
     letzteAnmeldungAm: new Date(),

src/server/services/meine-schluessel.ts

@@ -0,0 +1,195 @@
+import type { Benutzer } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { feldfehlerAus } from "@/lib/hosts";
+import { eigenerKeySchema, type EigenerKeyEingabe } from "@/lib/personen";
+import { FachFehler } from "@/server/services/fachfehler";
+import { istEindeutigkeitsFehler } from "@/server/services/hosts";
+import { protokollieren } from "@/server/services/protokoll";
+import { publicKeyAnlegen } from "@/server/services/schluessel";
+
+/**
+ * Self-Service „Meine Schluessel“ (#013, Freigabe Frage 4): jeder angemeldete Benutzer
+ * hinterlegt eigene Public Keys. Wirksam werden sie erst, wenn ein Operator oder Admin sie
+ * einem Host zuweist – hier wird nichts ausgerollt.
+ *
+ * Jede Funktion nimmt den angemeldeten Benutzer und arbeitet nur mit **seiner** Person; eine
+ * Schluessel-ID von aussen wird immer gegen sie geprueft.
+ */
+type Konto = Pick<Benutzer, "id" | "name" | "email" | "emailBestaetigt">;
+
+/**
+ * Liefert die Person des Kontos und legt sie beim ersten Aufruf an. Verknuepft per
+ * `benutzerId`, sonst per E-Mail – aber nur, wenn der Anbieter die Adresse bestaetigt hat und
+ * genau eine freie, nicht archivierte Person dazu passt.
+ */
+export async function eigenePersonSicherstellen(konto: Konto): Promise<{ id: string; name: string }> {
+  const vorhanden = await prisma.person.findUnique({
+    where: { benutzerId: konto.id },
+    select: { id: true, name: true },
+  });
+  if (vorhanden) return vorhanden;
+
+  const akteur = { id: konto.id, name: konto.name };
+  try {
+    if (konto.email && konto.emailBestaetigt) {
+      const passend = await prisma.person.findMany({
+        where: {
+          email: { equals: konto.email, mode: "insensitive" },
+          benutzerId: null,
+          archiviertAm: null,
+        },
+        select: { id: true },
+        take: 2,
+      });
+      // Bedingt: hat inzwischen jemand anderes die Person verknuepft, aendert sich nichts,
+      // und das Konto bekommt unten eine eigene Person.
+      const verknuepft =
+        passend.length === 1
+          ? await prisma.person.updateMany({
+              where: { id: passend[0]!.id, benutzerId: null },
+              data: { benutzerId: konto.id },
+            })
+          : { count: 0 };
+      if (verknuepft.count === 1) {
+        const person = await prisma.person.findUniqueOrThrow({
+          where: { benutzerId: konto.id },
+          select: { id: true, name: true },
+        });
+        await protokollieren({
+          akteur,
+          aktion: "person.verknuepft",
+          ergebnis: "ERFOLG",
+          details: { person: person.name, ueber: "email" },
+        });
+        return person;
+      }
+    }
+    const person = await prisma.person.create({
+      data: { name: konto.name, email: konto.email, benutzerId: konto.id },
+      select: { id: true, name: true },
+    });
+    await protokollieren({
+      akteur,
+      aktion: "person.angelegt",
+      ergebnis: "ERFOLG",
+      details: { name: konto.name, ueber: "selbstauskunft" },
+    });
+    return person;
+  } catch (fehler) {
+    // Zwei gleichzeitige erste Aufrufe: der zweite findet die Person des ersten.
+    if (istEindeutigkeitsFehler(fehler)) {
+      return prisma.person.findUniqueOrThrow({
+        where: { benutzerId: konto.id },
+        select: { id: true, name: true },
+      });
+    }
+    throw fehler;
+  }
+}
+
+/** Die eigenen Schluessel – mit genau den Feldern, die die Seite zeigt. */
+export async function eigeneSchluessel(konto: Konto) {
+  const person = await eigenePersonSicherstellen(konto);
+  const schluessel = await prisma.schluessel.findMany({
+    where: { personId: person.id },
+    orderBy: { angelegtAm: "desc" },
+    select: {
+      id: true,
+      name: true,
+      typ: true,
+      status: true,
+      publicKey: true,
+      fingerprint: true,
+      kommentar: true,
+      selbstHinterlegt: true,
+      angelegtAm: true,
+      _count: {
+        select: {
+          publicVerwendungen: { where: { zustand: { not: "ENTFERNT" } } },
+          privateVerwendungen: { where: { zustand: { not: "ENTFERNT" } } },
+        },
+      },
+    },
+  });
+  return {
+    person,
+    schluessel: schluessel.map(({ _count, ...rest }) => ({
+      ...rest,
+      verwendungen: _count.publicVerwendungen + _count.privateVerwendungen,
+    })),
+  };
+}
+
+export async function eigenenPublicKeyHinterlegen(konto: Konto, eingabe: EigenerKeyEingabe) {
+  const ergebnis = eigenerKeySchema.safeParse(eingabe);
+  if (!ergebnis.success) {
+    throw new FachFehler("Bitte die markierten Felder prüfen.", feldfehlerAus(ergebnis.error));
+  }
+  const person = await eigenePersonSicherstellen(konto);
+  return publicKeyAnlegen(
+    {
+      name: ergebnis.data.name,
+      slug: null,
+      kategorie: "PERSON",
+      publicKey: ergebnis.data.publicKey,
+      kommentar: null,
+      tags: [],
+      ablaufAm: null,
+      personId: person.id,
+      vorlageId: null,
+      selbstHinterlegt: true,
+    },
+    { id: konto.id, name: konto.name },
+    "schluessel.selbst_hinterlegt",
+  );
+}
+
+/**
+ * Entfernt einen eigenen, selbst hinterlegten Key, solange er nirgends zugewiesen ist – auch
+ * keine entfernte Verwendung, damit der Verlauf am Key nicht verloren geht. Fremde Keys sind
+ * fuer diese Funktion „nicht vorhanden“, damit sie nichts ueber fremde IDs verraet.
+ */
+export async function eigenenSchluesselEntfernen(konto: Konto, schluesselId: string): Promise<void> {
+  const person = await eigenePersonSicherstellen(konto);
+  const schluessel = await prisma.schluessel.findFirst({
+    where: { id: schluesselId, personId: person.id },
+    select: {
+      id: true,
+      name: true,
+      fingerprint: true,
+      selbstHinterlegt: true,
+      _count: { select: { publicVerwendungen: true, privateVerwendungen: true } },
+    },
+  });
+  if (!schluessel) throw new FachFehler("Diesen Schlüssel gibt es unter Ihren Schlüsseln nicht.");
+  if (!schluessel.selbstHinterlegt) {
+    throw new FachFehler(
+      "Diesen Schlüssel hat ein Operator oder Admin angelegt – bitte dort entfernen lassen.",
+    );
+  }
+  if (schluessel._count.publicVerwendungen + schluessel._count.privateVerwendungen > 0) {
+    throw new FachFehler(
+      "Der Schlüssel ist schon einem Host zugewiesen. Bitte einen Operator oder Admin bitten.",
+    );
+  }
+  await prisma.$transaction(async (tx) => {
+    // Bedingt geloescht: weist ein Operator den Key gerade zu, darf das Loeschen die neue
+    // Verwendung nicht per Cascade mitnehmen.
+    const geloescht = await tx.schluessel.deleteMany({
+      where: { id: schluessel.id, publicVerwendungen: { none: {} }, privateVerwendungen: { none: {} } },
+    });
+    if (geloescht.count !== 1) {
+      throw new FachFehler("Der Schlüssel wurde gerade zugewiesen und bleibt deshalb bestehen.");
+    }
+    await protokollieren(
+      {
+        akteur: { id: konto.id, name: konto.name },
+        aktion: "schluessel.selbst_entfernt",
+        ergebnis: "ERFOLG",
+        fingerprint: schluessel.fingerprint,
+        details: { name: schluessel.name },
+      },
+      tx,
+    );
+  });
+}

src/server/services/personen.ts

@@ -0,0 +1,139 @@
+import type { Prisma } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { feldfehlerAus } from "@/lib/hosts";
+import { personEingabeSchema, type PersonDaten, type PersonEingabe } from "@/lib/personen";
+import { FachFehler } from "@/server/services/fachfehler";
+import { istEindeutigkeitsFehler, type Akteur } from "@/server/services/hosts";
+import { protokollieren } from "@/server/services/protokoll";
+
+/**
+ * Personen anlegen, bearbeiten, archivieren (#013).
+ *
+ * Archivieren statt Loeschen: an einer Person haengen Schluessel und Protokoll-Bezuege. Die
+ * Schluessel bleiben der archivierten Person zugeordnet – wer bis wann welchen Key hatte, soll
+ * nachvollziehbar bleiben. Widerrufen ist ein eigener Schritt (#024).
+ */
+
+function pruefen(eingabe: PersonEingabe): PersonDaten {
+  const ergebnis = personEingabeSchema.safeParse(eingabe);
+  if (!ergebnis.success) {
+    throw new FachFehler("Bitte die markierten Felder prüfen.", feldfehlerAus(ergebnis.error));
+  }
+  return ergebnis.data;
+}
+
+function benutzerVergeben(): FachFehler {
+  return new FachFehler("Dieses Konto ist schon mit einer anderen Person verknüpft.", {
+    benutzerId: "Schon mit einer anderen Person verknüpft.",
+  });
+}
+
+/** Das gewaehlte Konto muss existieren und frei sein (oder schon zu dieser Person gehoeren). */
+async function benutzerPruefen(
+  tx: Prisma.TransactionClient,
+  benutzerId: string | null,
+  personId?: string,
+): Promise<string | null> {
+  if (!benutzerId) return null;
+  const benutzer = await tx.benutzer.findUnique({
+    where: { id: benutzerId },
+    select: { name: true, person: { select: { id: true } } },
+  });
+  if (!benutzer)
+    throw new FachFehler("Das gewählte Konto gibt es nicht.", { benutzerId: "Bitte neu wählen." });
+  if (benutzer.person && benutzer.person.id !== personId) throw benutzerVergeben();
+  return benutzer.name;
+}
+
+export async function personAnlegen(eingabe: PersonEingabe, akteur: Akteur) {
+  const daten = pruefen(eingabe);
+  try {
+    return await prisma.$transaction(async (tx) => {
+      const konto = await benutzerPruefen(tx, daten.benutzerId);
+      const person = await tx.person.create({ data: daten, select: { id: true, name: true } });
+      await protokollieren(
+        {
+          akteur,
+          aktion: "person.angelegt",
+          ergebnis: "ERFOLG",
+          details: { name: daten.name, email: daten.email, organisation: daten.organisation, konto },
+        },
+        tx,
+      );
+      return person;
+    });
+  } catch (fehler) {
+    if (istEindeutigkeitsFehler(fehler)) throw benutzerVergeben();
+    throw fehler;
+  }
+}
+
+export async function personBearbeiten(id: string, eingabe: PersonEingabe, akteur: Akteur) {
+  const daten = pruefen(eingabe);
+  const alt = await prisma.person.findUnique({
+    where: { id },
+    select: {
+      name: true,
+      email: true,
+      organisation: true,
+      notiz: true,
+      benutzerId: true,
+      archiviertAm: true,
+    },
+  });
+  if (!alt) throw new FachFehler("Diese Person gibt es nicht.");
+  if (alt.archiviertAm) throw new FachFehler("Archivierte Personen lassen sich nicht bearbeiten.");
+
+  const geaendert = Object.fromEntries(
+    (Object.keys(daten) as (keyof PersonDaten)[])
+      .filter((feld) => daten[feld] !== alt[feld])
+      // Die Notiz kann Persoenliches enthalten – im Protokoll steht nur, dass sie sich aenderte.
+      .map((feld) => [feld, feld === "notiz" ? "geändert" : { vorher: alt[feld], nachher: daten[feld] }]),
+  );
+  try {
+    return await prisma.$transaction(async (tx) => {
+      await benutzerPruefen(tx, daten.benutzerId, id);
+      const person = await tx.person.update({ where: { id }, data: daten, select: { id: true, name: true } });
+      if (Object.keys(geaendert).length > 0) {
+        await protokollieren(
+          { akteur, aktion: "person.geaendert", ergebnis: "ERFOLG", details: geaendert },
+          tx,
+        );
+      }
+      return person;
+    });
+  } catch (fehler) {
+    if (istEindeutigkeitsFehler(fehler)) throw benutzerVergeben();
+    throw fehler;
+  }
+}
+
+/**
+ * Archiviert eine Person. Die Verknuepfung zum Konto faellt weg, damit der Self-Service beim
+ * naechsten Aufruf nicht wieder bei einer archivierten Person landet.
+ */
+export async function personArchivieren(id: string, akteur: Akteur) {
+  const person = await prisma.person.findUnique({
+    where: { id },
+    select: { name: true, archiviertAm: true, _count: { select: { schluessel: true } } },
+  });
+  if (!person) throw new FachFehler("Diese Person gibt es nicht.");
+  if (person.archiviertAm) throw new FachFehler("Diese Person ist bereits archiviert.");
+  return prisma.$transaction(async (tx) => {
+    const archiviert = await tx.person.update({
+      where: { id },
+      data: { archiviertAm: new Date(), benutzerId: null },
+      select: { id: true },
+    });
+    await protokollieren(
+      {
+        akteur,
+        aktion: "person.archiviert",
+        ergebnis: "ERFOLG",
+        details: { name: person.name, schluessel: person._count.schluessel },
+      },
+      tx,
+    );
+    return archiviert;
+  });
+}

tests/e2e/schluessel.spec.ts

@@ -72,3 +72,23 @@ test("Leser sieht Schlüssel, darf aber keine anlegen", async ({ page }) => {
   await page.goto("/schluessel/neu");
   await expect(page).toHaveURL(/\/kein-zugriff/);
 });
+
+test("Leser hinterlegt einen eigenen Public Key und entfernt ihn wieder", async ({ page }) => {
+  const name = `${eindeutig()} Laptop`;
+  const paar = await schluesselpaarErzeugen("ED25519", { kommentar: "reader@laptop" });
+  await oidcAnmelden(page, "reader");
+  await page.getByRole("link", { name: "Meine Schlüssel" }).first().click();
+  await expect(page.getByRole("heading", { name: "Meine Schlüssel" })).toBeVisible();
+  await expect(page.getByText(/Wirksam erst, wenn ein Operator oder Admin/).first()).toBeVisible();
+
+  await page.getByLabel("Bezeichnung").fill(name);
+  await page.getByLabel("Public Key").fill(paar.publicKeyZeile);
+  await page.getByRole("button", { name: "Hinterlegen" }).click();
+  await expect(page.getByText(`Hinterlegt: ${paar.fingerprint}`)).toBeVisible();
+  const eintrag = page.locator("li", { hasText: name });
+  await expect(eintrag.getByText("noch nicht zugewiesen")).toBeVisible();
+
+  await eintrag.getByRole("button", { name: `${name} entfernen` }).click();
+  await page.getByRole("dialog").getByRole("button", { name: "Entfernen", exact: true }).click();
+  await expect(page.locator("li", { hasText: name })).toHaveCount(0);
+});

tests/personen.test.ts

@@ -0,0 +1,213 @@
+import { readFileSync } from "node:fs";
+import { afterAll, beforeEach, describe, expect, it } from "vitest";
+import type { Benutzer } from "@/generated/prisma/client";
+import { prisma } from "@/lib/db";
+import { darf } from "@/server/auth/rechte";
+import { kontenAuswahl, personDetail, personenListe } from "@/server/queries/personen";
+import { FachFehler } from "@/server/services/fachfehler";
+import {
+  eigenePersonSicherstellen,
+  eigenenPublicKeyHinterlegen,
+  eigenenSchluesselEntfernen,
+  eigeneSchluessel,
+} from "@/server/services/meine-schluessel";
+import { personAnlegen, personArchivieren, personBearbeiten } from "@/server/services/personen";
+import { publicKeyImportieren } from "@/server/services/schluessel";
+import { datenbankLeeren } from "./hilfen/db";
+import { warteschlangeStoppen } from "./hilfen/vorgang";
+import { ed25519Blob, zeile } from "./ssh/hilfen";
+
+/** Personen und Self-Service „Meine Schluessel“ (#013). */
+
+let operator: Benutzer;
+let leser: Benutzer;
+let andererLeser: Benutzer;
+
+beforeEach(async () => {
+  await datenbankLeeren();
+  operator = await prisma.benutzer.create({ data: { name: "Olga Operator", rolle: "OPERATOR" } });
+  leser = await prisma.benutzer.create({
+    data: { name: "Lea Leser", rolle: "LESER", email: "lea@example.org", emailBestaetigt: true },
+  });
+  andererLeser = await prisma.benutzer.create({
+    data: { name: "Max Mitleser", rolle: "LESER", email: "max@example.org", emailBestaetigt: true },
+  });
+});
+
+afterAll(async () => {
+  await warteschlangeStoppen();
+});
+
+async function fachfehlerVon(versuch: Promise<unknown>): Promise<FachFehler> {
+  const fehler = await versuch.then(
+    () => undefined,
+    (f: unknown) => f,
+  );
+  expect(fehler).toBeInstanceOf(FachFehler);
+  return fehler as FachFehler;
+}
+
+const akteur = () => ({ id: operator.id, name: operator.name });
+const neueZeile = (kommentar = "test") => zeile("ssh-ed25519", ed25519Blob(), kommentar);
+
+describe("Personen verwalten", () => {
+  it("legt an, bearbeitet, archiviert und protokolliert", async () => {
+    const person = await personAnlegen(
+      { name: "Anna Berger", email: "A.Berger@Example.org", organisation: "Netzwerk GmbH" },
+      akteur(),
+    );
+    const detail = await personDetail(person.id);
+    expect(detail).toMatchObject({ email: "a.berger@example.org", organisation: "Netzwerk GmbH" });
+
+    await personBearbeiten(
+      person.id,
+      { name: "Anna Berger", email: "a.berger@example.org", notiz: "privat" },
+      akteur(),
+    );
+    const geaendert = await prisma.protokoll.findFirstOrThrow({ where: { aktion: "person.geaendert" } });
+    // Die Notiz steht nicht im Protokoll, nur dass sie sich aenderte.
+    expect(JSON.stringify(geaendert.details)).not.toContain("privat");
+    expect(geaendert.details).toMatchObject({ notiz: "geändert", organisation: { vorher: "Netzwerk GmbH" } });
+
+    await personArchivieren(person.id, akteur());
+    expect((await personenListe()).map((p) => p.name)).toEqual([]);
+    expect((await personenListe({ archivierte: true })).map((p) => p.name)).toEqual(["Anna Berger"]);
+    await fachfehlerVon(personBearbeiten(person.id, { name: "X" }, akteur()));
+    expect(await prisma.protokoll.count({ where: { aktion: { startsWith: "person." } } })).toBe(3);
+  });
+
+  it("prueft E-Mail und verknuepft ein Konto nur einmal", async () => {
+    const fehler = await fachfehlerVon(personAnlegen({ name: "X", email: "keine-mail" }, akteur()));
+    expect(fehler.feldfehler["email"]).toBeDefined();
+
+    await personAnlegen({ name: "Lea", benutzerId: leser.id }, akteur());
+    const doppelt = await fachfehlerVon(personAnlegen({ name: "Lea 2", benutzerId: leser.id }, akteur()));
+    expect(doppelt.feldfehler["benutzerId"]).toBeDefined();
+    expect((await kontenAuswahl()).map((k) => k.name)).toEqual(["Max Mitleser", "Olga Operator"]);
+  });
+
+  it("loest beim Archivieren die Kontoverknuepfung", async () => {
+    const person = await personAnlegen({ name: "Lea", benutzerId: leser.id }, akteur());
+    await personArchivieren(person.id, akteur());
+    expect((await personDetail(person.id))?.benutzerId).toBeNull();
+    // Der Self-Service landet danach bei einer neuen Person, nicht bei der archivierten.
+    expect((await eigenePersonSicherstellen(leser)).id).not.toBe(person.id);
+  });
+});
+
+describe("Eigene Person", () => {
+  it("wird beim ersten Aufruf angelegt und danach wiederverwendet", async () => {
+    const [a, b] = await Promise.all([eigenePersonSicherstellen(leser), eigenePersonSicherstellen(leser)]);
+    expect(a.id).toBe(b.id);
+    expect(await prisma.person.count()).toBe(1);
+    expect((await personDetail(a.id))?.benutzerId).toBe(leser.id);
+  });
+
+  it("verknuepft per bestaetigter E-Mail mit einer vorhandenen Person", async () => {
+    const person = await personAnlegen({ name: "Lea Leser (IT)", email: "LEA@example.org" }, akteur());
+    expect((await eigenePersonSicherstellen(leser)).id).toBe(person.id);
+    expect(await prisma.protokoll.count({ where: { aktion: "person.verknuepft" } })).toBe(1);
+  });
+
+  it("verknuepft nicht ueber eine unbestaetigte Adresse", async () => {
+    const person = await personAnlegen({ name: "Chefin", email: "chefin@example.org" }, akteur());
+    const angreifer = await prisma.benutzer.create({
+      data: { name: "Mallory", rolle: "LESER", email: "chefin@example.org", emailBestaetigt: false },
+    });
+    expect((await eigenePersonSicherstellen(angreifer)).id).not.toBe(person.id);
+    expect((await personDetail(person.id))?.benutzerId).toBeNull();
+  });
+});
+
+describe("Meine Schluessel", () => {
+  it("hinterlegt eigene Public Keys als Personen-Keys", async () => {
+    const neu = await eigenenPublicKeyHinterlegen(leser, {
+      name: "Laptop",
+      publicKey: neueZeile("lea@laptop"),
+    });
+    const schluessel = await prisma.schluessel.findUniqueOrThrow({
+      where: { id: neu.id },
+      select: {
+        kategorie: true,
+        selbstHinterlegt: true,
+        personId: true,
+        erstelltVonId: true,
+        masterKeyVersion: true,
+      },
+    });
+    const person = await eigenePersonSicherstellen(leser);
+    expect(schluessel).toEqual({
+      kategorie: "PERSON",
+      selbstHinterlegt: true,
+      personId: person.id,
+      erstelltVonId: leser.id,
+      masterKeyVersion: null,
+    });
+    const eintrag = await prisma.protokoll.findFirstOrThrow({
+      where: { aktion: "schluessel.selbst_hinterlegt" },
+    });
+    expect(eintrag.akteurId).toBe(leser.id);
+  });
+
+  it("zeigt nur eigene Keys und laesst fremde nicht entfernen", async () => {
+    const eigener = await eigenenPublicKeyHinterlegen(leser, { name: "Meiner", publicKey: neueZeile() });
+    const fremder = await eigenenPublicKeyHinterlegen(andererLeser, {
+      name: "Fremd",
+      publicKey: neueZeile(),
+    });
+
+    expect((await eigeneSchluessel(leser)).schluessel.map((s) => s.name)).toEqual(["Meiner"]);
+    expect((await eigeneSchluessel(andererLeser)).schluessel.map((s) => s.name)).toEqual(["Fremd"]);
+
+    const fehler = await fachfehlerVon(eigenenSchluesselEntfernen(leser, fremder.id));
+    expect(fehler.message).toMatch(/unter Ihren Schlüsseln nicht/);
+    expect(await prisma.schluessel.count({ where: { id: fremder.id } })).toBe(1);
+
+    await eigenenSchluesselEntfernen(leser, eigener.id);
+    expect(await prisma.schluessel.count({ where: { id: eigener.id } })).toBe(0);
+    expect(await prisma.protokoll.count({ where: { aktion: "schluessel.selbst_entfernt" } })).toBe(1);
+  });
+
+  it("entfernt keine zugewiesenen und keine von Operatoren angelegten Keys", async () => {
+    const zugewiesen = await eigenenPublicKeyHinterlegen(leser, {
+      name: "Zugewiesen",
+      publicKey: neueZeile(),
+    });
+    const host = await prisma.host.create({ data: { name: "srv-test01", adresse: "10.0.0.1" } });
+    await prisma.publicVerwendung.create({
+      data: { schluesselId: zugewiesen.id, hostId: host.id, zielbenutzer: "lea" },
+    });
+    await fachfehlerVon(eigenenSchluesselEntfernen(leser, zugewiesen.id));
+
+    const person = await eigenePersonSicherstellen(leser);
+    const vomOperator = await publicKeyImportieren(
+      { name: "Vom Operator", kategorie: "PERSON", publicKey: neueZeile(), personId: person.id },
+      akteur(),
+    );
+    await fachfehlerVon(eigenenSchluesselEntfernen(leser, vomOperator.id));
+    expect(await prisma.schluessel.count()).toBe(2);
+  });
+
+  it("meldet Duplikate auch im Self-Service", async () => {
+    const z = neueZeile();
+    await eigenenPublicKeyHinterlegen(leser, { name: "Einmal", publicKey: z });
+    const fehler = await fachfehlerVon(
+      eigenenPublicKeyHinterlegen(andererLeser, { name: "Nochmal", publicKey: z }),
+    );
+    expect(fehler.message).toMatch(/bereits verwaltet/);
+  });
+});
+
+describe("Rechte (Freigabe Frage 4)", () => {
+  it("Leser darf eigene Keys hinterlegen, aber weder verwalten noch zuweisen", () => {
+    expect(darf("LESER", "eigeneSchluesselHinterlegen")).toBe(true);
+    expect(darf("LESER", "schluesselVerwalten")).toBe(false);
+    expect(darf("LESER", "publicKeyAusrollen")).toBe(false);
+  });
+
+  it("die Self-Service-Aktionen verlangen das Self-Service-Recht und reichen nur den eigenen Benutzer weiter", () => {
+    const text = readFileSync("src/server/actions/meine-schluessel.ts", "utf8");
+    expect(text.match(/rechtErforderlich\("eigeneSchluesselHinterlegen"\)/g)).toHaveLength(2);
+    expect(text).not.toMatch(/personId/);
+  });
+});