Personalakte als Aktenblatt, Status als Etiketten, Verknüpfen von beiden Seiten

Das Formular der Personalabteilung ist übernommen, nicht durch eine
Bildschirmansicht ersetzt: schwarzer Rahmen, Kopf mit Kennung und
Klassifizierungsbalken, Raster aus fünf Spalten, Unterschriftenzeilen,
Fußzeile. Es steht bewusst außerhalb des Design-Systems - es wird gedruckt und
muss auf Papier aussehen wie das Blatt daneben.

Datengetrieben bleibt es trotzdem. Kein Feld steht im Programm: sheetTitle und
sheetSubtitle an der Vorlage, span für die Zellbreite, rows für das Lichtbild,
dateKey für das Datum unter einer Unterschrift, slot für den
Klassifizierungsbalken. Eine weitere Dokumentart mit layout = DOSSIER braucht
keine Zeile Code.

Der Balken zeigt die Foundation-Stufe aus der neuen Tabelle
FoundationClearance. Sie ist Inhalt, kein Zugriff - was jemand sehen darf,
entscheidet weiterhin allein die interne Stufe. Ohne Auswahl bleibt der Balken
neutral, statt eine Einstufung zu behaupten.

Die Dienstnummer ist entfallen, es gibt sie nicht. Der Status ist zu mehreren
Etiketten geworden: "Gekündigt" und "Verhaftet" schließen einander nicht aus.
Unbekannte Schlüssel werden verworfen und die Reihenfolge kommt aus der
Konfiguration, nicht aus der Eingabe.

PersonnelAssignment hängt AfiS-Mitglieder an eine Person - Aktenführung,
Ermittler, Ansprechpartner - und ist zugleich der ausnahmsweise Zugang, wie
CaseParticipant bei der Fallakte. Betroffen zu sein gibt weiterhin keinen
Zugang: das ist eine Eigenschaft der Person, die Zuordnung eine Entscheidung
der Abteilung.

Fall und Person lassen sich von beiden Seiten verknüpfen und schon beim
Anlegen einer Fallakte. Alle drei Wege laufen in addParticipant zusammen.

Noch offen: das Lichtbild. Feldtyp und Platz stehen, hochladen kommt mit der
Prüfkette in Phase 5 - ein Bild als Data-URL im Abschnittswert verstiesse
gegen harte Regel 4.

102 Tests im Web-Paket, davon sechs auf dem gerenderten Blatt selbst.

packages/db/prisma/migrations/20260902190000_personalakte_aktenblatt/migration.sql

@@ -0,0 +1,128 @@
+-- Die Personalakte, wie die Abteilung sie wirklich führt.
+--
+-- Drei Änderungen: die Dienstnummer entfällt (es gibt sie nicht), der Status
+-- wird zu mehreren Etiketten statt eines Wertes, und AfiS-Mitglieder lassen
+-- sich an eine Person hängen.
+
+-- ===========================================================================
+-- 1. Dienstnummer entfällt
+--
+--    Sie steckt im Suchvektor und in einem Trigram-Index, beide müssen vor
+--    dem Löschen der Spalte weg. Der Trigger wird danach ohne sie neu gesetzt.
+-- ===========================================================================
+
+DROP TRIGGER IF EXISTS personnel_search_trg ON "PersonnelFile";
+DROP INDEX IF EXISTS "PersonnelFile_serviceNumber_key";
+ALTER TABLE "PersonnelFile" DROP COLUMN "serviceNumber";
+
+-- ===========================================================================
+-- 2. Status als Etiketten
+--
+--    "Gekündigt" und "Verhaftet" schließen einander nicht aus, ein einzelnes
+--    Feld zwingt aber zur Wahl. Der bisherige Wert wandert als Freitext in die
+--    Anmerkung, damit nichts verloren geht: er lässt sich nicht verlässlich
+--    auf die neuen Schlüssel abbilden.
+-- ===========================================================================
+
+ALTER TABLE "PersonnelFile"
+  ADD COLUMN "statusTags" TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[];
+
+UPDATE "PersonnelFile"
+   SET "note" = COALESCE(NULLIF("note", '') || E'\n', '') || 'Früherer Status: ' || "status"
+ WHERE "status" IS NOT NULL AND "status" <> '';
+
+ALTER TABLE "PersonnelFile" DROP COLUMN "status";
+
+CREATE INDEX "PersonnelFile_statusTags_idx" ON "PersonnelFile" USING GIN ("statusTags");
+
+CREATE TABLE "PersonnelStatusTag" (
+    "key"        TEXT    NOT NULL,
+    "name"       TEXT    NOT NULL,
+    "colorToken" TEXT    NOT NULL DEFAULT 'stamp-0',
+    "sortOrder"  INTEGER NOT NULL DEFAULT 0,
+    "isActive"   BOOLEAN NOT NULL DEFAULT true,
+
+    CONSTRAINT "PersonnelStatusTag_pkey" PRIMARY KEY ("key")
+);
+
+CREATE INDEX "PersonnelStatusTag_isActive_sortOrder_idx"
+  ON "PersonnelStatusTag"("isActive", "sortOrder");
+
+-- ===========================================================================
+-- 3. Suchvektor ohne Dienstnummer, dafür mit den Etiketten
+-- ===========================================================================
+
+CREATE OR REPLACE FUNCTION personnel_refresh_search_vector() RETURNS trigger AS $$
+BEGIN
+  NEW."searchVector" :=
+    setweight(to_tsvector('german', coalesce(NEW."displayName", '')), 'A')
+    ||
+    setweight(to_tsvector('german',
+      coalesce(NEW."rank", '') || ' ' || coalesce(NEW."department", '') || ' ' ||
+      coalesce(array_to_string(NEW."statusTags", ' '), '')), 'B');
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER personnel_search_trg
+  BEFORE INSERT OR UPDATE OF "displayName", "rank", "department", "statusTags"
+  ON "PersonnelFile"
+  FOR EACH ROW EXECUTE FUNCTION personnel_refresh_search_vector();
+
+-- Bestehende Zeilen einmal nachziehen, sonst tragen sie den alten Vektor.
+UPDATE "PersonnelFile" SET "displayName" = "displayName";
+
+-- ===========================================================================
+-- 4. AfiS-Mitglieder an einer Personalakte
+--
+--    Wie CaseParticipant bei der Fallakte zugleich der Weg zum ausnahmsweisen
+--    Zugang: wer hier steht, liest die Akte unabhängig von seiner Stufe.
+-- ===========================================================================
+
+CREATE TYPE "AssignmentRole" AS ENUM ('HANDLER', 'INVESTIGATOR', 'CONTACT');
+
+CREATE TABLE "PersonnelAssignment" (
+    "id"              TEXT             NOT NULL,
+    "personnelFileId" TEXT             NOT NULL,
+    "userId"          TEXT             NOT NULL,
+    "role"            "AssignmentRole" NOT NULL,
+    "addedById"       TEXT,
+    "createdAt"       TIMESTAMP(3)     NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "PersonnelAssignment_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX "PersonnelAssignment_personnelFileId_userId_role_key"
+  ON "PersonnelAssignment"("personnelFileId", "userId", "role");
+CREATE INDEX "PersonnelAssignment_userId_idx" ON "PersonnelAssignment"("userId");
+
+ALTER TABLE "PersonnelAssignment" ADD CONSTRAINT "PersonnelAssignment_personnelFileId_fkey"
+  FOREIGN KEY ("personnelFileId") REFERENCES "PersonnelFile"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "PersonnelAssignment" ADD CONSTRAINT "PersonnelAssignment_userId_fkey"
+  FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- ===========================================================================
+-- 5. Freigabestufen der Foundation
+--
+--    Stehen im Kopf eines Dokuments und steuern **keinen** Zugriff. Getrennte
+--    Tabelle, weil sie im Adminbereich pflegbar sein sollen wie die internen.
+-- ===========================================================================
+
+CREATE TABLE "FoundationClearance" (
+    "level"     INTEGER NOT NULL,
+    "name"      TEXT    NOT NULL,
+    "colorHex"  TEXT    NOT NULL,
+    "sortOrder" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "FoundationClearance_pkey" PRIMARY KEY ("level")
+);
+
+-- ===========================================================================
+-- 6. Kopfzeilen des Aktenblatts an der Vorlage
+-- ===========================================================================
+
+ALTER TYPE "DocumentLayout" ADD VALUE 'DOSSIER';
+
+ALTER TABLE "DocumentTemplate"
+  ADD COLUMN "sheetTitle"    TEXT,
+  ADD COLUMN "sheetSubtitle" TEXT;

packages/db/prisma/schema.prisma

@@ -47,6 +47,7 @@ model User {
   sessions       Session[]
   personnelFiles PersonnelFile[]
   participations CaseParticipant[]
+  assignments    PersonnelAssignment[]
   exclusions     CaseExclusion[]
   watches        Watch[]
   readMarkers    ReadMarker[]
@@ -157,6 +158,12 @@ model DocumentTemplate {
   /// Bestimmt allein das Aussehen, nicht den Zugriff. Siehe docs/08.
   layout DocumentLayout @default(FORM)
 
+  /// Kopfzeilen des Aktenblatts (layout = DOSSIER). Stehen in der Vorlage,
+  /// damit eine weitere Dokumentart dieselbe Bauform mit eigener Beschriftung
+  /// verwenden kann.
+  sheetTitle    String?
+  sheetSubtitle String?
+
   /// Muster des Aktenzeichens, siehe docs/13-entscheidungen.md. Die Abteilung
   /// fuehrt gewachsene Praefixe wie "AKT-PA"; der Nummernkreis laeuft je
   /// Praefix und Jahr, damit zwei Fallarten sich nicht in die Quere kommen.
@@ -192,6 +199,9 @@ enum DocumentLayout {
   PROSE
   /// ein einzelnes Freitextfeld, dargestellt wie ein Vermerk
   NOTE
+  /// Aktenblatt der Foundation: schwarzer Rahmen, Kopf mit Kennung,
+  /// Klassifizierungsbalken, Feldraster, Unterschriftenzeilen, Fusszeile
+  DOSSIER
 }
 
 // ---------------------------------------------------------------------------
@@ -439,14 +449,20 @@ enum LinkKind {
 // Personalakten
 // ---------------------------------------------------------------------------
 
+/// Akte zu einer Person. Ueberwiegend zu **Externen** — Sicherheitsdienst,
+/// Zeugen, Vertragspartner — die kein Discord-Konto haben. `userId` bleibt
+/// deshalb der Ausnahmefall, nicht die Regel.
 model PersonnelFile {
   id          String  @id @default(uuid(7))
   userId      String? // null bei Personen ohne Discord-Konto
   displayName String
-  serviceNumber  String? @unique
   rank        String?
   department  String?
-  status         String?
+
+  /// Mehrere Etiketten zugleich: "Gekuendigt" und "Verhaftet" schliessen
+  /// einander nicht aus. Die Werte sind Schluessel aus PersonnelStatusTag.
+  statusTags String[] @default([])
+
   classification Int  @default(1)
   fields         Json @default("{}")
   /// Freitext im Kopf der Akte, etwa "kein Discord-Konto, Aktenlage aus 2025".
@@ -461,14 +477,68 @@ model PersonnelFile {
   user         User?                 @relation(fields: [userId], references: [id])
   participants CaseParticipant[]
   documents    Document[]
+  assignments  PersonnelAssignment[]
 
   @@index([displayName])
   @@index([userId])
   @@index([classification])
+  @@index([statusTags], type: Gin)
   @@index([searchVector], map: "personnel_search_idx", type: Gin)
   @@index([displayName(ops: raw("gin_trgm_ops"))], map: "personnel_name_trgm_idx", type: Gin)
 }
 
+/// Auswahl der Status-Etiketten, im Adminbereich pflegbar. Die Namen sind
+/// Daten, keine Oberflaechentexte — siehe CLAUDE.md, Sprachkonvention.
+model PersonnelStatusTag {
+  key        String  @id // "tot", "gekuendigt"
+  name       String // "Tot", "Gekuendigt"
+  colorToken String  @default("stamp-0")
+  sortOrder  Int     @default(0)
+  isActive   Boolean @default(true)
+
+  @@index([isActive, sortOrder])
+}
+
+/// Ein AfiS-Mitglied, das an dieser Personalakte haengt: Bearbeiter,
+/// ermittelnder Beamter, Ansprechpartner.
+///
+/// Wie `CaseParticipant` bei der Fallakte ist das zugleich der Weg zum
+/// **ausnahmsweisen Zugang**: wer hier eingetragen ist, liest die Akte
+/// unabhaengig von seiner Freigabestufe. Siehe docs/13-entscheidungen.md.
+model PersonnelAssignment {
+  id              String            @id @default(uuid(7))
+  personnelFileId String
+  userId          String
+  role            AssignmentRole
+  addedById       String?
+  createdAt       DateTime          @default(now())
+
+  personnelFile PersonnelFile @relation(fields: [personnelFileId], references: [id], onDelete: Cascade)
+  user          User          @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([personnelFileId, userId, role])
+  @@index([userId])
+}
+
+enum AssignmentRole {
+  /// fuehrt die Akte
+  HANDLER
+  /// ermittelt gegen oder ueber die Person
+  INVESTIGATOR
+  /// Ansprechpartner, ohne eigene Ermittlung
+  CONTACT
+}
+
+/// Die Freigabestufen der Foundation, wie sie im Kopf eines Dokuments stehen.
+/// **Sie steuern keinen Zugriff** — das tut allein ClearanceLevelConfig.
+/// Siehe docs/13-entscheidungen.md, "Zwei Freigaben im Kopf".
+model FoundationClearance {
+  level     Int    @id // 1..5
+  name      String // "Streng Geheim"
+  colorHex  String // Balkenfarbe im Aktenblatt
+  sortOrder Int    @default(0)
+}
+
 // ---------------------------------------------------------------------------
 // Dokumente
 // ---------------------------------------------------------------------------

packages/db/prisma/seed.ts

@@ -41,7 +41,9 @@ type Vorlage = {
   name: string
   description: string
   uses?: ('CASE' | 'CASE_DOCUMENT' | 'PERSON_DOCUMENT' | 'STANDALONE')[]
-  layout?: 'FORM' | 'PROSE' | 'NOTE'
+  layout?: 'FORM' | 'PROSE' | 'NOTE' | 'DOSSIER'
+  sheetTitle?: string
+  sheetSubtitle?: string
   numberPrefix?: string
   numberPadding?: number
   fields?: unknown[]
@@ -114,6 +116,88 @@ const TEMPLATE_FIELDS = [
   },
 ]
 
+/**
+ * Status einer Person. Mehrere zugleich möglich: "Gekündigt" und "Verhaftet"
+ * schließen einander nicht aus. Im Adminbereich erweiterbar.
+ */
+const STATUS_TAGS = [
+  { key: 'lebt', name: 'Lebt', colorToken: 'stamp-2', sortOrder: 10 },
+  { key: 'im_dienst', name: 'Im Dienst', colorToken: 'stamp-2', sortOrder: 20 },
+  { key: 'beurlaubt', name: 'Beurlaubt', colorToken: 'stamp-1', sortOrder: 30 },
+  { key: 'suspendiert', name: 'Suspendiert', colorToken: 'stamp-3', sortOrder: 40 },
+  { key: 'gekuendigt', name: 'Gekündigt', colorToken: 'stamp-3', sortOrder: 50 },
+  { key: 'verhaftet', name: 'Verhaftet', colorToken: 'stamp-4', sortOrder: 60 },
+  { key: 'vermisst', name: 'Vermisst', colorToken: 'stamp-4', sortOrder: 70 },
+  { key: 'amnestiert', name: 'Amnestiert', colorToken: 'stamp-5', sortOrder: 80 },
+  { key: 'tot', name: 'Tot', colorToken: 'stamp-4', sortOrder: 90 },
+]
+
+/**
+ * Die Freigabestufen der Foundation, wie sie im Kopf eines Aktenblatts stehen.
+ * **Sie steuern keinen Zugriff.** Das tut allein die interne Stufe.
+ * Siehe docs/13-entscheidungen.md, "Zwei Freigaben im Kopf".
+ */
+const FOUNDATION_CLEARANCES = [
+  { level: 1, name: 'Vertraulich', colorHex: '#1e3a5f', sortOrder: 10 },
+  { level: 2, name: 'Eingeschränkt', colorHex: '#1a4d2e', sortOrder: 20 },
+  { level: 3, name: 'Geheim', colorHex: '#7c2d12', sortOrder: 30 },
+  { level: 4, name: 'Streng Geheim', colorHex: '#450a0a', sortOrder: 40 },
+  { level: 5, name: 'Thaumiel', colorHex: '#2d0060', sortOrder: 50 },
+]
+
+/**
+ * Das Aktenblatt der Personalabteilung, nachgebaut nach dem Formular, das die
+ * Abteilung bislang von Hand ausgefüllt hat. Reihenfolge und Breiten (`span`,
+ * vier Spalten) ergeben genau dessen Raster.
+ */
+const PERSONALAKTE_FIELDS = [
+  {
+    key: 'foundation_klassifikation',
+    label: 'Klassifikation',
+    type: 'select',
+    options: ['1', '2', '3', '4', '5'],
+    slot: 'classbar',
+    help: 'Steht im Balken des Blattes. Steuert keinen Zugriff im Aktensystem.',
+  },
+  { key: 'lichtbild', label: 'Lichtbild', type: 'photo', rows: 4 },
+  { key: 'name', label: 'Name', type: 'shorttext', span: 2, required: true },
+  { key: 'vorname', label: 'Vorname', type: 'shorttext', span: 2, required: true },
+  { key: 'alter', label: 'Alter', type: 'shorttext', span: 2 },
+  { key: 'geschlecht', label: 'Geschlecht', type: 'shorttext', span: 2 },
+  { key: 'groesse', label: 'Größe', type: 'shorttext', span: 4 },
+  { key: 'abteilung', label: 'Abteilung', type: 'shorttext', span: 2 },
+  { key: 'dienstgrad', label: 'Dienstgrad', type: 'shorttext', span: 2 },
+  {
+    key: 'sicherheitsfreigabe',
+    label: 'Sicherheitsfreigabe',
+    type: 'select',
+    options: ['0', '1', '2', '3', '4', '5'],
+    span: 3,
+    emphasis: true,
+    help: 'Steht im Kopf des Blattes und steuert keinen Zugriff im Aktensystem.',
+  },
+  { key: 'wissensfreigabe', label: 'Wissensfreigabe', type: 'shorttext', span: 2, emphasis: true },
+  { key: 'konfession', label: 'Konfession', type: 'shorttext', span: 2 },
+  { key: 'adresse', label: 'Adresse', type: 'shorttext', span: 3 },
+  { key: 'anmerkungen', label: 'Anmerkungen / Bemerkungen', type: 'longtext', span: 5 },
+  {
+    key: 'personalarbeiter',
+    label: 'Personalarbeiter',
+    type: 'signature',
+    span: 3,
+    dateKey: 'personalarbeiter_datum',
+  },
+  { key: 'personalarbeiter_datum', label: 'Datum Personalarbeiter', type: 'date' },
+  {
+    key: 'standortleiter',
+    label: 'Standortleiter',
+    type: 'signature',
+    span: 2,
+    dateKey: 'standortleiter_datum',
+  },
+  { key: 'standortleiter_datum', label: 'Datum Standortleiter', type: 'date' },
+]
+
 /**
  * Dokumentarten. Sie hängen an einer Fallakte, an einer Personalakte oder an
  * nichts — was davon, steht in `uses`. Eine weitere Art anzulegen ist ein
@@ -121,6 +205,17 @@ const TEMPLATE_FIELDS = [
  * Siehe docs/13-entscheidungen.md.
  */
 const DOCUMENT_TEMPLATES: Vorlage[] = [
+  {
+    key: 'personalakte',
+    name: 'Personalakte',
+    description: 'Das Aktenblatt der Personalabteilung, meist der erste Eintrag zu einer Person',
+    uses: ['PERSON_DOCUMENT'],
+    layout: 'DOSSIER',
+    sheetTitle: 'SCP Foundation',
+    sheetSubtitle: 'Personalakte // Personalabteilung',
+    numberPrefix: 'PA',
+    fields: PERSONALAKTE_FIELDS,
+  },
   {
     key: 'vermerk',
     name: 'Vermerk',
@@ -233,6 +328,24 @@ async function main(): Promise<void> {
   })
   console.log('[seed] Änderungsrichtlinie GRACE_WINDOW, 15 Minuten')
 
+  for (const tag of STATUS_TAGS) {
+    await db.personnelStatusTag.upsert({
+      where: { key: tag.key },
+      create: tag,
+      update: { name: tag.name, colorToken: tag.colorToken, sortOrder: tag.sortOrder },
+    })
+  }
+  console.log(`[seed] ${STATUS_TAGS.length} Status-Etiketten`)
+
+  for (const stufe of FOUNDATION_CLEARANCES) {
+    await db.foundationClearance.upsert({
+      where: { level: stufe.level },
+      create: stufe,
+      update: { name: stufe.name, colorHex: stufe.colorHex, sortOrder: stufe.sortOrder },
+    })
+  }
+  console.log(`[seed] ${FOUNDATION_CLEARANCES.length} Foundation-Freigabestufen`)
+
   const alle = [...TEMPLATES, ...DOCUMENT_TEMPLATES]
   for (const template of alle) {
     const fields = (template.fields ?? TEMPLATE_FIELDS) as object[]
@@ -245,6 +358,8 @@ async function main(): Promise<void> {
         description: template.description,
         uses,
         layout: template.layout ?? 'FORM',
+        sheetTitle: template.sheetTitle ?? null,
+        sheetSubtitle: template.sheetSubtitle ?? null,
         numberPrefix: template.numberPrefix ?? 'AfiS',
         numberPadding: template.numberPadding ?? 4,
         version: 1,
@@ -259,6 +374,8 @@ async function main(): Promise<void> {
         description: template.description,
         uses,
         layout: template.layout ?? 'FORM',
+        sheetTitle: template.sheetTitle ?? null,
+        sheetSubtitle: template.sheetSubtitle ?? null,
         fields,
       },
     })

web/app/(app)/dokumente/[documentNumber]/page.tsx

@@ -15,6 +15,8 @@ import { de } from '@/lib/i18n/de'
 import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
 import { SkeletonLine } from '@/components/Skeleton'
 import { Sections } from '@/components/sections/Sections'
+import { Sheet } from '@/components/documents/Sheet'
+import { SheetSwitch } from '@/components/documents/SheetSwitch'
 import { saveDocumentSectionAction } from '../actions'
 import { DocumentActions } from './DocumentActions'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
@@ -35,12 +37,19 @@ async function Body({
   permissions,
   canEdit,
 }: {
-  document: { id: string; templateId: string; documentNumber: string }
+  document: {
+    id: string
+    templateId: string
+    documentNumber: string
+    title: string
+    layout: string
+    createdAt: Date
+  }
   permissions: EffectivePermissions
   canEdit: boolean
 }) {
   const sections = await loadDocumentSections(permissions, document)
-  return (
+  const editor = (
     <Sections
       scope={`dokument:${document.documentNumber}`}
       save={saveDocumentSectionAction.bind(null, document.documentNumber)}
@@ -48,6 +57,36 @@ async function Body({
       canEdit={canEdit}
     />
   )
+
+  if (document.layout !== 'DOSSIER') return editor
+
+  // Das Aktenblatt braucht die Kopfzeilen der Vorlage und die
+  // Foundation-Stufen für den Balken. Beide steuern keinen Zugriff.
+  const [template, foundationLevels] = await Promise.all([
+    db.documentTemplate.findUnique({
+      where: { id: document.templateId },
+      select: { sheetTitle: true, sheetSubtitle: true, name: true },
+    }),
+    db.foundationClearance.findMany({ orderBy: { sortOrder: 'asc' } }),
+  ])
+
+  return (
+    <SheetSwitch
+      canEdit={canEdit}
+      editor={editor}
+      sheet={
+        <Sheet
+          sections={sections}
+          title={template?.sheetTitle ?? de.app.name}
+          subtitle={template?.sheetSubtitle ?? template?.name ?? document.title}
+          documentNumber={document.documentNumber}
+          issuedAt={document.createdAt}
+          foundationLevels={foundationLevels}
+          footerNote={de.document.footerNote}
+        />
+      }
+    />
+  )
 }
 
 /**

web/app/(app)/faelle/actions.ts

@@ -25,6 +25,8 @@ const createSchema = z.object({
   title: z.string().trim().min(3).max(200),
   classification: z.coerce.number().int().min(0).max(5),
   templateKey: z.string().min(1),
+  /** Betroffene Person, gleich beim Anlegen verknüpft. Optional. */
+  personnelFileId: z.string().max(64).optional(),
 })
 
 export type CreateState = { error?: string }
@@ -43,6 +45,7 @@ export async function createCaseAction(
     title: formData.get('title'),
     classification: formData.get('classification'),
     templateKey: formData.get('templateKey'),
+    personnelFileId: formData.get('personnelFileId') || undefined,
   })
   if (!parsed.success) return { error: de.actionErrors.default! }
 
@@ -50,6 +53,16 @@ export async function createCaseAction(
   try {
     const created = await createCase(user.permissions, parsed.data)
     caseNumber = created.caseNumber
+
+    // Die betroffene Person gleich mitverknüpfen, damit sie nicht in einem
+    // zweiten Schritt vergessen wird. Scheitert das, steht die Akte trotzdem.
+    if (parsed.data.personnelFileId) {
+      await addParticipant(user.permissions, {
+        caseNumber,
+        role: 'SUBJECT',
+        personnelFileId: parsed.data.personnelFileId,
+      })
+    }
   } catch (error) {
     return { error: toMessage(error) }
   }

web/app/(app)/faelle/neu/NewCaseForm.tsx

@@ -7,10 +7,12 @@ import { createCaseAction, type CreateState } from '../actions'
 export function NewCaseForm({
   templates,
   levels,
+  people,
   defaultLevel,
 }: {
   templates: { key: string; name: string }[]
   levels: { level: number; name: string }[]
+  people: { id: string; displayName: string }[]
   defaultLevel: number
 }) {
   const [state, action, pending] = useActionState<CreateState, FormData>(createCaseAction, {})
@@ -68,6 +70,29 @@ export function NewCaseForm({
         </select>
       </div>
 
+      {people.length > 0 ? (
+        <div>
+          <label htmlFor="personnelFileId" className="font-condensed text-xs text-text-dim">
+            {de.case.subject}
+          </label>
+          {/* Gleich beim Anlegen verknüpfen erspart den zweiten Schritt, den
+              man sonst vergisst. Nachträglich geht es genauso. */}
+          <select
+            id="personnelFileId"
+            name="personnelFileId"
+            defaultValue=""
+            className="mt-1.5 block w-full border border-line bg-raised px-3 py-2 text-sm"
+          >
+            <option value="">{de.case.subjectNone}</option>
+            {people.map((person) => (
+              <option key={person.id} value={person.id}>
+                {person.displayName}
+              </option>
+            ))}
+          </select>
+        </div>
+      ) : null}
+
       <div className="flex items-center gap-3">
         <button
           type="submit"

web/app/(app)/faelle/neu/page.tsx

@@ -1,6 +1,7 @@
 import type { Metadata } from 'next'
 import { db } from '@/lib/db'
 import { requirePermission } from '@/lib/auth/current'
+import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import { de } from '@/lib/i18n/de'
 import { NewCaseForm } from './NewCaseForm'
 
@@ -10,7 +11,7 @@ export const dynamic = 'force-dynamic'
 export default async function NewCasePage() {
   const user = await requirePermission('case.create')
 
-  const [templates, levels] = await Promise.all([
+  const [templates, levels, people] = await Promise.all([
     db.documentTemplate.findMany({
       // Nur Fallarten. Eine Vorlage für Dokumente legt keine Akte an.
       where: { isActive: true, uses: { has: 'CASE' } },
@@ -19,6 +20,16 @@ export default async function NewCasePage() {
       select: { key: true, name: true },
     }),
     db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    // Nur Personalakten, die der Anlegende sehen darf, und nur mit dem Recht
+    // dazu: sonst verriete die Auswahlliste ihre Existenz.
+    user.permissions.isAdmin || user.permissions.permissions.has('personnel.read')
+      ? db.personnelFile.findMany({
+          where: visiblePersonnelWhere(user.permissions),
+          orderBy: { displayName: 'asc' },
+          take: 200,
+          select: { id: true, displayName: true },
+        })
+      : Promise.resolve([]),
   ])
 
   return (
@@ -27,6 +38,7 @@ export default async function NewCasePage() {
       <NewCaseForm
         templates={templates}
         levels={levels.filter((level) => level.level <= user.permissions.clearanceLevel)}
+        people={people}
         defaultLevel={Math.min(1, user.permissions.clearanceLevel)}
       />
     </main>

web/app/(app)/personalakten/[id]/Assignments.tsx

@@ -0,0 +1,149 @@
+'use client'
+
+import { useState, useTransition } from 'react'
+import { de } from '@/lib/i18n/de'
+import { ASSIGNMENT_ROLES } from '@/lib/personnel/terms'
+import { addAssignmentAction, removeAssignmentAction } from '../actions'
+
+type Zuordnung = {
+  id: string
+  role: string
+  user: { id: string; displayName: string }
+}
+
+/**
+ * Mitglieder der Abteilung, die an dieser Personalakte hängen.
+ *
+ * Wie die Beteiligten einer Fallakte ist das zugleich der Weg zum
+ * ausnahmsweisen Zugang — der Hinweis steht deshalb direkt am Formular.
+ */
+export function Assignments({
+  personnelFileId,
+  assignments,
+  members,
+  canEdit,
+}: {
+  personnelFileId: string
+  assignments: Zuordnung[]
+  members: { id: string; displayName: string }[]
+  canEdit: boolean
+}) {
+  const [open, setOpen] = useState(false)
+  const [role, setRole] = useState<string>('HANDLER')
+  const [userId, setUserId] = useState('')
+  const [error, setError] = useState<string | null>(null)
+  const [pending, startTransition] = useTransition()
+
+  return (
+    <div>
+      {assignments.length === 0 ? (
+        <p className="text-text-dim">{de.assignment.empty}</p>
+      ) : (
+        <ul className="border-t border-line">
+          {assignments.map((zuordnung) => (
+            <li
+              key={zuordnung.id}
+              className="flex flex-wrap items-baseline gap-x-4 gap-y-1 border-b border-line py-2"
+            >
+              <span className="font-condensed text-2xs text-text-dim">
+                {de.assignment.roles[zuordnung.role] ?? zuordnung.role}
+              </span>
+              <span className="grow text-sm">{zuordnung.user.displayName}</span>
+              {canEdit ? (
+                <button
+                  type="button"
+                  disabled={pending}
+                  onClick={() =>
+                    startTransition(async () => {
+                      const result = await removeAssignmentAction({
+                        personnelFileId,
+                        assignmentId: zuordnung.id,
+                      })
+                      if (!result.ok) setError(result.error)
+                    })
+                  }
+                  className="font-condensed text-2xs text-text-dim"
+                >
+                  {de.assignment.remove}
+                </button>
+              ) : null}
+            </li>
+          ))}
+        </ul>
+      )}
+
+      {error ? <p className="mt-2 font-condensed text-2xs text-stamp-4">{error}</p> : null}
+
+      {canEdit ? (
+        open ? (
+          <div className="mt-4 border border-line p-3">
+            <p className="max-w-(--container-measure) text-2xs text-text-dim">
+              {de.assignment.hint}
+            </p>
+            <div className="mt-3 flex flex-wrap items-center gap-2">
+              <select
+                value={role}
+                onChange={(event) => setRole(event.target.value)}
+                aria-label={de.participant.role}
+                className="border border-line bg-raised px-2 py-1 text-2xs"
+              >
+                {ASSIGNMENT_ROLES.map((value) => (
+                  <option key={value} value={value}>
+                    {de.assignment.roles[value] ?? value}
+                  </option>
+                ))}
+              </select>
+              <select
+                value={userId}
+                onChange={(event) => setUserId(event.target.value)}
+                aria-label={de.participant.pickUser}
+                className="border border-line bg-raised px-2 py-1 text-2xs"
+              >
+                <option value="">—</option>
+                {members.map((member) => (
+                  <option key={member.id} value={member.id}>
+                    {member.displayName}
+                  </option>
+                ))}
+              </select>
+              <button
+                type="button"
+                disabled={pending || !userId}
+                onClick={() =>
+                  startTransition(async () => {
+                    setError(null)
+                    const result = await addAssignmentAction({ personnelFileId, userId, role })
+                    if (result.ok) {
+                      setUserId('')
+                      setOpen(false)
+                    } else {
+                      setError(result.error)
+                    }
+                  })
+                }
+                className="border border-line bg-raised px-3 py-1 font-condensed text-2xs text-accent disabled:text-text-dim"
+              >
+                {de.assignment.add}
+              </button>
+              <button
+                type="button"
+                onClick={() => setOpen(false)}
+                className="font-condensed text-2xs text-text-dim"
+              >
+                {de.common.cancel}
+              </button>
+            </div>
+          </div>
+        ) : (
+          <button
+            type="button"
+            onClick={() => setOpen(true)}
+            className="mt-4 border border-line bg-raised px-3 py-1 font-condensed text-2xs text-accent"
+          >
+            {de.assignment.add}
+          </button>
+        )
+      ) : null}
+    </div>
+  )
+}

web/app/(app)/personalakten/[id]/LinkCase.tsx

@@ -0,0 +1,94 @@
+'use client'
+
+import { useState, useTransition } from 'react'
+import { de } from '@/lib/i18n/de'
+import { PARTICIPANT_ROLES } from '@/lib/cases/terms'
+import { linkCaseToPersonAction } from '../actions'
+
+/**
+ * Einen Fall von der Personalakte aus verknüpfen.
+ *
+ * Derselbe Vorgang wie „Beteiligte eintragen" auf der Fallakte, nur von der
+ * anderen Seite gedacht: dort sucht man die Person, hier den Fall. Deshalb ein
+ * Eingabefeld für das Aktenzeichen und keine Auswahlliste — eine Liste aller
+ * sichtbaren Fälle wäre auf einer Personalakte am falschen Ort.
+ */
+export function LinkCase({ personnelFileId }: { personnelFileId: string }) {
+  const [open, setOpen] = useState(false)
+  const [caseNumber, setCaseNumber] = useState('')
+  const [role, setRole] = useState<string>('SUBJECT')
+  const [error, setError] = useState<string | null>(null)
+  const [pending, startTransition] = useTransition()
+
+  if (!open) {
+    return (
+      <button
+        type="button"
+        onClick={() => setOpen(true)}
+        className="mt-4 border border-line bg-raised px-3 py-1 font-condensed text-2xs text-accent"
+      >
+        {de.personnel.linkCase}
+      </button>
+    )
+  }
+
+  return (
+    <div className="mt-4 border border-line p-3">
+      <p className="max-w-(--container-measure) text-2xs text-text-dim">
+        {de.personnel.linkCaseHint}
+      </p>
+      <div className="mt-3 flex flex-wrap items-center gap-2">
+        <select
+          value={role}
+          onChange={(event) => setRole(event.target.value)}
+          aria-label={de.participant.role}
+          className="border border-line bg-raised px-2 py-1 text-2xs"
+        >
+          {PARTICIPANT_ROLES.map((value) => (
+            <option key={value} value={value}>
+              {de.participant.roles[value] ?? value}
+            </option>
+          ))}
+        </select>
+        <input
+          value={caseNumber}
+          onChange={(event) => setCaseNumber(event.target.value)}
+          placeholder={de.link.target}
+          aria-label={de.link.target}
+          className="border border-line bg-raised px-2 py-1 font-mono text-2xs"
+        />
+        <button
+          type="button"
+          disabled={pending || caseNumber.trim() === ''}
+          onClick={() =>
+            startTransition(async () => {
+              setError(null)
+              const result = await linkCaseToPersonAction({
+                personnelFileId,
+                caseNumber,
+                role,
+              })
+              if (result.ok) {
+                setCaseNumber('')
+                setOpen(false)
+              } else {
+                setError(result.error)
+              }
+            })
+          }
+          className="border border-line bg-raised px-3 py-1 font-condensed text-2xs text-accent disabled:text-text-dim"
+        >
+          {de.personnel.linkCase}
+        </button>
+        <button
+          type="button"
+          onClick={() => setOpen(false)}
+          className="font-condensed text-2xs text-text-dim"
+        >
+          {de.common.cancel}
+        </button>
+      </div>
+      {error ? <p className="mt-2 font-condensed text-2xs text-stamp-4">{error}</p> : null}
+    </div>
+  )
+}

web/app/(app)/personalakten/[id]/PersonnelHead.tsx

@@ -2,6 +2,7 @@
 
 import { useActionState, useState, useTransition } from 'react'
 import { de } from '@/lib/i18n/de'
+import { StatusTags } from '@/components/StatusTags'
 import {
   reclassifyPersonnelAction,
   updatePersonnelAction,
@@ -11,10 +12,9 @@ import {
 type File = {
   id: string
   displayName: string
-  serviceNumber: string | null
   rank: string | null
   department: string | null
-  status: string | null
+  statusTags: string[]
   note: string | null
   classification: number
   userId: string | null
@@ -31,10 +31,12 @@ export function PersonnelHead({
   file,
   canEdit,
   levels,
+  statusTags,
 }: {
   file: File
   canEdit: boolean
   levels: { level: number; name: string }[]
+  statusTags: { key: string; name: string; colorToken: string }[]
 }) {
   const [editing, setEditing] = useState(false)
   const [state, action, pending] = useActionState<ActionResult | null, FormData>(
@@ -46,10 +48,8 @@ export function PersonnelHead({
     return (
       <div>
         <dl className="grid gap-x-8 gap-y-2 text-sm sm:grid-cols-2">
-          <Zeile label={de.personnel.serviceNumber} value={file.serviceNumber} mono />
           <Zeile label={de.personnel.rank} value={file.rank} />
           <Zeile label={de.personnel.department} value={file.department} />
-          <Zeile label={de.personnel.status} value={file.status} />
           <Zeile
             label={de.personnel.linkedAccount}
             value={file.userId ? file.userId : de.personnel.noAccount}
@@ -57,6 +57,15 @@ export function PersonnelHead({
           />
         </dl>
 
+        <div className="mt-3 flex flex-wrap items-baseline gap-3">
+          <span className="font-condensed text-xs text-text-dim">{de.personnel.status}</span>
+          {file.statusTags.length > 0 ? (
+            <StatusTags tags={file.statusTags} known={statusTags} />
+          ) : (
+            <span className="text-sm text-text-dim">{de.personnel.statusNone}</span>
+          )}
+        </div>
+
         {file.note ? (
           <p className="mt-4 max-w-(--container-measure) border-l-(length:--spacing-edge) border-line pl-3 text-sm whitespace-pre-wrap">
             {file.note}
@@ -88,15 +97,27 @@ export function PersonnelHead({
       <input type="hidden" name="id" value={file.id} />
       <Feld id="displayName" label={de.personnel.name} defaultValue={file.displayName} required />
       <div className="grid gap-4 sm:grid-cols-2">
-        <Feld
-          id="serviceNumber"
-          label={de.personnel.serviceNumber}
-          defaultValue={file.serviceNumber}
-        />
         <Feld id="rank" label={de.personnel.rank} defaultValue={file.rank} />
         <Feld id="department" label={de.personnel.department} defaultValue={file.department} />
-        <Feld id="status" label={de.personnel.status} defaultValue={file.status} />
       </div>
+
+      <fieldset>
+        <legend className="font-condensed text-2xs text-text-dim">{de.personnel.status}</legend>
+        <div className="mt-2 flex flex-wrap gap-x-6 gap-y-2">
+          {statusTags.map((tag) => (
+            <label key={tag.key} className="flex items-center gap-2 text-sm">
+              <input
+                type="checkbox"
+                name="statusTags"
+                value={tag.key}
+                defaultChecked={file.statusTags.includes(tag.key)}
+              />
+              {tag.name}
+            </label>
+          ))}
+        </div>
+        <p className="mt-1 text-2xs text-text-dim">{de.personnel.statusHint}</p>
+      </fieldset>
       <div>
         <label htmlFor="note" className="font-condensed text-2xs text-text-dim">
           {de.personnel.note}

web/app/(app)/personalakten/[id]/page.tsx

@@ -5,7 +5,12 @@ import { notFound } from 'next/navigation'
 import { db } from '@/lib/db'
 import { requirePermission } from '@/lib/auth/current'
 import { recordRead, READ_AUDIT_FROM_LEVEL } from '@/lib/audit'
-import { loadBacklinks, loadVisiblePersonnelFile } from '@/lib/personnel/service'
+import {
+  listAssignments,
+  listStatusTags,
+  loadBacklinks,
+  loadVisiblePersonnelFile,
+} from '@/lib/personnel/service'
 import { listDocuments, listTemplatesFor } from '@/lib/documents/service'
 import { canWritePersonnel } from '@/lib/access/documentWrite'
 import { de } from '@/lib/i18n/de'
@@ -14,6 +19,8 @@ import { SkeletonLine } from '@/components/Skeleton'
 import { DocumentList } from '@/components/documents/DocumentList'
 import { NewDocument } from '@/components/documents/NewDocument'
 import { PersonnelHead } from './PersonnelHead'
+import { Assignments } from './Assignments'
+import { LinkCase } from './LinkCase'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 
 export const dynamic = 'force-dynamic'
@@ -39,14 +46,21 @@ export async function generateMetadata({
 async function Backlinks({
   file,
   permissions,
+  canLink,
 }: {
   file: { id: string; userId: string | null }
   permissions: EffectivePermissions
+  canLink: boolean
 }) {
   const { total, byRole } = await loadBacklinks(permissions, file)
 
   if (total === 0) {
-    return <p className="text-text-dim">{de.personnel.backlinksEmpty}</p>
+    return (
+      <div>
+        <p className="text-text-dim">{de.personnel.backlinksEmpty}</p>
+        {canLink ? <LinkCase personnelFileId={file.id} /> : null}
+      </div>
+    )
   }
 
   return (
@@ -76,6 +90,7 @@ async function Backlinks({
           </ul>
         </div>
       ))}
+      {canLink ? <LinkCase personnelFileId={file.id} /> : null}
     </div>
   )
 }
@@ -113,6 +128,37 @@ async function Documents({
   )
 }
 
+async function AssignmentBlock({
+  fileId,
+  permissions,
+  canEdit,
+}: {
+  fileId: string
+  permissions: EffectivePermissions
+  canEdit: boolean
+}) {
+  const [assignments, members] = await Promise.all([
+    listAssignments(permissions, fileId),
+    canEdit
+      ? db.user.findMany({
+          where: { isActive: true },
+          orderBy: { displayName: 'asc' },
+          take: 200,
+          select: { id: true, displayName: true },
+        })
+      : Promise.resolve([]),
+  ])
+
+  return (
+    <Assignments
+      personnelFileId={fileId}
+      assignments={assignments}
+      members={members}
+      canEdit={canEdit}
+    />
+  )
+}
+
 export default async function PersonnelPage({ params }: { params: Promise<{ id: string }> }) {
   const user = await requirePermission('personnel.read')
   const { id } = await params
@@ -133,7 +179,10 @@ export default async function PersonnelPage({ params }: { params: Promise<{ id:
     })
   }
 
-  const levels = await db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } })
+  const [levels, statusTags] = await Promise.all([
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    listStatusTags(),
+  ])
   const level = levels.find((l) => l.level === akte.classification)
   const canEdit = canWritePersonnel(user.permissions, akte.classification).ok
 
@@ -154,10 +203,24 @@ export default async function PersonnelPage({ params }: { params: Promise<{ id:
             file={akte}
             canEdit={canEdit}
             levels={levels.filter((l) => l.level <= user.permissions.clearanceLevel)}
+            statusTags={statusTags}
           />
         </div>
       </section>
 
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.assignment.heading}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="50%" />}>
+            <AssignmentBlock
+              fileId={akte.id}
+              permissions={user.permissions}
+              canEdit={canEdit}
+            />
+          </Suspense>
+        </div>
+      </section>
+
       <section className="mt-10">
         <h2 className="font-condensed">{de.document.heading}</h2>
         <div className="mt-4">
@@ -179,7 +242,7 @@ export default async function PersonnelPage({ params }: { params: Promise<{ id:
               </div>
             }
           >
-            <Backlinks file={akte} permissions={user.permissions} />
+            <Backlinks file={akte} permissions={user.permissions} canLink={canEdit} />
           </Suspense>
         </div>
       </section>

web/app/(app)/personalakten/actions.ts

@@ -6,10 +6,17 @@ import { z } from 'zod'
 import { requireUser } from '@/lib/auth/current'
 import { AccessError } from '@/lib/errors'
 import {
+  addAssignment,
   createPersonnelFile,
   reclassifyPersonnelFile,
+  removeAssignment,
   updatePersonnelFile,
 } from '@/lib/personnel/service'
+import { createDocument, saveDocumentSection } from '@/lib/documents/service'
+import { addParticipant } from '@/lib/cases/participants'
+import { ASSIGNMENT_ROLES } from '@/lib/personnel/terms'
+import { PARTICIPANT_ROLES } from '@/lib/cases/terms'
+import { db } from '@/lib/db'
 import { de } from '@/lib/i18n/de'
 
 export type ActionResult = { ok: true } | { ok: false; error: string }
@@ -24,13 +31,23 @@ function toMessage(error: unknown): string {
 
 const kopfdaten = {
   displayName: z.string().min(2).max(120),
-  serviceNumber: z.string().max(60).optional(),
   rank: z.string().max(60).optional(),
   department: z.string().max(60).optional(),
-  status: z.string().max(60).optional(),
   note: z.string().max(2000).optional(),
 }
 
+/**
+ * Mehrfachauswahl aus einem Formular: der Browser schickt denselben Namen
+ * mehrfach, `Object.fromEntries` behält davon nur den letzten. Deshalb werden
+ * die Etiketten getrennt eingesammelt.
+ */
+function statusAusFormular(formData: FormData): string[] {
+  return formData
+    .getAll('statusTags')
+    .filter((value): value is string => typeof value === 'string' && value.length > 0)
+    .slice(0, 20)
+}
+
 const createSchema = z.object({
   ...kopfdaten,
   userId: z.string().max(64).optional(),
@@ -47,8 +64,16 @@ export async function createPersonnelAction(
 
   let id: string
   try {
-    const created = await createPersonnelFile(user.permissions, parsed.data)
+    const created = await createPersonnelFile(user.permissions, {
+      ...parsed.data,
+      statusTags: statusAusFormular(formData),
+    })
     id = created.id
+
+    // Das Aktenblatt ist der erste Eintrag zu einer Person und entsteht
+    // deshalb gleich mit — als Entwurf, mit dem Namen schon eingetragen.
+    // Fehlt das Recht dafür, bleibt es bei der Akte allein.
+    await erstesAktenblatt(user.permissions, id, parsed.data.displayName)
   } catch (error) {
     return { ok: false, error: toMessage(error) }
   }
@@ -69,7 +94,10 @@ export async function updatePersonnelAction(
 
   try {
     const { id, ...rest } = parsed.data
-    await updatePersonnelFile(user.permissions, id, rest)
+    await updatePersonnelFile(user.permissions, id, {
+      ...rest,
+      statusTags: statusAusFormular(formData),
+    })
     revalidatePath(`/personalakten/${id}`)
     return { ok: true }
   } catch (error) {
@@ -101,3 +129,121 @@ export async function reclassifyPersonnelAction(input: unknown): Promise<ActionR
     return { ok: false, error: toMessage(error) }
   }
 }
+
+/**
+ * Legt das Aktenblatt zu einer frisch angelegten Person an und trägt den Namen
+ * ein, soweit er sich zerlegen lässt.
+ *
+ * Schlägt es fehl, weil das Recht `document.create` fehlt, bleibt die
+ * Personalakte trotzdem stehen: das Blatt lässt sich später nachholen, die
+ * Akte wäre sonst verloren.
+ */
+async function erstesAktenblatt(
+  permissions: Awaited<ReturnType<typeof requireUser>>['permissions'],
+  personnelFileId: string,
+  displayName: string,
+): Promise<void> {
+  const vorlage = await db.documentTemplate.findFirst({
+    where: { key: 'personalakte', isActive: true, uses: { has: 'PERSON_DOCUMENT' } },
+    select: { key: true },
+  })
+  if (!vorlage) return
+
+  const teile = displayName.trim().split(/\s+/)
+  const nachname = teile.length > 1 ? teile[teile.length - 1]! : displayName.trim()
+  const vorname = teile.length > 1 ? teile.slice(0, -1).join(' ') : ''
+
+  try {
+    const doc = await createDocument(permissions, {
+      templateKey: vorlage.key,
+      title: displayName,
+      classification: 1,
+      owner: { kind: 'personnel', personnelFileId },
+    })
+
+    for (const [fieldKey, value] of [
+      ['name', nachname],
+      ['vorname', vorname],
+    ] as const) {
+      if (!value) continue
+      await saveDocumentSection(permissions, {
+        documentNumber: doc.documentNumber,
+        fieldKey,
+        value,
+        baseVersion: 0,
+      })
+    }
+  } catch (error) {
+    if (error instanceof AccessError) return
+    throw error
+  }
+}
+
+const assignmentSchema = z.object({
+  personnelFileId: z.string().min(1),
+  userId: z.string().min(1),
+  role: z.enum(ASSIGNMENT_ROLES),
+})
+
+export async function addAssignmentAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = assignmentSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await addAssignment(user.permissions, parsed.data)
+    revalidatePath(`/personalakten/${parsed.data.personnelFileId}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}
+
+const removeAssignmentSchema = z.object({
+  personnelFileId: z.string().min(1),
+  assignmentId: z.string().min(1),
+})
+
+export async function removeAssignmentAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = removeAssignmentSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await removeAssignment(user.permissions, parsed.data)
+    revalidatePath(`/personalakten/${parsed.data.personnelFileId}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}
+
+const linkCaseSchema = z.object({
+  personnelFileId: z.string().min(1),
+  caseNumber: z.string().min(1).max(60),
+  role: z.enum(PARTICIPANT_ROLES),
+})
+
+/**
+ * Einen Fall von der Personalakte aus verknüpfen.
+ *
+ * Es ist derselbe Vorgang wie „Beteiligte eintragen" auf der Fallakte, nur von
+ * der anderen Seite her gedacht: dort sucht man die Person, hier den Fall.
+ */
+export async function linkCaseToPersonAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = linkCaseSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await addParticipant(user.permissions, {
+      caseNumber: parsed.data.caseNumber.trim(),
+      role: parsed.data.role,
+      personnelFileId: parsed.data.personnelFileId,
+    })
+    revalidatePath(`/personalakten/${parsed.data.personnelFileId}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}

web/app/(app)/personalakten/neu/NewPersonnelForm.tsx

@@ -14,10 +14,12 @@ import { createPersonnelAction, type ActionResult } from '../actions'
 export function NewPersonnelForm({
   members,
   levels,
+  statusTags,
   defaultLevel,
 }: {
   members: { id: string; displayName: string }[]
   levels: { level: number; name: string }[]
+  statusTags: { key: string; name: string }[]
   defaultLevel: number
 }) {
   const [state, action, pending] = useActionState<ActionResult | null, FormData>(
@@ -49,12 +51,25 @@ export function NewPersonnelForm({
       </div>
 
       <div className="grid gap-5 sm:grid-cols-2">
-        <Feld id="serviceNumber" label={de.personnel.serviceNumber} />
         <Feld id="rank" label={de.personnel.rank} />
         <Feld id="department" label={de.personnel.department} />
-        <Feld id="status" label={de.personnel.status} />
       </div>
 
+      <fieldset>
+        <legend className="font-condensed text-xs text-text-dim">{de.personnel.status}</legend>
+        {/* Kästchen statt Auswahlliste: mehrere Etiketten sind der Normalfall,
+            und eine Mehrfachauswahl mit Strg-Klick findet niemand. */}
+        <div className="mt-2 flex flex-wrap gap-x-6 gap-y-2">
+          {statusTags.map((tag) => (
+            <label key={tag.key} className="flex items-center gap-2 text-sm">
+              <input type="checkbox" name="statusTags" value={tag.key} />
+              {tag.name}
+            </label>
+          ))}
+        </div>
+        <p className="mt-1 text-2xs text-text-dim">{de.personnel.statusHint}</p>
+      </fieldset>
+
       <div>
         <label htmlFor="note" className="font-condensed text-xs text-text-dim">
           {de.personnel.note}

web/app/(app)/personalakten/neu/page.tsx

@@ -1,6 +1,7 @@
 import type { Metadata } from 'next'
 import { db } from '@/lib/db'
 import { requirePermission } from '@/lib/auth/current'
+import { listStatusTags } from '@/lib/personnel/service'
 import { de } from '@/lib/i18n/de'
 import { NewPersonnelForm } from './NewPersonnelForm'
 
@@ -10,7 +11,7 @@ export const dynamic = 'force-dynamic'
 export default async function NewPersonnelPage() {
   const user = await requirePermission('personnel.edit')
 
-  const [levels, members] = await Promise.all([
+  const [levels, members, statusTags] = await Promise.all([
     db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
     // Nur Konten, für die es noch keine Akte gibt: zwei Akten zu einer Person
     // wären zwei Wahrheiten.
@@ -20,6 +21,7 @@ export default async function NewPersonnelPage() {
       take: 200,
       select: { id: true, displayName: true },
     }),
+    listStatusTags(),
   ])
 
   return (
@@ -31,6 +33,7 @@ export default async function NewPersonnelPage() {
       <NewPersonnelForm
         members={members}
         levels={levels.filter((level) => level.level <= user.permissions.clearanceLevel)}
+        statusTags={statusTags}
         defaultLevel={Math.min(1, user.permissions.clearanceLevel)}
       />
     </main>

web/app/(app)/personalakten/page.tsx

@@ -2,9 +2,10 @@ import type { Metadata } from 'next'
 import Link from 'next/link'
 import { db } from '@/lib/db'
 import { requirePermission } from '@/lib/auth/current'
-import { listPersonnelFiles } from '@/lib/personnel/service'
+import { listPersonnelFiles, listStatusTags } from '@/lib/personnel/service'
 import { de } from '@/lib/i18n/de'
 import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
+import { StatusTags } from '@/components/StatusTags'
 
 export const metadata: Metadata = { title: de.personnel.listHeading }
 export const dynamic = 'force-dynamic'
@@ -19,15 +20,16 @@ export const dynamic = 'force-dynamic'
 export default async function PersonnelListPage({
   searchParams,
 }: {
-  searchParams: Promise<{ q?: string }>
+  searchParams: Promise<{ q?: string; status?: string }>
 }) {
   // Ohne das Recht gibt es die Seite nicht — 404, nicht 403.
   const user = await requirePermission('personnel.read')
-  const { q } = await searchParams
+  const { q, status } = await searchParams
 
-  const [{ files, total }, levels] = await Promise.all([
+  const [{ files, total }, levels, statusTags] = await Promise.all([
-    listPersonnelFiles(user.permissions, { query: q }),
+    listPersonnelFiles(user.permissions, { query: q, statusTag: status }),
     db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    listStatusTags(),
   ])
   const levelName = new Map(levels.map((l) => [l.level, l.name]))
   const darfAnlegen =
@@ -49,6 +51,7 @@ export default async function PersonnelListPage({
           aria-label={de.personnel.search}
           className="w-full max-w-sm border border-line bg-raised px-3 py-2 text-sm"
         />
+        {status ? <input type="hidden" name="status" value={status} /> : null}
         {darfAnlegen ? (
           <Link href="/personalakten/neu" className="ml-auto font-condensed text-xs">
             {de.personnel.create}
@@ -56,6 +59,21 @@ export default async function PersonnelListPage({
         ) : null}
       </form>
 
+      <nav className="mt-4 flex flex-wrap gap-3 font-condensed text-xs">
+        <Link href={q ? `/personalakten?q=${encodeURIComponent(q)}` : '/personalakten'}>
+          {de.personnel.filterAll}
+        </Link>
+        {statusTags.map((tag) => (
+          <Link
+            key={tag.key}
+            href={`/personalakten?${new URLSearchParams({ ...(q ? { q } : {}), status: tag.key })}`}
+            className={tag.key === status ? 'text-accent' : undefined}
+          >
+            {tag.name}
+          </Link>
+        ))}
+      </nav>
+
       {files.length === 0 ? (
         <p className="mt-10 text-text-dim">
           {q ? de.personnel.emptySearch : de.personnel.empty}
@@ -71,12 +89,10 @@ export default async function PersonnelListPage({
                 style={classificationEdgeStyle(akte.classification)}
               >
                 <span className="grow">{akte.displayName}</span>
-                {akte.serviceNumber ? (
-                  <span className="font-mono text-xs text-text-dim">{akte.serviceNumber}</span>
-                ) : null}
                 {akte.rank ? (
                   <span className="font-condensed text-2xs text-text-dim">{akte.rank}</span>
                 ) : null}
+                <StatusTags tags={akte.statusTags} known={statusTags} />
                 <StampMark
                   level={akte.classification}
                   name={levelName.get(akte.classification) ?? de.common.unknown}

web/app/globals.css

@@ -212,6 +212,221 @@
     width: 1px;
     background-color: var(--color-line);
   }
+
+  /* ---------------------------------------------------------------------
+     Das Aktenblatt.
+
+     Bewusst **ausserhalb** des Design-Systems der Oberflaeche: schwarz auf
+     weiss, harte Rahmen, Massangaben in Millimetern. Es ist kein Bildschirm-
+     element, sondern ein Formular, das gedruckt und weitergereicht wird und
+     auf Papier genauso aussehen muss wie hier. Deshalb steht hier kein
+     einziger Farb-Token der Anwendung.
+
+     Nachgebaut nach dem Formular, das die Personalabteilung bislang von Hand
+     ausgefuellt hat. Siehe docs/13-entscheidungen.md.
+     --------------------------------------------------------------------- */
+  .sheet {
+    width: 210mm;
+    min-height: 297mm;
+    box-sizing: border-box;
+    margin: 0 auto;
+    padding: 10mm;
+    background: #ffffff;
+    color: #000000;
+    font-family: var(--font-sans, sans-serif);
+  }
+
+  .sheet-frame {
+    border: 4px solid #000;
+    min-height: calc(297mm - 20mm);
+    display: flex;
+    flex-direction: column;
+  }
+
+  .sheet-head {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 1rem;
+    padding: 15px;
+    border-bottom: 4px solid #000;
+  }
+
+  .sheet-head h1 {
+    margin: 0 0 5px;
+    font-size: 28px;
+    font-weight: 900;
+    letter-spacing: 1px;
+    line-height: 1.1;
+    text-transform: uppercase;
+    color: #000;
+  }
+
+  .sheet-head h2 {
+    margin: 0;
+    font-size: 14px;
+    font-weight: 900;
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    color: #000;
+  }
+
+  .sheet-mark {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+    gap: 10px;
+  }
+
+  /* Rein dekorativ, deshalb aria-hidden im Markup. */
+  .sheet-barcode {
+    width: 140px;
+    height: 25px;
+    background: repeating-linear-gradient(
+      90deg,
+      #000,
+      #000 2px,
+      #fff 2px,
+      #fff 5px,
+      #000 5px,
+      #000 8px,
+      #fff 8px,
+      #fff 10px
+    );
+  }
+
+  .sheet-classbar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 1rem;
+    padding: 10px 15px;
+    border-bottom: 4px solid #000;
+    color: #fff;
+    font-size: 14px;
+    font-weight: 900;
+    text-transform: uppercase;
+  }
+
+  .sheet-grid {
+    width: 100%;
+    border-collapse: collapse;
+    table-layout: fixed;
+  }
+
+  .sheet-grid td {
+    border: 2px solid #000;
+    padding: 10px;
+    vertical-align: top;
+    word-wrap: break-word;
+    overflow-wrap: anywhere;
+  }
+
+  .sheet-label {
+    font-size: 10px;
+    font-weight: 900;
+    text-transform: uppercase;
+    margin-bottom: 4px;
+    color: #000;
+  }
+
+  .sheet-value {
+    font-size: 14px;
+    font-weight: 700;
+    min-height: 20px;
+    color: #000;
+  }
+
+  .sheet-value-emphasis {
+    color: #7f1d1d;
+  }
+
+  .sheet-photo {
+    width: 120px;
+    height: 160px;
+    margin: 0 auto;
+    border: 2px solid #000;
+    background: #f0f0f0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    text-align: center;
+    font-size: 10px;
+    font-weight: 700;
+    color: #555;
+    position: relative;
+    overflow: hidden;
+  }
+
+  .sheet-photo img {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+  }
+
+  .sheet-signature {
+    border-bottom: 2px solid #000;
+    min-height: 30px;
+    display: flex;
+    align-items: flex-end;
+    font-family: 'Times New Roman', Times, serif;
+    font-style: italic;
+    font-size: 18px;
+    color: #000;
+  }
+
+  .sheet-foot {
+    margin-top: auto;
+    border-top: 4px solid #000;
+    padding: 10px 15px;
+    display: flex;
+    justify-content: space-between;
+    gap: 1rem;
+    font-family: var(--font-mono, monospace);
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    color: #000;
+  }
+
+  /* Schmale Fenster: das Blatt behaelt seine Proportionen und wird als Ganzes
+     verkleinert, statt umzubrechen. Ein umgebrochenes Formular waere ein
+     anderes Formular. */
+  @media (max-width: 230mm) {
+    .sheet-scroll {
+      overflow-x: auto;
+    }
+  }
+}
+
+/* Drucken: nur das Blatt, ohne Rahmenwerk der Anwendung. Der PDF-Export mit
+   Wasserzeichen und Deckblatt kommt in Phase 8, siehe docs/08. */
+@media print {
+  .no-print {
+    display: none !important;
+  }
+
+  body {
+    background: #fff !important;
+  }
+
+  .sheet {
+    margin: 0;
+    padding: 0;
+    width: auto;
+  }
+
+  .sheet-frame {
+    min-height: auto;
+  }
+
+  .sheet-classbar {
+    /* Sonst druckt der Balken weiss auf weiss. */
+    print-color-adjust: exact;
+    -webkit-print-color-adjust: exact;
+  }
 }
 
 @media (prefers-reduced-motion: reduce) {

web/components/StatusTags.tsx

@@ -0,0 +1,36 @@
+/**
+ * Status einer Person als Etiketten.
+ *
+ * Mehrere zugleich: „Gekündigt" und „Verhaftet" schließen einander nicht aus.
+ * Die Namen und Farben kommen aus `PersonnelStatusTag` und sind im
+ * Adminbereich pflegbar — deshalb werden sie hereingereicht und nicht aus
+ * `lib/i18n/de.ts` gelesen. Siehe CLAUDE.md, Sprachkonvention.
+ */
+export function StatusTags({
+  tags,
+  known,
+}: {
+  tags: string[]
+  known: { key: string; name: string; colorToken: string }[]
+}) {
+  if (tags.length === 0) return null
+  const byKey = new Map(known.map((tag) => [tag.key, tag]))
+
+  return (
+    <ul className="flex flex-wrap gap-1.5">
+      {tags.map((key) => {
+        const tag = byKey.get(key)
+        const color = `var(--color-${tag?.colorToken ?? 'stamp-0'})`
+        return (
+          <li
+            key={key}
+            className="border px-1.5 py-0.5 font-condensed text-2xs"
+            style={{ borderColor: color, color }}
+          >
+            {tag?.name ?? key}
+          </li>
+        )
+      })}
+    </ul>
+  )
+}

web/components/documents/FoundationMark.tsx

@@ -0,0 +1,32 @@
+/**
+ * Das Zeichen der Foundation im Kopf des Aktenblatts.
+ *
+ * Als SVG im Markup, nicht als Bilddatei von einem fremden Host: die
+ * Inhaltsrichtlinie der Anwendung lässt keine externen Bilder zu, und ein
+ * Formular, das nur mit Internetverbindung vollständig aussieht, ist auf einem
+ * Heimserver die falsche Bauart. Wer das Original einsetzen will, legt es als
+ * `public/foundation.svg` ab und tauscht diese Komponente gegen ein `img`.
+ */
+export function FoundationMark({ size = 70 }: { size?: number }) {
+  // Drei nach innen zeigende Pfeile, um 120 Grad versetzt.
+  const pfeile = [0, 120, 240]
+
+  return (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 100 100"
+      role="img"
+      aria-label="Zeichen der Foundation"
+      style={{ background: '#ffffff' }}
+    >
+      <circle cx="50" cy="50" r="46" fill="none" stroke="#000" strokeWidth="4" />
+      <circle cx="50" cy="50" r="38" fill="none" stroke="#000" strokeWidth="2" />
+      {pfeile.map((winkel) => (
+        <g key={winkel} transform={`rotate(${winkel} 50 50)`}>
+          <path d="M50 14 L68 44 L56 44 L56 62 L44 62 L44 44 L32 44 Z" fill="#000" />
+        </g>
+      ))}
+    </svg>
+  )
+}

web/components/documents/Sheet.tsx

@@ -0,0 +1,240 @@
+import { de } from '@/lib/i18n/de'
+import {
+  dossierRows,
+  dossierSpan,
+  fillPlaceholders,
+  isInputField,
+  type TemplateField,
+} from '@/lib/templates/fields'
+import { RedactedText } from '@/components/Redacted'
+import { FoundationMark } from './FoundationMark'
+import type { RenderedSection } from '@/lib/sections/render'
+
+/**
+ * Das Aktenblatt: ein Formular, kein Bildschirmelement.
+ *
+ * Nachgebaut nach dem Blatt, das die Personalabteilung bislang von Hand
+ * ausgefüllt hat — Raster, Rahmenstärken und Beschriftungen entsprechen ihm.
+ * Es steht bewusst außerhalb des Design-Systems der Oberfläche, weil es
+ * gedruckt weitergereicht wird und auf Papier gleich aussehen muss.
+ *
+ * Welche Felder wo stehen, kommt aus der Vorlage, nicht von hier. Damit trägt
+ * dieselbe Bauform später einen Vorfallsbericht oder einen Bußgeldbescheid.
+ * Siehe docs/13-entscheidungen.md.
+ */
+export function Sheet({
+  sections,
+  title,
+  subtitle,
+  documentNumber,
+  issuedAt,
+  foundationLevels,
+  footerNote,
+}: {
+  sections: RenderedSection[]
+  title: string
+  subtitle: string
+  documentNumber: string
+  issuedAt: Date
+  /** Aus FoundationClearance. Steuert keinen Zugriff, nur den Balken. */
+  foundationLevels: { level: number; name: string; colorHex: string }[]
+  footerNote: string
+}) {
+  const fields = sections.map((section) => section.field)
+  const byKey = new Map(sections.map((section) => [section.fieldKey, section]))
+  const werte = Object.fromEntries(
+    sections.filter((s) => s.visible).map((s) => [s.fieldKey, s.value]),
+  )
+  const { photo, photoRows, rows } = dossierRows(fields)
+
+  const klassifikation = sections.find(
+    (section) => isInputField(section.field) && section.field.slot === 'classbar',
+  )
+  const stufe = klassifikation?.visible ? Number(klassifikation.value) : NaN
+  const balken = foundationLevels.find((l) => l.level === stufe)
+
+  return (
+    <div className="sheet-scroll">
+      <article className="sheet">
+        <div className="sheet-frame">
+          <header className="sheet-head">
+            <div>
+              <h1>{title}</h1>
+              <h2>{subtitle}</h2>
+            </div>
+            <div className="sheet-mark">
+              <FoundationMark />
+              <span className="sheet-barcode" aria-hidden />
+              <span style={{ fontFamily: 'var(--font-mono, monospace)', fontSize: 10, fontWeight: 700 }}>
+                {de.document.number}: {documentNumber}
+              </span>
+            </div>
+          </header>
+
+          <div
+            className="sheet-classbar"
+            // Ohne gesetzte Stufe bleibt der Balken neutral dunkel, statt zu
+            // behaupten, das Blatt sei eingestuft.
+            style={{ backgroundColor: balken?.colorHex ?? '#333333' }}
+          >
+            <span>
+              {subtitle} — {balken ? `${balken.name} [Level ${balken.level}]` : de.document.unclassified}
+            </span>
+            <span>
+              {de.document.issuedAt}: {formatiereDatum(issuedAt)}
+            </span>
+          </div>
+
+          <table className="sheet-grid">
+            <tbody>
+              {rows.map((row, rowIndex) => {
+                const inPhotoRows = rowIndex < photoRows
+                return (
+                  <tr key={rowIndex}>
+                    {photo && rowIndex === 0 ? (
+                      <td rowSpan={photoRows} style={{ width: 150, textAlign: 'center' }}>
+                        <div className="sheet-label" style={{ textAlign: 'center' }}>
+                          {photo.label}
+                        </div>
+                        <PhotoBox section={byKey.get(photo.key)} />
+                      </td>
+                    ) : null}
+
+                    {row.map((field) => (
+                      <Cell
+                        key={field.key}
+                        field={field}
+                        section={byKey.get(field.key)}
+                        dateSection={
+                          isInputField(field) && field.dateKey
+                            ? byKey.get(field.dateKey)
+                            : undefined
+                        }
+                        span={dossierSpan(field, inPhotoRows)}
+                        werte={werte}
+                      />
+                    ))}
+                  </tr>
+                )
+              })}
+            </tbody>
+          </table>
+
+          <footer className="sheet-foot">
+            <span>{footerNote}</span>
+            <span>{documentNumber}</span>
+          </footer>
+        </div>
+      </article>
+    </div>
+  )
+}
+
+function PhotoBox({ section }: { section: RenderedSection | undefined }) {
+  if (section && !section.visible) {
+    return (
+      <div className="sheet-photo">
+        <span>{de.section.redacted}</span>
+      </div>
+    )
+  }
+
+  // Der Wert eines Lichtbildfeldes ist die Kennung eines geprüften Anhangs,
+  // nie das Bild selbst. Die Prüfkette dafür baut Phase 5, siehe docs/07.
+  return (
+    <div className="sheet-photo">
+      <span>{de.document.photoEmpty}</span>
+    </div>
+  )
+}
+
+function Cell({
+  field,
+  section,
+  dateSection,
+  span,
+  werte,
+}: {
+  field: TemplateField
+  section: RenderedSection | undefined
+  dateSection: RenderedSection | undefined
+  span: number
+  werte: Record<string, unknown>
+}) {
+  if (!isInputField(field)) {
+    const text = fillPlaceholders(field.text ?? '', werte)
+    return (
+      <td colSpan={span}>
+        {field.type === 'heading' ? (
+          <div className="sheet-label">{text || field.label}</div>
+        ) : (
+          <div className="sheet-value" style={{ whiteSpace: 'pre-wrap' }}>
+            {text}
+          </div>
+        )}
+      </td>
+    )
+  }
+
+  // Serverseitig ersetzt: der echte Wert ist gar nicht erst hier.
+  if (section && !section.visible) {
+    return (
+      <td colSpan={span}>
+        <div className="sheet-label">{field.label}</div>
+        <div className="sheet-value">
+          <span className="redaction inline-block h-[1.1rem] w-40" aria-hidden />
+        </div>
+      </td>
+    )
+  }
+
+  if (field.type === 'signature') {
+    return (
+      <td colSpan={span} style={{ paddingBottom: 20 }}>
+        <div className="sheet-label">{fillPlaceholders(field.label, werte)}</div>
+        <div className="sheet-signature">{asText(section?.value)}</div>
+        {field.dateKey ? (
+          <div className="sheet-label" style={{ marginTop: 5 }}>
+            {de.document.signedOn}: {asText(dateSection?.value) || '—'}
+          </div>
+        ) : null}
+      </td>
+    )
+  }
+
+  const lang = field.type === 'longtext'
+
+  return (
+    <td colSpan={span}>
+      <div className="sheet-label">{field.label}</div>
+      <div
+        className={`sheet-value${field.emphasis ? ' sheet-value-emphasis' : ''}`}
+        style={lang ? { minHeight: 220, whiteSpace: 'pre-wrap' } : undefined}
+      >
+        {section?.segments ? (
+          <RedactedText segments={section.segments} />
+        ) : (
+          asText(section?.value) || '---'
+        )}
+      </div>
+    </td>
+  )
+}
+
+/**
+ * Zweistellig, wie auf dem Formular: `14.03.2026`, nicht `14.3.2026`. Die
+ * deutsche Voreinstellung kürzt, ein Formular tut das nicht.
+ */
+function formatiereDatum(value: Date): string {
+  return value.toLocaleDateString('de-DE', {
+    day: '2-digit',
+    month: '2-digit',
+    year: 'numeric',
+  })
+}
+
+function asText(value: unknown): string {
+  if (value === null || value === undefined) return ''
+  if (Array.isArray(value)) return value.join(', ')
+  return String(value)
+}

web/components/documents/SheetSwitch.tsx

@@ -0,0 +1,62 @@
+'use client'
+
+import { useState, type ReactNode } from 'react'
+import { de } from '@/lib/i18n/de'
+
+/**
+ * Umschalter zwischen Aktenblatt und Bearbeitung.
+ *
+ * Beide Bäume kommen fertig gerendert vom Server herein; hier wird nur
+ * umgeschaltet. Das Blatt bleibt damit das, was es ist — ein Formular —, ohne
+ * dass die Bearbeitung es mit Eingabefeldern zerlegt.
+ */
+export function SheetSwitch({
+  sheet,
+  editor,
+  canEdit,
+}: {
+  sheet: ReactNode
+  editor: ReactNode
+  canEdit: boolean
+}) {
+  const [modus, setModus] = useState<'blatt' | 'bearbeiten'>('blatt')
+
+  return (
+    <div>
+      <div className="no-print mb-6 flex flex-wrap items-center gap-4 border-b border-line pb-2 font-condensed text-xs">
+        <button
+          type="button"
+          onClick={() => setModus('blatt')}
+          aria-current={modus === 'blatt'}
+          className={modus === 'blatt' ? 'text-accent' : 'text-text-dim'}
+        >
+          {de.document.sheet}
+        </button>
+        {canEdit ? (
+          <button
+            type="button"
+            onClick={() => setModus('bearbeiten')}
+            aria-current={modus === 'bearbeiten'}
+            className={modus === 'bearbeiten' ? 'text-accent' : 'text-text-dim'}
+          >
+            {de.document.edit}
+          </button>
+        ) : null}
+        <button
+          type="button"
+          onClick={() => {
+            setModus('blatt')
+            // Ein Bild vom Bildschirm ist kein Export. Der PDF-Export mit
+            // Wasserzeichen und Protokolleintrag kommt in Phase 8.
+            requestAnimationFrame(() => window.print())
+          }}
+          className="ml-auto text-text-dim"
+        >
+          {de.document.print}
+        </button>
+      </div>
+
+      {modus === 'blatt' ? sheet : <div className="no-print">{editor}</div>}
+    </div>
+  )
+}

web/components/sections/Sections.tsx

@@ -40,16 +40,6 @@ export function Sections({
         // Feste Bausteine der Vorlage.
         if (!isInputField(field)) {
           if (field.type === 'pagebreak') return <hr key={field.key} className="border-line" />
-          if (field.type === 'signature') {
-            return (
-              <div key={field.key} className="pt-8">
-                <div className="w-64 border-t border-line" />
-                <p className="mt-1 text-2xs text-text-dim">
-                  {fillPlaceholders(field.label, werte)}
-                </p>
-              </div>
-            )
-          }
           const text = fillPlaceholders(field.text ?? '', werte)
           return field.type === 'heading' ? (
             <h3 key={field.key} className="font-condensed">
@@ -62,6 +52,15 @@ export function Sections({
           )
         }
 
+        if (field.type === 'photo') {
+          return (
+            <div key={field.key}>
+              <dt className="font-condensed text-xs text-text-dim">{field.label}</dt>
+              <dd className="mt-1 text-2xs text-text-dim">{de.document.photoLater}</dd>
+            </div>
+          )
+        }
+
         return (
           <div key={field.key}>
             <dt className="flex flex-wrap items-baseline gap-x-3">

web/lib/access/personnelFilter.ts

@@ -13,16 +13,28 @@ import { visibleCaseWhere } from '@/lib/access/caseFilter'
 /**
  * Personalakten, die ein Nutzer lesen darf.
  *
- * Anders als bei der Fallakte gibt es hier keinen „Beteiligten": eine
+ * Zwei Wege, wie bei der Fallakte:
- * Personalakte hat keine Ermittlergruppe. Es zählt allein die Freigabestufe.
+ *  1. die Freigabestufe reicht, oder
+ *  2. der Nutzer ist der Akte **zugeordnet** (`PersonnelAssignment`)
  *
- * Auch die eigene Akte ist keine Ausnahme. Das ist bewusst so: eine Beurteilung
+ * Der zweite Weg ist der ausnahmsweise Zugang: die Leitung zieht einen
- * auf Stufe 4 über einen Mitarbeiter der Stufe 1 wäre sonst genau für den
+ * Ermittler zu einer bestimmten Person hinzu, ohne ihm allgemein eine höhere
- * einen Menschen lesbar, vor dem sie geschützt werden soll.
+ * Stufe zu geben. Er entsteht nur durch eine bewusste Eintragung und wird
+ * protokolliert.
+ *
+ * **Betroffen zu sein ist kein Weg.** Wer die Person selbst ist, liest ihre
+ * Akte nicht allein deshalb: eine Beurteilung auf Stufe 4 über einen
+ * Mitarbeiter der Stufe 1 wäre sonst genau für den einen Menschen lesbar, vor
+ * dem sie geschützt werden soll. Siehe docs/13-entscheidungen.md.
  */
 export function visiblePersonnelWhere(p: EffectivePermissions): Prisma.PersonnelFileWhereInput {
   if (p.isAdmin) return {}
-  return { classification: { lte: p.clearanceLevel } }
+  return {
+    OR: [
+      { classification: { lte: p.clearanceLevel } },
+      { assignments: { some: { userId: p.userId } } },
+    ],
+  }
 }
 
 /**

web/lib/audit.ts

@@ -32,6 +32,8 @@ export type AuditAction =
   | 'personnel.create'
   | 'personnel.update'
   | 'personnel.reclassify'
+  | 'personnel.assign'
+  | 'personnel.unassign'
   | 'document.read'
   | 'document.create'
   | 'document.update'

web/lib/i18n/de.ts

@@ -141,6 +141,8 @@ export const de = {
     empty: 'Noch keine Fallakte. Erste Fallakte anlegen.',
     create: 'Fallakte anlegen',
     createTitle: 'Neue Fallakte',
+    subject: 'Betroffene Person',
+    subjectNone: 'Keine',
     open: 'Öffnen',
     updatedAt: 'Zuletzt geändert',
     more: 'Weitere laden',
@@ -227,10 +229,13 @@ export const de = {
     many: 'Personalakten',
     listHeading: 'Personalakten',
     name: 'Name',
-    serviceNumber: 'Dienstnummer',
     rank: 'Dienstgrad',
     department: 'Abteilung',
     status: 'Status',
+    statusHint: 'Mehrere möglich. „Gekündigt" und „Verhaftet" schließen einander nicht aus.',
+    statusNone: 'Kein Status gesetzt',
+    filterStatus: 'Status',
+    filterAll: 'Alle',
     note: 'Anmerkung',
     noteHelp: 'Steht im Kopf der Akte, etwa "kein Discord-Konto, Aktenlage aus 2025".',
     linkedAccount: 'Discord-Konto',
@@ -240,8 +245,8 @@ export const de = {
     create: 'Personalakte anlegen',
     createTitle: 'Neue Personalakte',
     createHint:
-      'Auch für Personen ohne Discord-Konto: Zeugen, ehemalige Mitarbeiter, Aktenlage von außen.',
+      'Meist für Externe ohne Discord-Konto: Sicherheitsdienst, Zeugen, Vertragspartner. Zusammen mit der Akte entsteht das Aktenblatt als erster Eintrag.',
-    search: 'Name, Dienstnummer oder Dienstgrad',
+    search: 'Name, Dienstgrad oder Abteilung',
     countLabel: (n: number) => (n === 1 ? '1 Personalakte' : `${n} Personalakten`),
     edit: 'Kopfdaten ändern',
     reclassify: 'Klassifizierung ändern',
@@ -249,6 +254,22 @@ export const de = {
     backlinks: 'Fälle mit dieser Person',
     backlinksEmpty: 'Diese Person kommt in keinem Fall vor, den du sehen darfst.',
     backlinksCount: (n: number) => (n === 1 ? '1 Fall' : `${n} Fälle`),
+    linkCase: 'Fall verknüpfen',
+    linkCaseHint: 'Aktenzeichen eintragen und die Rolle wählen, in der die Person darin vorkommt.',
+  },
+
+  assignment: {
+    heading: 'Zuständige der Abteilung',
+    empty: 'Niemand zugeordnet.',
+    add: 'Mitglied zuordnen',
+    remove: 'Entfernen',
+    hint:
+      'Wer hier steht, liest die Personalakte unabhängig von seiner Freigabestufe.',
+    roles: {
+      HANDLER: 'Aktenführung',
+      INVESTIGATOR: 'Ermittler',
+      CONTACT: 'Ansprechpartner',
+    } as Record<string, string>,
   },
 
   participant: {
@@ -310,6 +331,15 @@ export const de = {
     retracted: (date: string, person: string, reason: string) =>
       `Dokument zurückgezogen am ${date} durch ${person} · Begründung: ${reason}`,
     finalized: (date: string, person: string) => `Ausgefertigt am ${date} durch ${person}`,
+    sheet: 'Aktenblatt',
+    edit: 'Bearbeiten',
+    print: 'Drucken',
+    issuedAt: 'Ausgestellt',
+    signedOn: 'Datum',
+    unclassified: 'Ohne Klassifikation',
+    photoEmpty: 'Lichtbild 3×4 cm',
+    photoLater: 'Lichtbilder kommen mit der Dateiprüfung.',
+    footerNote: 'Dieses Dokument ist klassifiziert. Nur für autorisiertes Personal.',
     ownerCase: 'Zur Fallakte',
     ownerPersonnel: 'Zur Personalakte',
     ownerNone: 'Ohne Besitzer',
@@ -322,6 +352,7 @@ export const de = {
       FORM: 'Formular',
       PROSE: 'Vertragstext',
       NOTE: 'Vermerk',
+      DOSSIER: 'Aktenblatt',
     } as Record<string, string>,
   },
 

web/lib/personnel/service.ts

@@ -4,6 +4,7 @@ import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import { canWritePersonnel } from '@/lib/access/documentWrite'
 import { AccessError, must } from '@/lib/errors'
+import type { AssignmentRoleName } from '@/lib/personnel/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -19,10 +20,9 @@ const KOPFDATEN = {
   id: true,
   userId: true,
   displayName: true,
-  serviceNumber: true,
   rank: true,
   department: true,
-  status: true,
+  statusTags: true,
   note: true,
   classification: true,
   createdById: true,
@@ -44,19 +44,20 @@ export async function loadVisiblePersonnelFile(p: EffectivePermissions, id: stri
  */
 export async function listPersonnelFiles(
   p: EffectivePermissions,
-  options: { query?: string; take?: number } = {},
+  options: { query?: string; statusTag?: string; take?: number } = {},
 ) {
   const begriff = options.query?.trim()
   const where: Prisma.PersonnelFileWhereInput = {
     AND: [
       visiblePersonnelWhere(p),
+      ...(options.statusTag ? [{ statusTags: { has: options.statusTag } }] : []),
       ...(begriff
         ? [
             {
               OR: [
                 { displayName: { contains: begriff, mode: 'insensitive' as const } },
-                { serviceNumber: { contains: begriff, mode: 'insensitive' as const } },
                 { rank: { contains: begriff, mode: 'insensitive' as const } },
+                { department: { contains: begriff, mode: 'insensitive' as const } },
               ],
             },
           ]
@@ -82,10 +83,9 @@ export async function createPersonnelFile(
   input: {
     displayName: string
     userId?: string | null
-    serviceNumber?: string | null
     rank?: string | null
     department?: string | null
-    status?: string | null
+    statusTags?: string[]
     note?: string | null
     classification: number
   },
@@ -100,10 +100,9 @@ export async function createPersonnelFile(
       data: {
         displayName: name,
         userId: input.userId || null,
-        serviceNumber: input.serviceNumber?.trim() || null,
         rank: input.rank?.trim() || null,
         department: input.department?.trim() || null,
-        status: input.status?.trim() || null,
+        statusTags: await gueltigeStatusEtiketten(input.statusTags),
         note: input.note?.trim() || null,
         classification: input.classification,
         createdById: p.userId,
@@ -130,10 +129,9 @@ export async function updatePersonnelFile(
   id: string,
   input: {
     displayName?: string
-    serviceNumber?: string | null
     rank?: string | null
     department?: string | null
-    status?: string | null
+    statusTags?: string[]
     note?: string | null
   },
 ): Promise<void> {
@@ -149,14 +147,13 @@ export async function updatePersonnelFile(
       where: { id },
       data: {
         ...(name !== undefined ? { displayName: name } : {}),
-        ...(input.serviceNumber !== undefined
-          ? { serviceNumber: input.serviceNumber?.trim() || null }
-          : {}),
         ...(input.rank !== undefined ? { rank: input.rank?.trim() || null } : {}),
         ...(input.department !== undefined
           ? { department: input.department?.trim() || null }
           : {}),
-        ...(input.status !== undefined ? { status: input.status?.trim() || null } : {}),
+        ...(input.statusTags !== undefined
+          ? { statusTags: await gueltigeStatusEtiketten(input.statusTags) }
+          : {}),
         ...(input.note !== undefined ? { note: input.note?.trim() || null } : {}),
       },
     })
@@ -265,3 +262,132 @@ export async function loadBacklinks(
     byRole: [...nachRolle.entries()].map(([role, eintraege]) => ({ role, eintraege })),
   }
 }
+
+/**
+ * Filtert auf die Etiketten, die es wirklich gibt.
+ *
+ * Sonst könnte ein manipuliertes Formular einen erfundenen Status setzen, und
+ * die Liste im Adminbereich wäre nur noch eine Empfehlung. Die Reihenfolge
+ * kommt aus der Konfiguration, nicht aus der Eingabe: so steht auf jeder Akte
+ * dieselbe Abfolge.
+ */
+async function gueltigeStatusEtiketten(gewuenscht: string[] | undefined): Promise<string[]> {
+  if (!gewuenscht?.length) return []
+  const bekannt = await db.personnelStatusTag.findMany({
+    where: { key: { in: gewuenscht }, isActive: true },
+    orderBy: { sortOrder: 'asc' },
+    select: { key: true },
+  })
+  return bekannt.map((tag) => tag.key)
+}
+
+/** Die Etiketten zur Auswahl, für Formulare und Filter. */
+export async function listStatusTags() {
+  return db.personnelStatusTag.findMany({
+    where: { isActive: true },
+    orderBy: { sortOrder: 'asc' },
+    select: { key: true, name: true, colorToken: true },
+  })
+}
+
+/**
+ * Die AfiS-Mitglieder, die an dieser Personalakte hängen.
+ *
+ * Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe — das ist
+ * derselbe ausnahmsweise Zugang wie `CaseParticipant` bei der Fallakte.
+ */
+export async function listAssignments(p: EffectivePermissions, personnelFileId: string) {
+  return db.personnelAssignment.findMany({
+    where: {
+      AND: [{ personnelFileId }, { personnelFile: { is: visiblePersonnelWhere(p) } }],
+    },
+    orderBy: { createdAt: 'asc' },
+    select: {
+      id: true,
+      role: true,
+      createdAt: true,
+      user: { select: { id: true, displayName: true } },
+    },
+  })
+}
+
+export async function addAssignment(
+  p: EffectivePermissions,
+  input: { personnelFileId: string; userId: string; role: AssignmentRoleName },
+): Promise<{ id: string }> {
+  const target = await loadVisiblePersonnelFile(p, input.personnelFileId)
+  if (!target) throw new AccessError('not-found')
+  must(canWritePersonnel(p, target.classification))
+
+  const mitglied = await db.user.findUnique({
+    where: { id: input.userId },
+    select: { id: true },
+  })
+  if (!mitglied) throw new AccessError('not-found')
+
+  const vorhanden = await db.personnelAssignment.findFirst({
+    where: { personnelFileId: target.id, userId: input.userId, role: input.role },
+    select: { id: true },
+  })
+  if (vorhanden) return vorhanden
+
+  return db.$transaction(async (tx) => {
+    const created = await tx.personnelAssignment.create({
+      data: {
+        personnelFileId: target.id,
+        userId: input.userId,
+        role: input.role,
+        addedById: p.userId,
+      },
+      select: { id: true },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.assign',
+      targetType: 'PersonnelAssignment',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        personnelFileId: target.id,
+        displayName: target.displayName,
+        userId: input.userId,
+        role: input.role,
+      },
+    })
+
+    return created
+  })
+}
+
+export async function removeAssignment(
+  p: EffectivePermissions,
+  input: { personnelFileId: string; assignmentId: string },
+): Promise<void> {
+  const target = await loadVisiblePersonnelFile(p, input.personnelFileId)
+  if (!target) throw new AccessError('not-found')
+  must(canWritePersonnel(p, target.classification))
+
+  const zuordnung = await db.personnelAssignment.findFirst({
+    where: { id: input.assignmentId, personnelFileId: target.id },
+    select: { id: true, userId: true, role: true },
+  })
+  if (!zuordnung) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.personnelAssignment.delete({ where: { id: zuordnung.id } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.unassign',
+      targetType: 'PersonnelAssignment',
+      targetId: zuordnung.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        personnelFileId: target.id,
+        userId: zuordnung.userId,
+        role: zuordnung.role,
+      },
+    })
+  })
+}

web/lib/personnel/terms.ts

@@ -0,0 +1,15 @@
+/**
+ * Feste Wertelisten der Personalakte.
+ *
+ * **Ohne Abhängigkeiten**, weil der Client sie lädt — derselbe Schnitt wie
+ * `lib/cases/terms.ts`. Die Status-Etiketten stehen bewusst **nicht** hier:
+ * sie sind im Adminbereich pflegbar und kommen aus der Datenbank.
+ */
+
+export const ASSIGNMENT_ROLES = ['HANDLER', 'INVESTIGATOR', 'CONTACT'] as const
+
+export type AssignmentRoleName = (typeof ASSIGNMENT_ROLES)[number]
+
+export function isAssignmentRole(value: string): value is AssignmentRoleName {
+  return (ASSIGNMENT_ROLES as readonly string[]).includes(value)
+}

web/lib/templates/fields.ts

@@ -23,10 +23,14 @@ export const INPUT_TYPES = [
   'number',
   'checklist',
   'table',
+  /** Lichtbild. Der Wert ist die Kennung eines geprüften Anhangs, nie ein Bild. */
+  'photo',
+  /** Getippter Name, dargestellt als Zug über einer Linie. */
+  'signature',
 ] as const
 
 /** Bausteine, die aus der Vorlage kommen und nicht ausgefüllt werden. */
-export const STATIC_TYPES = ['heading', 'paragraph', 'signature', 'pagebreak'] as const
+export const STATIC_TYPES = ['heading', 'paragraph', 'pagebreak'] as const
 
 export type InputType = (typeof INPUT_TYPES)[number]
 export type StaticType = (typeof STATIC_TYPES)[number]
@@ -41,6 +45,25 @@ export type InputField = {
   requiredToClose?: boolean
   options?: string[]
   columns?: string[]
+  /**
+   * Breite im Raster des Aktenblatts, 1 bis 5 Spalten. Nur `layout = DOSSIER`
+   * wertet das aus; die übrigen Darstellungen setzen ohnehin untereinander.
+   */
+  span?: number
+  /** Nur bei `photo`: über wie viele Zeilen die Zelle reicht. */
+  rows?: number
+  /**
+   * Statt einer eigenen Zelle im Raster: dieses Feld füllt einen festen Platz
+   * des Aktenblatts. Bekannt ist `classbar` — der Klassifizierungsbalken.
+   */
+  slot?: string
+  /** Hebt den Wert hervor, etwa die Freigabestufen im Aktenblatt. */
+  emphasis?: boolean
+  /**
+   * Nur bei `signature`: Schlüssel des Datumsfeldes, das unter der Zeile
+   * steht. Das genannte Feld bekommt dadurch keine eigene Zelle mehr.
+   */
+  dateKey?: string
 }
 
 export type StaticBlock = {
@@ -50,6 +73,7 @@ export type StaticBlock = {
   help?: string
   minClearance?: number
   text?: string
+  span?: number
 }
 
 export type TemplateField = InputField | StaticBlock
@@ -80,6 +104,78 @@ export function requiredToCloseKeys(fields: TemplateField[]): string[] {
     .map((field) => field.key)
 }
 
+/**
+ * Die Datumsfelder, die eine Unterschrift bereits mitzeichnet. Sie bekommen
+ * im Aktenblatt keine eigene Zelle, bleiben aber ganz normal bearbeitbar.
+ */
+export const DOSSIER_COLUMNS = 5
+
+/**
+ * Zerlegt die Bausteine in die Zeilen des Aktenblatts.
+ *
+ * Solange die Lichtbildzelle mitläuft, ist eine Zeile eine Spalte schmaler —
+ * genau so, wie das Formular es tut. Danach nimmt sie die volle Breite.
+ * Felder, die in einen festen Platz gehören oder von einer Unterschrift
+ * mitgezeichnet werden, tauchen im Raster nicht auf.
+ */
+export function dossierRows(fields: TemplateField[]): {
+  photo: InputField | null
+  photoRows: number
+  rows: TemplateField[][]
+} {
+  const mitgezeichnet = signatureDateKeys(fields)
+  const photo =
+    fields.find((f): f is InputField => isInputField(f) && f.type === 'photo') ?? null
+  const photoRows = photo ? Math.max(1, photo.rows ?? 4) : 0
+
+  const rest = fields.filter(
+    (field) =>
+      field !== photo &&
+      !mitgezeichnet.has(field.key) &&
+      !(isInputField(field) && field.slot),
+  )
+
+  const rows: TemplateField[][] = []
+  let aktuell: TemplateField[] = []
+  let breite = 0
+
+  for (const field of rest) {
+    const grenze = rows.length < photoRows ? DOSSIER_COLUMNS - 1 : DOSSIER_COLUMNS
+    const span = Math.min(field.span ?? grenze, grenze)
+    if (breite + span > grenze && aktuell.length > 0) {
+      rows.push(aktuell)
+      aktuell = []
+      breite = 0
+    }
+    aktuell.push(field)
+    breite += span
+    if (breite >= grenze) {
+      rows.push(aktuell)
+      aktuell = []
+      breite = 0
+    }
+  }
+  if (aktuell.length > 0) rows.push(aktuell)
+
+  return { photo, photoRows, rows }
+}
+
+/** Die Breite einer Zelle in Rasterspalten, begrenzt auf die Zeilenbreite. */
+export function dossierSpan(field: TemplateField, inPhotoRows: boolean): number {
+  const grenze = inPhotoRows ? DOSSIER_COLUMNS - 1 : DOSSIER_COLUMNS
+  return Math.min(field.span ?? grenze, grenze)
+}
+
+export function signatureDateKeys(fields: TemplateField[]): Set<string> {
+  const keys = new Set<string>()
+  for (const field of fields) {
+    if (isInputField(field) && field.type === 'signature' && field.dateKey) {
+      keys.add(field.dateKey)
+    }
+  }
+  return keys
+}
+
 /**
  * Grobe Formprüfung für die Vorschau im Editor. Sagt, ob sich die Eingabe
  * überhaupt darstellen lässt — nicht, ob sie gespeichert werden darf. Das

web/lib/templates/schema.ts

@@ -29,12 +29,18 @@ const inputField = z.object({
   requiredToClose: z.boolean().optional(),
   options: z.array(z.string().min(1)).optional(),
   columns: z.array(z.string().min(1)).optional(),
+  span: z.number().int().min(1).max(5).optional(),
+  rows: z.number().int().min(1).max(12).optional(),
+  slot: z.enum(['classbar']).optional(),
+  emphasis: z.boolean().optional(),
+  dateKey: key.optional(),
 })
 
 const staticBlock = z.object({
   ...gemeinsam,
   type: z.enum(STATIC_TYPES),
   text: z.string().max(20_000).optional(),
+  span: z.number().int().min(1).max(5).optional(),
 })
 
 export const templateFieldSchema = z.union([inputField, staticBlock])
@@ -64,6 +70,14 @@ export const templateFieldsSchema = z
           message: 'Auswahlfelder brauchen mindestens eine Option',
         })
       }
+
+      if ('dateKey' in field && field.dateKey && field.type !== 'signature') {
+        ctx.addIssue({
+          code: 'custom',
+          path: [index, 'dateKey'],
+          message: 'Ein Datumsverweis gehört nur an eine Unterschrift',
+        })
+      }
     }
   })
 

web/tests/aktenblatt-darstellung.test.ts

@@ -0,0 +1,134 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import { createElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { Sheet } from '@/components/documents/Sheet'
+import type { RenderedSection } from '@/lib/sections/render'
+import type { TemplateField } from '@/lib/templates/fields'
+
+/**
+ * Das Blatt wirklich rendern, nicht nur seine Vorlage prüfen.
+ *
+ * Es ist ein Formular, das gedruckt weitergereicht wird: dass ein Feld in der
+ * falschen Zelle landet oder der Klassifizierungsbalken grau bleibt, fällt auf
+ * Papier auf und hier vorher.
+ */
+
+function abschnitt(
+  field: TemplateField,
+  value: unknown,
+  options: { visible?: boolean; requiredLevel?: number } = {},
+): RenderedSection {
+  const gemeinsam = {
+    fieldKey: field.key,
+    field,
+    version: 1,
+    updatedAt: null,
+    updatedById: null,
+  }
+  if (options.visible === false) {
+    return {
+      ...gemeinsam,
+      visible: false,
+      value: { redacted: true, requiredLevel: options.requiredLevel ?? 4 },
+    }
+  }
+  return { ...gemeinsam, visible: true, value, segments: null }
+}
+
+const STUFEN = [
+  { level: 1, name: 'Vertraulich', colorHex: '#1e3a5f' },
+  { level: 4, name: 'Streng Geheim', colorHex: '#450a0a' },
+]
+
+function blatt(sections: RenderedSection[]): string {
+  return renderToStaticMarkup(
+    createElement(Sheet, {
+      sections,
+      title: 'SCP Foundation',
+      subtitle: 'Personalakte // Personalabteilung',
+      documentNumber: 'PA-2026-0042',
+      issuedAt: new Date('2026-03-14T10:00:00Z'),
+      foundationLevels: STUFEN,
+      footerNote: 'Nur für autorisiertes Personal.',
+    }),
+  )
+}
+
+describe('Aktenblatt, gerendert', () => {
+  const felder: TemplateField[] = [
+    { key: 'foundation_klassifikation', label: 'Klassifikation', type: 'select', slot: 'classbar' },
+    { key: 'lichtbild', label: 'Lichtbild', type: 'photo', rows: 2 },
+    { key: 'name', label: 'Name', type: 'shorttext', span: 2 },
+    { key: 'vorname', label: 'Vorname', type: 'shorttext', span: 2 },
+    { key: 'alter', label: 'Alter', type: 'shorttext', span: 4 },
+    { key: 'wissensfreigabe', label: 'Wissensfreigabe', type: 'shorttext', span: 5, emphasis: true },
+    {
+      key: 'standortleiter',
+      label: 'Standortleiter',
+      type: 'signature',
+      span: 5,
+      dateKey: 'standortleiter_datum',
+    },
+    { key: 'standortleiter_datum', label: 'Datum', type: 'date' },
+  ]
+
+  const gefuellt = [
+    abschnitt(felder[0]!, '4'),
+    abschnitt(felder[1]!, null),
+    abschnitt(felder[2]!, 'Vogt'),
+    abschnitt(felder[3]!, 'Marlene'),
+    abschnitt(felder[4]!, '38'),
+    abschnitt(felder[5]!, 'Stufe 3 / Projekt Nachtblende'),
+    abschnitt(felder[6]!, 'M. Rutkowski'),
+    abschnitt(felder[7]!, '14.03.2026'),
+  ]
+
+  it('setzt die Werte in das Raster und zeichnet den Balken in der Stufenfarbe', () => {
+    const html = blatt(gefuellt)
+
+    expect(html).toContain('PA-2026-0042')
+    expect(html).toContain('Vogt')
+    expect(html).toContain('Marlene')
+
+    // Der Balken trägt die Farbe und den Namen der gewählten Stufe.
+    expect(html).toContain('#450a0a')
+    expect(html).toContain('Streng Geheim')
+    expect(html).toContain('Level 4')
+
+    // Das Lichtbild spannt über die angegebene Zeilenzahl. React schreibt das
+    // Attribut in gemischter Schreibweise; HTML wertet sie ohnehin nicht.
+    expect(html.toLowerCase()).toContain('rowspan="2"')
+
+    // Die Unterschrift trägt das Datum mit, das Datum hat keine eigene Zelle.
+    expect(html).toContain('M. Rutkowski')
+    // Zweistellig wie auf dem Formular, und nur einmal: das Datum der
+    // Unterschrift hat keine eigene Zelle.
+    expect(html.match(/14\.03\.2026/g)).toHaveLength(2)
+    expect(html).not.toContain('14.3.2026')
+  })
+
+  it('lässt den Balken neutral, wenn keine Klassifikation gesetzt ist', () => {
+    const ohne = [abschnitt(felder[0]!, null), ...gefuellt.slice(1)]
+    const html = blatt(ohne)
+
+    // Kein erfundener Anschein von Einstufung.
+    expect(html).not.toContain('#450a0a')
+    expect(html).toContain('#333333')
+    expect(html).toContain('Ohne Klassifikation')
+  })
+
+  it('zeigt statt eines gesperrten Feldes einen Balken, nie den Wert', () => {
+    const gesperrt = gefuellt.map((section) =>
+      section.fieldKey === 'wissensfreigabe'
+        ? abschnitt(felder[5]!, null, { visible: false, requiredLevel: 4 })
+        : section,
+    )
+    const html = blatt(gesperrt)
+
+    expect(html).not.toContain('Nachtblende')
+    expect(html).toContain('redaction')
+    // Die Beschriftung bleibt: dass es das Feld gibt, ist kein Geheimnis.
+    expect(html).toContain('Wissensfreigabe')
+  })
+})

web/tests/aktenblatt.test.ts

@@ -0,0 +1,124 @@
+// @vitest-environment node
+import { afterAll, describe, expect, it } from 'vitest'
+import { db } from '@/lib/db'
+import { parseTemplateFields } from '@/lib/templates/schema'
+import { dossierRows, dossierSpan, isInputField } from '@/lib/templates/fields'
+
+/**
+ * Das Aktenblatt der Personalabteilung.
+ *
+ * Der erste Test ist der wichtigere: `parseTemplateFields` gibt bei einer
+ * ungültigen Vorlage eine **leere Liste** zurück, statt zu werfen. Ein Tippfehler
+ * im Seed würde das Blatt also lautlos leeren, statt aufzufallen.
+ */
+const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
+const suite = url ? describe : describe.skip
+
+suite('Vorlage des Aktenblatts', () => {
+  afterAll(async () => {
+    await db.$disconnect()
+  })
+
+  async function felder() {
+    const vorlage = await db.documentTemplate.findFirst({
+      where: { key: 'personalakte', isActive: true },
+      orderBy: { version: 'desc' },
+      select: { fields: true, layout: true, uses: true, sheetTitle: true, sheetSubtitle: true },
+    })
+    expect(vorlage).not.toBeNull()
+    return { vorlage: vorlage!, fields: parseTemplateFields(vorlage!.fields) }
+  }
+
+  it('übersteht die verbindliche Prüfung vollständig', async () => {
+    const { vorlage, fields } = await felder()
+
+    // Kein stilles Leerlaufen: die Zahl muss stimmen, nicht nur "grösser null".
+    expect(fields).toHaveLength(
+      (vorlage.fields as unknown[]).length,
+    )
+    expect(vorlage.layout).toBe('DOSSIER')
+    expect(vorlage.uses).toEqual(['PERSON_DOCUMENT'])
+    expect(vorlage.sheetSubtitle).toBeTruthy()
+
+    // Die Felder, die das Blatt ausmachen.
+    const schluessel = fields.map((f) => f.key)
+    for (const key of [
+      'lichtbild',
+      'name',
+      'vorname',
+      'alter',
+      'geschlecht',
+      'groesse',
+      'abteilung',
+      'dienstgrad',
+      'sicherheitsfreigabe',
+      'wissensfreigabe',
+      'konfession',
+      'adresse',
+      'anmerkungen',
+      'personalarbeiter',
+      'standortleiter',
+    ]) {
+      expect(schluessel).toContain(key)
+    }
+  })
+
+  it('ergibt genau das Raster des Formulars', async () => {
+    const { fields } = await felder()
+    const { photo, photoRows, rows } = dossierRows(fields)
+
+    expect(photo?.key).toBe('lichtbild')
+    expect(photoRows).toBe(4)
+
+    // Neben dem Lichtbild vier Zeilen zu je vier Spalten, danach fünf.
+    const struktur = rows.map((row, index) =>
+      row.map((field) => `${field.key}:${dossierSpan(field, index < photoRows)}`),
+    )
+    expect(struktur).toEqual([
+      ['name:2', 'vorname:2'],
+      ['alter:2', 'geschlecht:2'],
+      ['groesse:4'],
+      ['abteilung:2', 'dienstgrad:2'],
+      ['sicherheitsfreigabe:3', 'wissensfreigabe:2'],
+      ['konfession:2', 'adresse:3'],
+      ['anmerkungen:5'],
+      ['personalarbeiter:3', 'standortleiter:2'],
+    ])
+  })
+
+  it('lässt die Datumsfelder der Unterschriften aus dem Raster heraus', async () => {
+    const { fields } = await felder()
+    const { rows } = dossierRows(fields)
+    const imRaster = rows.flat().map((f) => f.key)
+
+    // Sie stehen unter der jeweiligen Unterschrift, nicht in einer eigenen
+    // Zelle — bearbeitbar bleiben sie trotzdem.
+    expect(imRaster).not.toContain('personalarbeiter_datum')
+    expect(imRaster).not.toContain('standortleiter_datum')
+    expect(fields.map((f) => f.key)).toContain('personalarbeiter_datum')
+  })
+
+  it('hält die Klassifikation aus dem Raster heraus, sie gehört in den Balken', async () => {
+    const { fields } = await felder()
+    const { rows } = dossierRows(fields)
+    expect(rows.flat().map((f) => f.key)).not.toContain('foundation_klassifikation')
+
+    const feld = fields.find((f) => f.key === 'foundation_klassifikation')
+    expect(feld && isInputField(feld) && feld.slot).toBe('classbar')
+  })
+
+  it('kennt für jede Klassifikationsstufe eine Farbe', async () => {
+    const { fields } = await felder()
+    const feld = fields.find((f) => f.key === 'foundation_klassifikation')
+    const stufen = await db.foundationClearance.findMany({ orderBy: { level: 'asc' } })
+
+    // Sonst bliebe der Balken bei einer gültigen Auswahl grau.
+    const optionen = feld && isInputField(feld) ? (feld.options ?? []) : []
+    for (const option of optionen) {
+      expect(stufen.map((s) => String(s.level))).toContain(option)
+    }
+    for (const stufe of stufen) {
+      expect(stufe.colorHex).toMatch(/^#[0-9a-f]{6}$/i)
+    }
+  })
+})

web/tests/personalakte.test.ts

@@ -2,7 +2,12 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
-import { loadBacklinks } from '@/lib/personnel/service'
+import {
+  addAssignment,
+  createPersonnelFile,
+  loadBacklinks,
+  updatePersonnelFile,
+} from '@/lib/personnel/service'
 import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
 
 /**
@@ -160,6 +165,76 @@ suite('Personalakten und Rückverweise', () => {
     expect(anzahl).toBe(1)
   })
 
+  it('nimmt nur Status-Etiketten an, die es wirklich gibt', async () => {
+    const leitung = perms(nutzer.stufe3, 3, { permissions: ['personnel.edit'] })
+    const akte = await createPersonnelFile(leitung, {
+      displayName: `${marke} Etikettentest`,
+      classification: 1,
+      // "erfunden" steht in keiner Konfiguration und darf nicht durchrutschen,
+      // sonst wäre die Liste im Adminbereich nur eine Empfehlung.
+      statusTags: ['tot', 'erfunden', 'verhaftet'],
+    })
+
+    const gespeichert = await db.personnelFile.findUniqueOrThrow({
+      where: { id: akte.id },
+      select: { statusTags: true },
+    })
+    expect(gespeichert.statusTags).toEqual(['verhaftet', 'tot'])
+
+    // Und die Reihenfolge kommt aus der Konfiguration, nicht aus der Eingabe:
+    // auf jeder Akte steht dieselbe Abfolge.
+    await updatePersonnelFile(leitung, akte.id, { statusTags: ['tot', 'verhaftet'] })
+    const danach = await db.personnelFile.findUniqueOrThrow({
+      where: { id: akte.id },
+      select: { statusTags: true },
+    })
+    expect(danach.statusTags).toEqual(['verhaftet', 'tot'])
+  })
+
+  it('lässt ein zugeordnetes Mitglied auch über seiner Stufe lesen', async () => {
+    const p = perms(nutzer.stufe1, 1)
+
+    // Vorher: die Akte der Stufe 4 ist für ihn nicht da.
+    expect(
+      await db.personnelFile.findMany({
+        where: { AND: [visiblePersonnelWhere(p), { id: hoheAkteId }] },
+        select: { id: true },
+      }),
+    ).toHaveLength(0)
+
+    await addAssignment(perms(nutzer.stufe3, 3, { isAdmin: true }), {
+      personnelFileId: hoheAkteId,
+      userId: nutzer.stufe1,
+      role: 'INVESTIGATOR',
+    })
+
+    // Danach schon — das ist der ausnahmsweise Zugang, wie bei der Fallakte.
+    expect(
+      await db.personnelFile.findMany({
+        where: { AND: [visiblePersonnelWhere(p), { id: hoheAkteId }] },
+        select: { id: true },
+      }),
+    ).toHaveLength(1)
+  })
+
+  it('gibt der betroffenen Person selbst keinen Zugriff auf ihre Akte', async () => {
+    const eigene = await db.personnelFile.create({
+      data: {
+        displayName: `${marke} Eigene`,
+        userId: nutzer.betroffen,
+        classification: 4,
+      },
+    })
+
+    // Eine Beurteilung auf Stufe 4 über einen Mitarbeiter der Stufe 1 wäre
+    // sonst genau für den einen Menschen lesbar, vor dem sie schützt.
+    const treffer = await db.personnelFile.findMany({
+      where: { AND: [visiblePersonnelWhere(perms(nutzer.betroffen, 1)), { id: eigene.id }] },
+      select: { id: true },
+    })
+    expect(treffer).toHaveLength(0)
+  })
+
   it('gibt dem Admin die verborgene Personalakte', async () => {
     const treffer = await db.personnelFile.findMany({
       where: {