Phase 4 abgeschlossen: Personalakten, Dokumente, Beteiligte, Verknüpfungen

Die Dokumentebene aus docs/13 ist gebaut, additiv: Document, DocumentSection
und DocumentSectionVersion neben Case, CaseSection und CaseEntry. Ein Dokument
hängt an einer Fallakte, an einer Personalakte oder an nichts, höchstens an
einem - gesichert durch eine CHECK-Bedingung. Es gibt kein DELETE; eine
Zurücknahme lässt einen Grabstein stehen, der auch für den Admin zu ist.

Eine neue Dokumentart ist damit ein Datensatz, kein Deployment. Im Seed stehen
vier: vermerk, vorfallsbericht, sonderarbeitsvertrag (mehrseitiger Vertragstext
mit Platzhaltern und Unterschriftenzeilen) und bussgeld.

Zwei Umbenennungen, beide von Hand migriert, damit die vorhandenen Zeilen und
Zählerstände stehen bleiben:
- CaseTemplate -> DocumentTemplate, plus uses[] und layout
- CaseCounter -> NumberSeries, ein Nummernkreis je Präfix für Aktenzeichen
  und Dokumentnummern

Die Regeln für Abschnitte stehen jetzt einmal in lib/sections/render.ts und
gelten für Fallakten und Dokumente gleichermaßen. Die Frage aus docs/13, ob
CaseSection langfristig in die Dokumentebene wandert, ist damit verneint und
begründet.

Rückverweise auf der Personalakte laufen durch visibleCaseWhere, die Zahl
daneben entsteht aus dem gefilterten Ergebnis. Auch die Rollengruppe
verschwindet mit, sonst verriete "Betroffener" ohne Eintrag die Ermittlung.
Die eigene Personalakte ist keine Ausnahme von der Freigabestufe.

Vier neue Rechte: document.create, .edit, .finalize, .retract. Das letzte
steht bei den zurückgehaltenen, es greift in Geschriebenes ein.

91 Tests im Web-Paket, 15 in der Datenbank, 28 e2e. Größte Route 118 kB
gegen das Budget von 120 kB - die Luft wird knapp.

web/lib/access/documentWrite.ts

@@ -0,0 +1,113 @@
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+import type { WriteCheck } from '@/lib/access/caseWrite'
+
+/**
+ * Schreibgrenzen für Personalakten und Dokumente.
+ *
+ * Dieselbe Bauform wie `caseWrite.ts`: reine Funktionen, die auch dann greifen,
+ * wenn die Oberfläche einen Knopf versehentlich stehen lässt. Jede Server
+ * Action ruft sie auf, nicht nur die, die den Knopf zeichnet.
+ */
+
+/** Status, in denen ein Dokument nicht mehr verändert wird. */
+export const READ_ONLY_DOCUMENT_STATUS = ['RETRACTED'] as const
+
+function requirePermission(p: EffectivePermissions, permission: Permission): WriteCheck {
+  if (p.isAdmin || p.permissions.has(permission)) return { ok: true }
+  return { ok: false, reason: 'no-permission', permission }
+}
+
+/**
+ * Darf dieser Nutzer eine Personalakte mit dieser Klassifizierung anlegen oder
+ * auf diese Stufe heben? Wie bei der Fallakte: nie über der eigenen Stufe.
+ */
+export function canWritePersonnel(
+  p: EffectivePermissions,
+  classification: number,
+): WriteCheck {
+  const permitted = requirePermission(p, 'personnel.edit')
+  if (!permitted.ok) return permitted
+  if (classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: classification }
+  }
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer ein Dokument mit dieser Klassifizierung anlegen?
+ *
+ * Der Besitzer ist vorher schon durch die Sichtbarkeitsprüfung gelaufen — was
+ * man nicht sieht, kann man nicht bestücken.
+ */
+export function canCreateDocument(
+  p: EffectivePermissions,
+  classification: number,
+): WriteCheck {
+  const permitted = requirePermission(p, 'document.create')
+  if (!permitted.ok) return permitted
+  if (classification > p.clearanceLevel) {
+    return { ok: false, reason: 'clearance-too-low', required: classification }
+  }
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer dieses Dokument ändern?
+ *
+ * Ein zurückgezogenes Dokument ist endgültig schreibgeschützt, auch für
+ * Admins: es steht als Grabstein und darf nicht nachträglich zu etwas anderem
+ * werden. Ein ausgefertigtes Dokument zu ändern setzt dasselbe Recht voraus,
+ * das die Ausfertigung erlaubt hat.
+ */
+export function canEditDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if ((READ_ONLY_DOCUMENT_STATUS as readonly string[]).includes(target.status)) {
+    return { ok: false, reason: 'read-only', status: target.status }
+  }
+
+  const permitted = requirePermission(p, 'document.edit')
+  if (!permitted.ok) return permitted
+
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+
+  if (target.status === 'FINAL') {
+    const final = requirePermission(p, 'document.finalize')
+    if (!final.ok) return { ok: false, reason: 'closed' }
+  }
+
+  return { ok: true }
+}
+
+/** Ausfertigen: aus einem Entwurf wird ein gültiges Dokument. */
+export function canFinalizeDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if (target.status !== 'DRAFT') return { ok: false, reason: 'read-only', status: target.status }
+  const permitted = requirePermission(p, 'document.finalize')
+  if (!permitted.ok) return permitted
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+  return { ok: true }
+}
+
+/** Zurückziehen. Löschen gibt es nicht, der Grabstein bleibt stehen. */
+export function canRetractDocument(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+): WriteCheck {
+  if (target.status === 'RETRACTED') {
+    return { ok: false, reason: 'read-only', status: target.status }
+  }
+  const permitted = requirePermission(p, 'document.retract')
+  if (!permitted.ok) return permitted
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+  return { ok: true }
+}

web/lib/access/personnelFilter.ts

@@ -0,0 +1,68 @@
+import type { Prisma } from '@afis/db'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+
+/**
+ * Where-Fragmente für Personalakten und Dokumente.
+ *
+ * Wie bei den Fallakten gilt: **die Prüfung wird nie in JavaScript
+ * nachgelagert.** Trefferzahlen, Rückverweise und Paginierung laufen über
+ * dieselbe Abfrage. Siehe docs/03-auth-und-rechte.md.
+ */
+
+/**
+ * Personalakten, die ein Nutzer lesen darf.
+ *
+ * Anders als bei der Fallakte gibt es hier keinen „Beteiligten": eine
+ * Personalakte hat keine Ermittlergruppe. Es zählt allein die Freigabestufe.
+ *
+ * Auch die eigene Akte ist keine Ausnahme. Das ist bewusst so: 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.
+ */
+export function visiblePersonnelWhere(p: EffectivePermissions): Prisma.PersonnelFileWhereInput {
+  if (p.isAdmin) return {}
+  return { classification: { lte: p.clearanceLevel } }
+}
+
+/**
+ * Dokumente, die ein Nutzer lesen darf.
+ *
+ * Zwei Bedingungen, beide müssen zutreffen:
+ *
+ *  1. **Der Besitzer muss lesbar sein.** Ein Vertrag an einer Personalakte der
+ *     Stufe 4 bleibt verborgen, auch wenn der Vertrag selbst Stufe 1 trägt —
+ *     sonst verriete die Dokumentenliste die Existenz der Person.
+ *  2. **Das Dokument selbst muss lesbar sein.** Innerhalb einer sichtbaren
+ *     Akte kann ein einzelnes Dokument höher klassifiziert sein.
+ *
+ * Wer an der besitzenden Fallakte beteiligt ist, liest ihre Dokumente
+ * unabhängig von seiner Stufe — das ist derselbe ausnahmsweise Zugang wie beim
+ * Verlauf, siehe docs/03-auth-und-rechte.md. Für Dokumente an einer
+ * Personalakte und für Dokumente ohne Besitzer gibt es diesen Weg nicht.
+ */
+export function visibleDocumentWhere(p: EffectivePermissions): Prisma.DocumentWhereInput {
+  const besitzerLesbar: Prisma.DocumentWhereInput = {
+    OR: [
+      { case: { is: visibleCaseWhere(p) } },
+      { personnelFile: { is: visiblePersonnelWhere(p) } },
+      // Ohne Besitzer, etwa ein Bußgeldbescheid: dann entscheidet allein die
+      // Klassifizierung des Dokuments.
+      { AND: [{ caseId: null }, { personnelFileId: null }] },
+    ],
+  }
+
+  if (p.isAdmin) return besitzerLesbar
+
+  return {
+    AND: [
+      besitzerLesbar,
+      {
+        OR: [
+          { classification: { lte: p.clearanceLevel } },
+          { case: { is: { participants: { some: { userId: p.userId } } } } },
+        ],
+      },
+    ],
+  }
+}

web/lib/audit.ts

@@ -24,6 +24,20 @@ export type AuditAction =
   | 'entry.edit'
   | 'entry.retract'
   | 'entry.restore'
+  | 'case.participant.add'
+  | 'case.participant.remove'
+  | 'case.link'
+  | 'case.unlink'
+  | 'personnel.read'
+  | 'personnel.create'
+  | 'personnel.update'
+  | 'personnel.reclassify'
+  | 'document.read'
+  | 'document.create'
+  | 'document.update'
+  | 'document.finalize'
+  | 'document.retract'
+  | 'document.reclassify'
   | 'roles.update'
   | 'export.pdf'
 

web/lib/auth/permissions.ts

@@ -17,6 +17,10 @@ export const PERMISSIONS = [
   'entry.retract',
   'personnel.read',
   'personnel.edit',
+  'document.create',
+  'document.edit',
+  'document.finalize',
+  'document.retract',
   'template.manage',
   'roles.manage',
   'audit.read',
@@ -34,6 +38,7 @@ export const OPT_IN_PERMISSIONS: readonly Permission[] = [
   'entry.edit_own',
   'entry.edit_any',
   'entry.retract',
+  'document.retract',
 ]
 
 export function isPermission(value: string): value is Permission {

web/lib/cases/links.ts

@@ -0,0 +1,128 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { loadVisibleCase } from '@/lib/cases/service'
+import type { LinkKindName } from '@/lib/cases/terms'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Verknüpfungen zwischen Akten.
+ *
+ * Die Richtung trägt Bedeutung: `SUCCESSOR` und `MERGED_INTO` sagen etwas
+ * anderes, je nachdem, von welcher Seite man liest. `RELATED` ist symmetrisch.
+ *
+ * Beide Seiten laufen durch die Sichtbarkeitsprüfung. Eine Akte, die der Leser
+ * nicht sehen darf, taucht auch als Verknüpfung nicht auf — sonst verriete die
+ * Gegenseite ihre Existenz. Das gilt in **beide** Richtungen, deshalb wird der
+ * Filter zweimal angewandt.
+ */
+
+const AKTE = {
+  id: true,
+  caseNumber: true,
+  title: true,
+  status: true,
+  classification: true,
+  updatedAt: true,
+} as const
+
+/** Alle Verknüpfungen einer Akte, aus beiden Richtungen, gefiltert. */
+export async function listLinks(p: EffectivePermissions, caseId: string) {
+  const sichtbar = visibleCaseWhere(p)
+
+  const [hinaus, herein] = await Promise.all([
+    db.caseLink.findMany({
+      where: { AND: [{ fromId: caseId }, { to: { is: sichtbar } }] },
+      select: { kind: true, createdAt: true, to: { select: AKTE } },
+      orderBy: { createdAt: 'desc' },
+    }),
+    db.caseLink.findMany({
+      where: { AND: [{ toId: caseId }, { from: { is: sichtbar } }] },
+      select: { kind: true, createdAt: true, from: { select: AKTE } },
+      orderBy: { createdAt: 'desc' },
+    }),
+  ])
+
+  return [
+    ...hinaus.map((link) => ({
+      kind: link.kind,
+      direction: 'out' as const,
+      other: link.to,
+      createdAt: link.createdAt,
+    })),
+    ...herein.map((link) => ({
+      kind: link.kind,
+      direction: 'in' as const,
+      other: link.from,
+      createdAt: link.createdAt,
+    })),
+  ]
+}
+
+export async function linkCases(
+  p: EffectivePermissions,
+  input: { fromCaseNumber: string; toCaseNumber: string; kind: LinkKindName },
+): Promise<void> {
+  const from = await loadVisibleCase(p, input.fromCaseNumber)
+  if (!from) throw new AccessError('not-found')
+  must(canEditCase(p, from))
+
+  const to = await loadVisibleCase(p, input.toCaseNumber.trim())
+  if (!to) throw new AccessError('not-found')
+  if (to.id === from.id) throw new AccessError('link-self')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseLink.upsert({
+      where: { fromId_toId_kind: { fromId: from.id, toId: to.id, kind: input.kind } },
+      create: { fromId: from.id, toId: to.id, kind: input.kind, createdById: p.userId },
+      update: {},
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.link',
+      targetType: 'Case',
+      targetId: from.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: from.caseNumber, to: to.caseNumber, kind: input.kind },
+    })
+  })
+}
+
+/**
+ * Verknüpfung lösen. Umkehrbar und deshalb ohne Bestätigungsdialog, siehe
+ * docs/09-performance-und-ux.md. Das Protokoll behält sie.
+ */
+export async function unlinkCases(
+  p: EffectivePermissions,
+  input: { fromCaseNumber: string; toCaseNumber: string; kind: LinkKindName },
+): Promise<void> {
+  const from = await loadVisibleCase(p, input.fromCaseNumber)
+  if (!from) throw new AccessError('not-found')
+  must(canEditCase(p, from))
+
+  const to = await loadVisibleCase(p, input.toCaseNumber)
+  if (!to) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseLink.deleteMany({
+      where: {
+        OR: [
+          { fromId: from.id, toId: to.id, kind: input.kind },
+          { fromId: to.id, toId: from.id, kind: input.kind },
+        ],
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.unlink',
+      targetType: 'Case',
+      targetId: from.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: from.caseNumber, to: to.caseNumber, kind: input.kind },
+    })
+  })
+}

web/lib/cases/participants.ts

@@ -0,0 +1,183 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { loadVisibleCase } from '@/lib/cases/service'
+import type { ParticipantRoleName } from '@/lib/cases/terms'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Beteiligte einer Akte.
+ *
+ * Zwei Dinge zugleich: eine fachliche Angabe („wer ist Zeuge") und der Weg zum
+ * **ausnahmsweisen Zugang**. Wer als Beteiligter eingetragen ist, liest die
+ * Akte unabhängig von seiner Freigabestufe. Das ist der vorgesehene Weg,
+ * jemanden gezielt hinzuzuziehen, ohne ihm allgemein eine höhere Stufe zu
+ * geben. Es setzt `case.edit` voraus und wird protokolliert.
+ * Siehe docs/03-auth-und-rechte.md.
+ */
+
+export async function listParticipants(p: EffectivePermissions, caseId: string) {
+  const rows = await db.caseParticipant.findMany({
+    where: { AND: [{ caseId }, { case: { is: visibleCaseWhere(p) } }] },
+    orderBy: { createdAt: 'asc' },
+    select: {
+      id: true,
+      role: true,
+      createdAt: true,
+      addedById: true,
+      user: { select: { id: true, displayName: true } },
+      // Die Personalakte kommt nur mit, wenn der Leser sie sehen darf. Sonst
+      // steht der Name da, aber der Verweis führt ins Leere — das ist richtig
+      // so: der Beteiligte ist Teil der Akte, seine Personalakte nicht.
+      personnelFile: { select: { id: true, displayName: true } },
+    },
+  })
+
+  const sichtbareAkten = new Set(
+    (
+      await db.personnelFile.findMany({
+        where: {
+          AND: [
+            visiblePersonnelWhere(p),
+            {
+              id: {
+                in: rows.flatMap((row) => (row.personnelFile ? [row.personnelFile.id] : [])),
+              },
+            },
+          ],
+        },
+        select: { id: true },
+      })
+    ).map((row) => row.id),
+  )
+
+  return rows.map((row) => ({
+    id: row.id,
+    role: row.role,
+    createdAt: row.createdAt,
+    userId: row.user?.id ?? null,
+    displayName: row.user?.displayName ?? row.personnelFile?.displayName ?? null,
+    personnelFileId:
+      row.personnelFile && sichtbareAkten.has(row.personnelFile.id) ? row.personnelFile.id : null,
+  }))
+}
+
+/**
+ * Trägt einen Beteiligten ein. Entweder ein Discord-Konto oder eine
+ * Personalakte, nicht beides und nicht keins.
+ */
+export async function addParticipant(
+  p: EffectivePermissions,
+  input: {
+    caseNumber: string
+    role: ParticipantRoleName
+    userId?: string | null
+    personnelFileId?: string | null
+  },
+): Promise<{ id: string }> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canEditCase(p, target))
+
+  const userId = input.userId || null
+  const personnelFileId = input.personnelFileId || null
+  if ((userId === null) === (personnelFileId === null)) throw new AccessError('participant-target')
+
+  if (userId) {
+    const vorhanden = await db.user.findUnique({ where: { id: userId }, select: { id: true } })
+    if (!vorhanden) throw new AccessError('not-found')
+  }
+  if (personnelFileId) {
+    // Eine Personalakte, die der Eintragende nicht sehen darf, kann er auch
+    // nicht als Beteiligte setzen — sonst verrät ihm die Fehlermeldung ihre
+    // Existenz.
+    const akte = await db.personnelFile.findFirst({
+      where: { AND: [visiblePersonnelWhere(p), { id: personnelFileId }] },
+      select: { id: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+  }
+
+  const bereitsDa = await db.caseParticipant.findFirst({
+    where: { caseId: target.id, role: input.role, userId, personnelFileId },
+    select: { id: true },
+  })
+  if (bereitsDa) return bereitsDa
+
+  return db.$transaction(async (tx) => {
+    const created = await tx.caseParticipant.create({
+      data: { caseId: target.id, role: input.role, userId, personnelFileId, addedById: p.userId },
+      select: { id: true },
+    })
+
+    // Sichtbar im Verlauf, nicht nur im Protokoll: dass jemand Zugang zu einer
+    // Akte bekommt, geht alle an, die die Akte lesen.
+    await tx.caseEntry.create({
+      data: {
+        id: crypto.randomUUID(),
+        caseId: target.id,
+        type: 'SYSTEM',
+        body: `Beteiligte eingetragen: ${input.role}`,
+        authorId: p.userId,
+        minClearance: 0,
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.participant.add',
+      targetType: 'CaseParticipant',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        caseNumber: target.caseNumber,
+        role: input.role,
+        userId: userId ?? undefined,
+        personnelFileId: personnelFileId ?? undefined,
+      },
+    })
+
+    return created
+  })
+}
+
+/**
+ * Entfernt einen Beteiligten. Anders als ein Verlaufseintrag ist das keine
+ * Aussage über den Sachverhalt, sondern eine Zuständigkeit — sie darf
+ * verschwinden. Das Protokoll behält sie.
+ */
+export async function removeParticipant(
+  p: EffectivePermissions,
+  input: { caseNumber: string; participantId: string },
+): Promise<void> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canEditCase(p, target))
+
+  const teilnehmer = await db.caseParticipant.findFirst({
+    where: { id: input.participantId, caseId: target.id },
+    select: { id: true, role: true, userId: true, personnelFileId: true },
+  })
+  if (!teilnehmer) throw new AccessError('not-found')
+
+  await db.$transaction(async (tx) => {
+    await tx.caseParticipant.delete({ where: { id: teilnehmer.id } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.participant.remove',
+      targetType: 'CaseParticipant',
+      targetId: teilnehmer.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        caseNumber: target.caseNumber,
+        role: teilnehmer.role,
+        userId: teilnehmer.userId ?? undefined,
+        personnelFileId: teilnehmer.personnelFileId ?? undefined,
+      },
+    })
+  })
+}

web/lib/cases/sectionService.ts

@@ -1,97 +1,44 @@
 import { db } from '@/lib/db'
 import { writeAudit } from '@/lib/audit'
 import { canEditCase } from '@/lib/access/caseWrite'
-import { AccessError, loadVisibleCase } from '@/lib/cases/service'
-import { isInputField, type TemplateField } from '@/lib/templates/fields'
+import { loadVisibleCase } from '@/lib/cases/service'
+import { AccessError } from '@/lib/errors'
 import { parseTemplateFields } from '@/lib/templates/schema'
-import { redactForLevel, type Segment } from '@/lib/redaction'
+import {
+  asJson,
+  planSectionSave,
+  renderSections,
+  type RenderedSection,
+} from '@/lib/sections/render'
+import type { TemplateField } from '@/lib/templates/fields'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
-import type { Prisma } from '@afis/db'
 
 /**
  * Abschnitte einer Fallakte: der aktuelle Sachstand, aus der Vorlage erzeugt
  * und je Feld versioniert. Siehe docs/05-akten-und-vorlagen.md.
+ *
+ * Die Regeln stehen in `lib/sections/render.ts`, weil Dokumente dieselben
+ * haben. Hier steht nur, welche Tabelle gelesen und geschrieben wird.
  */
 
-/** Was ein Leser sieht, dessen Stufe für ein Feld nicht reicht. */
-export type Placeholder = { redacted: true; requiredLevel: number }
-
-export type RenderedSection = {
-  fieldKey: string
-  field: TemplateField
-  version: number
-  updatedAt: Date | null
-  updatedById: string | null
-} & (
-  | { visible: true; value: unknown; segments: Segment[] | null }
-  | { visible: false; value: Placeholder }
-)
-
-/**
- * Prisma trennt „Feld nicht setzen" von „JSON null". Ein leerer Abschnitt ist
- * inhaltlich JSON null, nicht das Fehlen des Feldes.
- */
-function asJson(value: unknown): Prisma.InputJsonValue {
-  return (value ?? null) as Prisma.InputJsonValue
-}
+export type { RenderedSection, Placeholder } from '@/lib/sections/render'
+export { ConflictError } from '@/lib/errors'
 
 export function templateFields(raw: unknown): TemplateField[] {
   return parseTemplateFields(raw)
 }
 
-/**
- * Lädt die Abschnitte einer Akte und wendet dabei die Stufe des Lesers an.
- *
- * Felder über seiner Stufe werden **serverseitig** durch einen Platzhalter
- * ersetzt. Der echte Wert verlässt den Server nicht — nie im Client
- * ausblenden. Dasselbe gilt für Schwärzungen im Fliesstext, die als Segmente
- * zurückkommen.
- */
 export async function loadSections(
   p: EffectivePermissions,
   caseId: string,
   templateId: string,
 ): Promise<RenderedSection[]> {
   const [template, rows] = await Promise.all([
-    db.caseTemplate.findUnique({ where: { id: templateId }, select: { fields: true } }),
+    db.documentTemplate.findUnique({ where: { id: templateId }, select: { fields: true } }),
     db.caseSection.findMany({ where: { caseId } }),
   ])
 
-  const fields = templateFields(template?.fields)
-  const byKey = new Map(rows.map((row) => [row.fieldKey, row]))
-
-  return fields.map((field): RenderedSection => {
-    const row = byKey.get(field.key)
-    const required = Math.max(field.minClearance ?? 0, row?.minClearance ?? 0)
-    const common = {
-      fieldKey: field.key,
-      field,
-      version: row?.currentVersion ?? 0,
-      updatedAt: row?.updatedAt ?? null,
-      updatedById: row?.updatedById ?? null,
-    }
-
-    if (!p.isAdmin && required > p.clearanceLevel) {
-      return { ...common, visible: false, value: { redacted: true, requiredLevel: required } }
-    }
-
-    const value = row?.value ?? null
-    const segments =
-      isInputField(field) && field.type === 'longtext' && typeof value === 'string'
-        ? redactForLevel(value, p.clearanceLevel)
-        : null
-
-    return { ...common, visible: true, value, segments }
-  })
-}
-
-export class ConflictError extends Error {
-  constructor(
-    readonly current: { value: unknown; version: number; updatedById: string | null },
-  ) {
-    super('conflict')
-    this.name = 'ConflictError'
-  }
+  return renderSections(templateFields(template?.fields), rows, p)
 }
 
 /**
@@ -99,7 +46,6 @@ export class ConflictError extends Error {
  *
  * Der Client schickt die Version mit, die er geladen hat. Weicht sie ab, gibt
  * es kein stilles Überschreiben, sondern einen Konflikt mit beiden Fassungen.
- * Siehe docs/05-akten-und-vorlagen.md.
  */
 export async function saveSection(
   p: EffectivePermissions,
@@ -118,32 +64,24 @@ export async function saveSection(
   const check = canEditCase(p, target)
   if (!check.ok) throw new AccessError(check.reason)
 
-  const template = await db.caseTemplate.findUnique({
+  const template = await db.documentTemplate.findUnique({
     where: { id: target.templateId },
     select: { fields: true },
   })
   const field = templateFields(template?.fields).find((f) => f.key === input.fieldKey)
-  if (!field || !isInputField(field)) throw new AccessError('field-unknown')
+  if (!field) throw new AccessError('field-unknown')
 
   const existing = await db.caseSection.findUnique({
     where: { caseId_fieldKey: { caseId: target.id, fieldKey: input.fieldKey } },
   })
 
-  const required = Math.max(field.minClearance ?? 0, existing?.minClearance ?? 0)
-  if (!p.isAdmin && required > p.clearanceLevel) throw new AccessError('clearance-too-low')
-
-  const nextClearance = input.minClearance ?? existing?.minClearance ?? field.minClearance ?? 0
-  if (nextClearance > p.clearanceLevel && !p.isAdmin) throw new AccessError('clearance-too-low')
-
-  if ((existing?.currentVersion ?? 0) !== input.baseVersion) {
-    throw new ConflictError({
-      value: existing?.value ?? null,
-      version: existing?.currentVersion ?? 0,
-      updatedById: existing?.updatedById ?? null,
-    })
-  }
-
-  const nextVersion = (existing?.currentVersion ?? 0) + 1
+  const { nextClearance, nextVersion } = planSectionSave({
+    p,
+    field,
+    existing,
+    baseVersion: input.baseVersion,
+    minClearance: input.minClearance,
+  })
 
   await db.$transaction(async (tx) => {
     if (existing) {

web/lib/cases/service.ts

@@ -2,8 +2,9 @@ import { db } from '@/lib/db'
 import { writeAudit } from '@/lib/audit'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { canCreateCase, canEditCase, canReclassify } from '@/lib/access/caseWrite'
-import { nextCaseNumber } from '@/lib/cases/caseNumber'
+import { nextNumber } from '@/lib/numbering'
 import { findTransition, type CaseStatusName } from '@/lib/cases/lifecycle'
+import { AccessError, must } from '@/lib/errors'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 
 /**
@@ -14,16 +15,7 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  * und geben zurück. Die Regeln stehen an genau einer Stelle.
  */
 
-export class AccessError extends Error {
-  constructor(readonly code: string) {
-    super(code)
-    this.name = 'AccessError'
-  }
-}
-
-function must(check: { ok: boolean; reason?: string }): void {
-  if (!check.ok) throw new AccessError(check.reason ?? 'denied')
-}
+export { AccessError } from '@/lib/errors'
 
 /** Lädt eine Akte, sofern der Nutzer sie sehen darf. Sonst `null` — nie 403. */
 export async function loadVisibleCase(p: EffectivePermissions, caseNumber: string) {
@@ -53,7 +45,7 @@ export async function createCase(
 ): Promise<{ caseNumber: string; id: string }> {
   must(canCreateCase(p, input.classification))
 
-  const template = await db.caseTemplate.findFirst({
+  const template = await db.documentTemplate.findFirst({
     where: { key: input.templateKey, isActive: true },
     orderBy: { version: 'desc' },
     select: { id: true, key: true, numberPrefix: true, numberPadding: true },
@@ -62,7 +54,7 @@ export async function createCase(
 
   return db.$transaction(async (tx) => {
     // Das Muster kommt aus der Vorlage, jede Fallart hat ihren Nummernkreis.
-    const caseNumber = await nextCaseNumber(tx, {
+    const caseNumber = await nextNumber(tx, {
       prefix: template.numberPrefix,
       padding: template.numberPadding,
     })
@@ -263,7 +255,7 @@ export async function reclassify(
 
 /** Felder mit `requiredToClose`, die noch leer sind. Kommt mit Phase 3 zum Tragen. */
 async function missingRequiredSections(caseId: string, templateId: string): Promise<string[]> {
-  const template = await db.caseTemplate.findUnique({
+  const template = await db.documentTemplate.findUnique({
     where: { id: templateId },
     select: { fields: true },
   })

web/lib/cases/terms.ts

@@ -0,0 +1,34 @@
+/**
+ * Feste Wertelisten der Akte — Rollen der Beteiligten und Arten der
+ * Verknüpfung.
+ *
+ * **Ohne Abhängigkeiten.** Diese Datei wird auch im Client geladen, und die
+ * Dienstmodule daneben ziehen den Datenbankclient nach sich. Denselben Schnitt
+ * hat `lib/templates/fields.ts` gegenüber `schema.ts`, aus demselben Grund:
+ * das Bündelbudget aus docs/09-performance-und-ux.md.
+ *
+ * Die Übersetzungen stehen in `lib/i18n/de.ts`, nicht hier: diese Namen sind
+ * Datenbankwerte.
+ */
+
+export const PARTICIPANT_ROLES = [
+  'LEAD',
+  'INVESTIGATOR',
+  'WITNESS',
+  'SUBJECT',
+  'OBSERVER',
+] as const
+
+export type ParticipantRoleName = (typeof PARTICIPANT_ROLES)[number]
+
+export function isParticipantRole(value: string): value is ParticipantRoleName {
+  return (PARTICIPANT_ROLES as readonly string[]).includes(value)
+}
+
+export const LINK_KINDS = ['RELATED', 'SUCCESSOR', 'MERGED_INTO'] as const
+
+export type LinkKindName = (typeof LINK_KINDS)[number]
+
+export function isLinkKind(value: string): value is LinkKindName {
+  return (LINK_KINDS as readonly string[]).includes(value)
+}

web/lib/documents/service.ts

@@ -0,0 +1,452 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import {
+  canCreateDocument,
+  canEditDocument,
+  canFinalizeDocument,
+  canRetractDocument,
+  canWritePersonnel,
+} from '@/lib/access/documentWrite'
+import { canEditCase } from '@/lib/access/caseWrite'
+import { AccessError, must } from '@/lib/errors'
+import { nextNumber } from '@/lib/numbering'
+import { parseTemplateFields } from '@/lib/templates/schema'
+import { asJson, planSectionSave, renderSections, type RenderedSection } from '@/lib/sections/render'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import type { Prisma } from '@afis/db'
+
+/**
+ * Dokumente. Eine Ausfertigung aus einer Vorlage — Vorfallsbericht,
+ * Sonderarbeitsvertrag, Bußgeldbescheid — an einer Fallakte, an einer
+ * Personalakte oder für sich stehend.
+ *
+ * Eine neue Dokumentart braucht hier keine Zeile: sie ist eine Vorlage mit
+ * passendem `uses`. Siehe docs/13-entscheidungen.md.
+ */
+
+export type TemplateUse = 'CASE' | 'CASE_DOCUMENT' | 'PERSON_DOCUMENT' | 'STANDALONE'
+
+/** Wo soll das Dokument hängen? Genau eine der drei Formen. */
+export type Owner =
+  | { kind: 'case'; caseNumber: string }
+  | { kind: 'personnel'; personnelFileId: string }
+  | { kind: 'standalone' }
+
+const KOPFDATEN = {
+  id: true,
+  documentNumber: true,
+  title: true,
+  templateId: true,
+  templateKey: true,
+  templateVersion: true,
+  layout: true,
+  status: true,
+  classification: true,
+  caseId: true,
+  personnelFileId: true,
+  createdById: true,
+  createdAt: true,
+  updatedAt: true,
+  finalizedAt: true,
+  finalizedById: true,
+  retractedAt: true,
+  retractedById: true,
+  retractionReason: true,
+} satisfies Prisma.DocumentSelect
+
+/** Die aktiven Vorlagen, die an dieser Stelle verwendet werden dürfen. */
+export async function listTemplatesFor(use: TemplateUse) {
+  const rows = await db.documentTemplate.findMany({
+    where: { isActive: true, uses: { has: use } },
+    orderBy: [{ key: 'asc' }, { version: 'desc' }],
+    select: { id: true, key: true, version: true, name: true, description: true, layout: true },
+  })
+  // Nur die jeweils höchste Version je Schlüssel. Ältere Versionen bleiben
+  // bestehen, weil Dokumente sich ihre merken, aber neu angelegt wird stets
+  // mit der aktuellen.
+  const gesehen = new Set<string>()
+  return rows.filter((row) => (gesehen.has(row.key) ? false : (gesehen.add(row.key), true)))
+}
+
+export async function loadVisibleDocument(p: EffectivePermissions, documentNumber: string) {
+  return db.document.findFirst({
+    where: { AND: [visibleDocumentWhere(p), { documentNumber }] },
+    select: KOPFDATEN,
+  })
+}
+
+/**
+ * Die Dokumente eines Besitzers. Der Filter steckt in der Abfrage: ein
+ * Dokument über der Stufe des Lesers taucht weder auf noch in der Zählung.
+ */
+export async function listDocuments(
+  p: EffectivePermissions,
+  owner: { caseId: string } | { personnelFileId: string },
+) {
+  const wo: Prisma.DocumentWhereInput =
+    'caseId' in owner ? { caseId: owner.caseId } : { personnelFileId: owner.personnelFileId }
+
+  return db.document.findMany({
+    where: { AND: [visibleDocumentWhere(p), wo] },
+    orderBy: { createdAt: 'desc' },
+    take: 100,
+    select: KOPFDATEN,
+  })
+}
+
+/**
+ * Legt ein Dokument an.
+ *
+ * Reihenfolge der Prüfungen, jede einzeln nötig:
+ *  1. Die Vorlage muss an dieser Stelle erlaubt sein (`uses`).
+ *  2. Der Besitzer muss sichtbar **und** beschreibbar sein.
+ *  3. Der Nutzer braucht `document.create` und die Stufe.
+ */
+export async function createDocument(
+  p: EffectivePermissions,
+  input: { templateKey: string; title?: string; classification: number; owner: Owner },
+): Promise<{ documentNumber: string; id: string }> {
+  const use: TemplateUse =
+    input.owner.kind === 'case'
+      ? 'CASE_DOCUMENT'
+      : input.owner.kind === 'personnel'
+        ? 'PERSON_DOCUMENT'
+        : 'STANDALONE'
+
+  const template = await db.documentTemplate.findFirst({
+    where: { key: input.templateKey, isActive: true, uses: { has: use } },
+    orderBy: { version: 'desc' },
+    select: {
+      id: true,
+      key: true,
+      version: true,
+      name: true,
+      layout: true,
+      numberPrefix: true,
+      numberPadding: true,
+    },
+  })
+  if (!template) throw new AccessError('template-missing')
+
+  must(canCreateDocument(p, input.classification))
+
+  let caseId: string | null = null
+  let personnelFileId: string | null = null
+  let caseNumber: string | null = null
+
+  if (input.owner.kind === 'case') {
+    const akte = await db.case.findFirst({
+      where: { AND: [visibleCaseWhere(p), { caseNumber: input.owner.caseNumber }] },
+      select: { id: true, caseNumber: true, status: true, classification: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+    must(canEditCase(p, akte, 'entry.create'))
+    caseId = akte.id
+    caseNumber = akte.caseNumber
+  } else if (input.owner.kind === 'personnel') {
+    const akte = await db.personnelFile.findFirst({
+      where: { AND: [visiblePersonnelWhere(p), { id: input.owner.personnelFileId }] },
+      select: { id: true, classification: true },
+    })
+    if (!akte) throw new AccessError('not-found')
+    must(canWritePersonnel(p, akte.classification))
+    personnelFileId = akte.id
+  }
+
+  const titel = input.title?.trim() || template.name
+
+  return db.$transaction(async (tx) => {
+    const documentNumber = await nextNumber(tx, {
+      prefix: template.numberPrefix,
+      padding: template.numberPadding,
+    })
+
+    const created = await tx.document.create({
+      data: {
+        documentNumber,
+        title: titel,
+        templateId: template.id,
+        templateKey: template.key,
+        templateVersion: template.version,
+        // Kopie, kein Verweis: ein späterer Umbau der Vorlage darf das
+        // Aussehen eines ausgefertigten Dokuments nicht verändern.
+        layout: template.layout,
+        classification: input.classification,
+        caseId,
+        personnelFileId,
+        createdById: p.userId,
+      },
+      select: { id: true, documentNumber: true },
+    })
+
+    // Ein Dokument in einer Fallakte gehört in ihren Verlauf, sonst entsteht
+    // es unsichtbar neben der Chronologie.
+    if (caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${created.documentNumber} angelegt: ${titel}`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.create',
+      targetType: 'Document',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: created.documentNumber,
+        templateKey: template.key,
+        classification: input.classification,
+        caseNumber: caseNumber ?? undefined,
+        personnelFileId: personnelFileId ?? undefined,
+      },
+    })
+
+    return created
+  })
+}
+
+/** Die Abschnitte eines Dokuments, mit der Stufe des Lesers angewendet. */
+export async function loadDocumentSections(
+  p: EffectivePermissions,
+  document: { id: string; templateId: string },
+): Promise<RenderedSection[]> {
+  const [template, rows] = await Promise.all([
+    db.documentTemplate.findUnique({
+      where: { id: document.templateId },
+      select: { fields: true },
+    }),
+    db.documentSection.findMany({ where: { documentId: document.id } }),
+  ])
+
+  return renderSections(parseTemplateFields(template?.fields), rows, p)
+}
+
+export async function saveDocumentSection(
+  p: EffectivePermissions,
+  input: {
+    documentNumber: string
+    fieldKey: string
+    value: unknown
+    baseVersion: number
+    minClearance?: number
+  },
+): Promise<{ version: number }> {
+  const target = await loadVisibleDocument(p, input.documentNumber)
+  if (!target) throw new AccessError('not-found')
+
+  const check = canEditDocument(p, target)
+  if (!check.ok) throw new AccessError(check.reason)
+
+  const template = await db.documentTemplate.findUnique({
+    where: { id: target.templateId },
+    select: { fields: true },
+  })
+  const field = parseTemplateFields(template?.fields).find((f) => f.key === input.fieldKey)
+  if (!field) throw new AccessError('field-unknown')
+
+  const existing = await db.documentSection.findUnique({
+    where: { documentId_fieldKey: { documentId: target.id, fieldKey: input.fieldKey } },
+  })
+
+  const { nextClearance, nextVersion } = planSectionSave({
+    p,
+    field,
+    existing,
+    baseVersion: input.baseVersion,
+    minClearance: input.minClearance,
+  })
+
+  await db.$transaction(async (tx) => {
+    if (existing) {
+      await tx.documentSectionVersion.create({
+        data: {
+          sectionId: existing.id,
+          version: existing.currentVersion,
+          value: asJson(existing.value),
+          authorId: existing.updatedById,
+        },
+      })
+      await tx.documentSection.update({
+        where: { id: existing.id },
+        data: {
+          value: asJson(input.value),
+          currentVersion: nextVersion,
+          updatedById: p.userId,
+          minClearance: nextClearance,
+        },
+      })
+    } else {
+      await tx.documentSection.create({
+        data: {
+          documentId: target.id,
+          fieldKey: input.fieldKey,
+          value: asJson(input.value),
+          currentVersion: 1,
+          updatedById: p.userId,
+          minClearance: nextClearance,
+        },
+      })
+    }
+
+    // Sonst bliebe `updatedAt` des Dokuments auf dem Anlagezeitpunkt stehen.
+    await tx.document.update({ where: { id: target.id }, data: { updatedAt: new Date() } })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.update',
+      targetType: 'DocumentSection',
+      targetId: `${target.id}:${input.fieldKey}`,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: target.documentNumber,
+        fieldKey: input.fieldKey,
+        version: nextVersion,
+        minClearance: nextClearance,
+      },
+    })
+  })
+
+  return { version: nextVersion }
+}
+
+/**
+ * Ausfertigen. Aus dem Entwurf wird ein gültiges Dokument; wer es danach noch
+ * ändern will, braucht dasselbe Recht erneut.
+ */
+export async function finalizeDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canFinalizeDocument(p, target))
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({
+      where: { id: target.id },
+      data: { status: 'FINAL', finalizedAt: new Date(), finalizedById: p.userId },
+    })
+
+    if (target.caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId: target.caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${target.documentNumber} ausgefertigt`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.finalize',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { documentNumber: target.documentNumber },
+    })
+  })
+}
+
+/**
+ * Zurückziehen. Es gibt kein Löschen: das Dokument bleibt als Grabstein
+ * stehen, mit Datum, Person und Begründung. Siehe CLAUDE.md, harte Regel 2.
+ */
+export async function retractDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+  reason: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  must(canRetractDocument(p, target))
+
+  const begruendung = reason.trim()
+  if (begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({
+      where: { id: target.id },
+      data: {
+        status: 'RETRACTED',
+        retractedAt: new Date(),
+        retractedById: p.userId,
+        retractionReason: begruendung,
+      },
+    })
+
+    if (target.caseId) {
+      await tx.caseEntry.create({
+        data: {
+          id: crypto.randomUUID(),
+          caseId: target.caseId,
+          type: 'SYSTEM',
+          body: `Dokument ${target.documentNumber} zurückgezogen. Begründung: ${begruendung}`,
+          authorId: p.userId,
+          minClearance: 0,
+        },
+      })
+    }
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.retract',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { documentNumber: target.documentNumber, reason: begruendung },
+    })
+  })
+}
+
+/** Klassifizierung eines Dokuments ändern, mit denselben Regeln wie beim Fall. */
+export async function reclassifyDocument(
+  p: EffectivePermissions,
+  documentNumber: string,
+  to: number,
+  reason?: string,
+): Promise<void> {
+  const target = await loadVisibleDocument(p, documentNumber)
+  if (!target) throw new AccessError('not-found')
+  if (target.classification === to) return
+  if (to < 0 || to > 5) throw new AccessError('clearance-too-low')
+  if (to > p.clearanceLevel && !p.isAdmin) {
+    throw new AccessError('clearance-too-low')
+  }
+  must(canEditDocument(p, target))
+
+  const lowering = to < target.classification
+  const begruendung = reason?.trim() ?? ''
+  if (lowering && begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.document.update({ where: { id: target.id }, data: { classification: to } })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'document.reclassify',
+      targetType: 'Document',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        documentNumber: target.documentNumber,
+        from: target.classification,
+        to,
+        lowering,
+        reason: begruendung || undefined,
+      },
+    })
+  })
+}

web/lib/errors.ts

@@ -0,0 +1,30 @@
+/**
+ * Fehler, die bis in die Oberfläche durchgereicht werden.
+ *
+ * `code` ist ein Schlüssel in `de.actionErrors`, kein Text: die Meldung wird
+ * erst am Rand übersetzt. Ein Fehler, den der Nutzer nicht sehen darf, kommt
+ * gar nicht erst hier an — fehlender Zugriff endet in 404, nicht in 403.
+ */
+export class AccessError extends Error {
+  constructor(readonly code: string) {
+    super(code)
+    this.name = 'AccessError'
+  }
+}
+
+/**
+ * Kein stilles Überschreiben: die fremde Fassung kommt mit zurück, damit der
+ * Nutzer beide sieht und entscheidet. Siehe docs/05-akten-und-vorlagen.md.
+ */
+export class ConflictError extends Error {
+  constructor(
+    readonly current: { value: unknown; version: number; updatedById: string | null },
+  ) {
+    super('conflict')
+    this.name = 'ConflictError'
+  }
+}
+
+export function must(check: { ok: boolean; reason?: string }): void {
+  if (!check.ok) throw new AccessError(check.reason ?? 'denied')
+}

web/lib/i18n/de.ts

@@ -155,18 +155,6 @@ export const de = {
     entryPlaceholder: 'Was ist passiert?',
     saving: 'Wird gespeichert',
     unsaved: 'Nicht gespeichert',
-    errors: {
-      'not-found': 'Die Akte gibt es nicht, oder du darfst sie nicht sehen.',
-      'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
-      'no-permission': 'Dir fehlt das nötige Recht.',
-      'read-only': 'Die Akte ist schreibgeschützt.',
-      closed: 'Die Akte ist abgeschlossen. Änderungen brauchen ein eigenes Recht.',
-      'reason-required': 'Begründung nötig, mindestens 10 Zeichen.',
-      'transition-invalid': 'Dieser Statuswechsel ist nicht vorgesehen.',
-      'sections-incomplete': 'Es fehlen Pflichtangaben für den Abschluss.',
-      'template-missing': 'Für diese Fallart gibt es keine Vorlage.',
-      default: 'Nicht gespeichert. Erneut versuchen.',
-    } as Record<string, string>,
     statusNames: {
       DRAFT: 'Entwurf',
       OPEN: 'Offen',
@@ -237,10 +225,104 @@ export const de = {
   personnel: {
     one: 'Personalakte',
     many: 'Personalakten',
+    listHeading: 'Personalakten',
+    name: 'Name',
     serviceNumber: 'Dienstnummer',
     rank: 'Dienstgrad',
     department: 'Abteilung',
+    status: 'Status',
+    note: 'Anmerkung',
+    noteHelp: 'Steht im Kopf der Akte, etwa "kein Discord-Konto, Aktenlage aus 2025".',
+    linkedAccount: 'Discord-Konto',
+    noAccount: 'Ohne Discord-Konto',
     empty: 'Noch keine Personalakte. Erste Personalakte anlegen.',
+    emptySearch: 'Kein Treffer. Anderen Begriff versuchen.',
+    create: 'Personalakte anlegen',
+    createTitle: 'Neue Personalakte',
+    createHint:
+      'Auch für Personen ohne Discord-Konto: Zeugen, ehemalige Mitarbeiter, Aktenlage von außen.',
+    search: 'Name, Dienstnummer oder Dienstgrad',
+    countLabel: (n: number) => (n === 1 ? '1 Personalakte' : `${n} Personalakten`),
+    edit: 'Kopfdaten ändern',
+    reclassify: 'Klassifizierung ändern',
+    headData: 'Kopfdaten',
+    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`),
+  },
+
+  participant: {
+    heading: 'Beteiligte',
+    empty: 'Noch niemand eingetragen.',
+    add: 'Beteiligte eintragen',
+    remove: 'Entfernen',
+    role: 'Rolle',
+    person: 'Person',
+    pickUser: 'Mitglied',
+    pickPersonnel: 'Personalakte',
+    hint:
+      'Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen.',
+    roles: {
+      LEAD: 'Ermittlungsführung',
+      INVESTIGATOR: 'Ermittler',
+      WITNESS: 'Zeuge',
+      SUBJECT: 'Betroffener',
+      OBSERVER: 'Beobachter',
+    } as Record<string, string>,
+  },
+
+  link: {
+    heading: 'Verknüpfungen',
+    empty: 'Keine Verknüpfung.',
+    add: 'Akte verknüpfen',
+    remove: 'Verknüpfung lösen',
+    target: 'Aktenzeichen',
+    kind: 'Art',
+    kinds: {
+      RELATED: 'Verwandt',
+      SUCCESSOR: 'Nachfolger',
+      MERGED_INTO: 'Zusammengeführt in',
+    } as Record<string, string>,
+    incoming: {
+      RELATED: 'Verwandt',
+      SUCCESSOR: 'Vorgänger',
+      MERGED_INTO: 'Zusammengeführt aus',
+    } as Record<string, string>,
+  },
+
+  document: {
+    one: 'Dokument',
+    many: 'Dokumente',
+    number: 'Dokumentnummer',
+    title: 'Titel',
+    kind: 'Dokumentart',
+    heading: 'Dokumente',
+    empty: 'Noch kein Dokument.',
+    create: 'Dokument anlegen',
+    createTitle: 'Neues Dokument',
+    createHint: 'Die Vorlage bestimmt Aufbau und Aussehen. Der Titel lässt sich später ändern.',
+    open: 'Öffnen',
+    finalize: 'Ausfertigen',
+    finalizeHint: 'Danach sind Änderungen nur noch mit eigenem Recht möglich.',
+    retract: 'Zurückziehen',
+    retractReason: 'Begründung der Zurücknahme',
+    reclassify: 'Klassifizierung ändern',
+    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}`,
+    ownerCase: 'Zur Fallakte',
+    ownerPersonnel: 'Zur Personalakte',
+    ownerNone: 'Ohne Besitzer',
+    statusNames: {
+      DRAFT: 'Entwurf',
+      FINAL: 'Ausgefertigt',
+      RETRACTED: 'Zurückgezogen',
+    } as Record<string, string>,
+    layoutNames: {
+      FORM: 'Formular',
+      PROSE: 'Vertragstext',
+      NOTE: 'Vermerk',
+    } as Record<string, string>,
   },
 
   common: {
@@ -253,6 +335,28 @@ export const de = {
     unknown: 'Unbekannt',
   },
 
+  /**
+   * Meldungen zu abgelehnten Aktionen. Der Schlüssel ist der `code` eines
+   * `AccessError`, siehe lib/errors.ts. Gilt für Fallakten, Personalakten und
+   * Dokumente gleichermaßen — die Regeln sind dieselben.
+   */
+  actionErrors: {
+    'not-found': 'Die Akte gibt es nicht, oder du darfst sie nicht sehen.',
+    'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
+    'no-permission': 'Dir fehlt das nötige Recht.',
+    'read-only': 'Der Datensatz ist schreibgeschützt.',
+    closed: 'Der Vorgang ist abgeschlossen. Änderungen brauchen ein eigenes Recht.',
+    'reason-required': 'Begründung nötig, mindestens 10 Zeichen.',
+    'transition-invalid': 'Dieser Statuswechsel ist nicht vorgesehen.',
+    'sections-incomplete': 'Es fehlen Pflichtangaben für den Abschluss.',
+    'template-missing': 'Dafür gibt es keine Vorlage.',
+    'field-unknown': 'Dieses Feld gehört nicht zur Vorlage.',
+    'name-required': 'Ein Name mit mindestens zwei Zeichen ist nötig.',
+    'participant-target': 'Entweder ein Discord-Konto oder eine Personalakte, nicht beides.',
+    'link-self': 'Eine Akte lässt sich nicht mit sich selbst verknüpfen.',
+    default: 'Nicht gespeichert. Erneut versuchen.',
+  } as Record<string, string>,
+
   errors: {
     notFound: {
       title: 'Nicht gefunden',

web/lib/numbering.ts

@@ -1,15 +1,21 @@
 import type { Prisma } from '@afis/db'
 
 /**
- * Aktenzeichen. Das Muster gehört zur Vorlage, nicht ins Programm: die
- * Abteilung führt gewachsene Präfixe wie `AKT-PA-2026-62843` neben dem
- * `AfiS-2026-0042` aus dem Glossar. Siehe docs/13-entscheidungen.md.
+ * Geschäftsnummern: Aktenzeichen und Dokumentnummern.
+ *
+ * Das Muster gehört zur Vorlage, nicht ins Programm: die Abteilung führt
+ * gewachsene Präfixe wie `AKT-PA-2026-62843` neben dem `AfiS-2026-0042` aus
+ * dem Glossar. Siehe docs/13-entscheidungen.md.
+ *
+ * Fallakten und Dokumente teilen sich denselben Zähler. Sie kollidieren nicht,
+ * weil das Präfix Teil des Schlüssels ist: eine Fallart und eine Dokumentart
+ * mit demselben Präfix laufen bewusst in einem Nummernkreis.
  */
 export type NumberPattern = { prefix: string; padding: number }
 
 export const DEFAULT_PATTERN: NumberPattern = { prefix: 'AfiS', padding: 4 }
 
-export function formatCaseNumber(
+export function formatNumber(
   year: number,
   number: number,
   pattern: NumberPattern = DEFAULT_PATTERN,
@@ -24,7 +30,7 @@ export function formatCaseNumber(
  */
 const PATTERN = /^([A-Za-z][A-Za-z0-9-]*)-(\d{4})-(\d+)$/
 
-export function parseCaseNumber(
+export function parseNumber(
   value: string,
 ): { prefix: string; year: number; number: number } | null {
   const match = PATTERN.exec(value.trim())
@@ -36,30 +42,30 @@ export function parseCaseNumber(
 export const CASE_NUMBER_GLOBAL = /\b[A-Za-z][A-Za-z0-9-]*-\d{4}-\d{3,8}\b/g
 
 /**
- * Vergibt das nächste Aktenzeichen im Nummernkreis dieses Präfixes und Jahres.
+ * Vergibt die nächste Nummer im Nummernkreis dieses Präfixes und Jahres.
  *
  * `INSERT … ON CONFLICT DO UPDATE` sperrt die Zeile für die Dauer der
  * Transaktion. Zwei gleichzeitige Anlagen warten dadurch aufeinander, statt
  * dieselbe Nummer zu ziehen. Läuft in **derselben** Transaktion wie das
  * Anlegen des Falls, siehe docs/04-datenmodell.md.
  */
-export async function nextCaseNumber(
+export async function nextNumber(
   tx: Prisma.TransactionClient,
   pattern: NumberPattern = DEFAULT_PATTERN,
   year = new Date().getFullYear(),
 ): Promise<string> {
   const rows = await tx.$queryRaw<{ lastNumber: number }[]>`
-    INSERT INTO "CaseCounter" ("prefix", "year", "lastNumber")
+    INSERT INTO "NumberSeries" ("prefix", "year", "lastNumber")
     VALUES (${pattern.prefix}, ${year}, 1)
     ON CONFLICT ("prefix", "year") DO UPDATE
-      SET "lastNumber" = "CaseCounter"."lastNumber" + 1
+      SET "lastNumber" = "NumberSeries"."lastNumber" + 1
     RETURNING "lastNumber"
   `
 
   const lastNumber = rows[0]?.lastNumber
   if (lastNumber === undefined) {
-    throw new Error('Aktenzeichen konnte nicht vergeben werden')
+    throw new Error('Nummer konnte nicht vergeben werden')
   }
 
-  return formatCaseNumber(year, lastNumber, pattern)
+  return formatNumber(year, lastNumber, pattern)
 }

web/lib/personnel/service.ts

@@ -0,0 +1,267 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+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 { EffectivePermissions } from '@/lib/auth/permissions'
+import type { Prisma } from '@afis/db'
+
+/**
+ * Personalakten. Eine Akte zu einer Person, auch zu einer **ohne
+ * Discord-Konto**: Zeugen, ehemalige Mitarbeiter und Personen, über die
+ * lediglich Aktenlage besteht, brauchen einen Platz.
+ *
+ * Die Rückverweise sind der heikelste Teil. Siehe `loadBacklinks`.
+ */
+
+const KOPFDATEN = {
+  id: true,
+  userId: true,
+  displayName: true,
+  serviceNumber: true,
+  rank: true,
+  department: true,
+  status: true,
+  note: true,
+  classification: true,
+  createdById: true,
+  createdAt: true,
+  updatedAt: true,
+} satisfies Prisma.PersonnelFileSelect
+
+export async function loadVisiblePersonnelFile(p: EffectivePermissions, id: string) {
+  return db.personnelFile.findFirst({
+    where: { AND: [visiblePersonnelWhere(p), { id }] },
+    select: KOPFDATEN,
+  })
+}
+
+/**
+ * Liste der Personalakten. Suchbegriff und Zählung laufen durch dieselbe
+ * Abfrage wie die Sichtbarkeit, damit sich aus einer Trefferzahl nichts über
+ * verborgene Akten ableiten lässt.
+ */
+export async function listPersonnelFiles(
+  p: EffectivePermissions,
+  options: { query?: string; take?: number } = {},
+) {
+  const begriff = options.query?.trim()
+  const where: Prisma.PersonnelFileWhereInput = {
+    AND: [
+      visiblePersonnelWhere(p),
+      ...(begriff
+        ? [
+            {
+              OR: [
+                { displayName: { contains: begriff, mode: 'insensitive' as const } },
+                { serviceNumber: { contains: begriff, mode: 'insensitive' as const } },
+                { rank: { contains: begriff, mode: 'insensitive' as const } },
+              ],
+            },
+          ]
+        : []),
+    ],
+  }
+
+  const [files, total] = await Promise.all([
+    db.personnelFile.findMany({
+      where,
+      orderBy: [{ displayName: 'asc' }],
+      take: options.take ?? 50,
+      select: KOPFDATEN,
+    }),
+    db.personnelFile.count({ where }),
+  ])
+
+  return { files, total }
+}
+
+export async function createPersonnelFile(
+  p: EffectivePermissions,
+  input: {
+    displayName: string
+    userId?: string | null
+    serviceNumber?: string | null
+    rank?: string | null
+    department?: string | null
+    status?: string | null
+    note?: string | null
+    classification: number
+  },
+): Promise<{ id: string }> {
+  must(canWritePersonnel(p, input.classification))
+
+  const name = input.displayName.trim()
+  if (name.length < 2) throw new AccessError('name-required')
+
+  return db.$transaction(async (tx) => {
+    const created = await tx.personnelFile.create({
+      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,
+        note: input.note?.trim() || null,
+        classification: input.classification,
+        createdById: p.userId,
+      },
+      select: { id: true },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.create',
+      targetType: 'PersonnelFile',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { displayName: name, classification: input.classification },
+    })
+
+    return created
+  })
+}
+
+/** Kopfdaten ändern. Die Klassifizierung läuft über `reclassifyPersonnelFile`. */
+export async function updatePersonnelFile(
+  p: EffectivePermissions,
+  id: string,
+  input: {
+    displayName?: string
+    serviceNumber?: string | null
+    rank?: string | null
+    department?: string | null
+    status?: string | null
+    note?: string | null
+  },
+): Promise<void> {
+  const target = await loadVisiblePersonnelFile(p, id)
+  if (!target) throw new AccessError('not-found')
+  must(canWritePersonnel(p, target.classification))
+
+  const name = input.displayName?.trim()
+  if (name !== undefined && name.length < 2) throw new AccessError('name-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.personnelFile.update({
+      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.note !== undefined ? { note: input.note?.trim() || null } : {}),
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.update',
+      targetType: 'PersonnelFile',
+      targetId: id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { fields: Object.keys(input) },
+    })
+  })
+}
+
+/**
+ * Klassifizierung ändern. Wie bei der Fallakte ist die Herabstufung der
+ * heiklere Fall: sie macht die Akte für Leute sichtbar, die sie vorher nicht
+ * sehen durften. Sie braucht eine Begründung und steht im Protokoll.
+ */
+export async function reclassifyPersonnelFile(
+  p: EffectivePermissions,
+  id: string,
+  to: number,
+  reason?: string,
+): Promise<void> {
+  const target = await loadVisiblePersonnelFile(p, id)
+  if (!target) throw new AccessError('not-found')
+  if (target.classification === to) return
+  if (to < 0 || to > 5) throw new AccessError('clearance-too-low')
+  must(canWritePersonnel(p, Math.max(to, target.classification)))
+
+  const lowering = to < target.classification
+  const begruendung = reason?.trim() ?? ''
+  if (lowering && begruendung.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.personnelFile.update({ where: { id }, data: { classification: to } })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'personnel.reclassify',
+      targetType: 'PersonnelFile',
+      targetId: id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        from: target.classification,
+        to,
+        lowering,
+        reason: begruendung || undefined,
+      },
+    })
+  })
+}
+
+/**
+ * Rückverweise: die Fälle, in denen diese Person vorkommt, nach Rolle getrennt.
+ *
+ * **Diese Liste läuft durch dieselbe Sichtbarkeitsprüfung wie die Fallliste.**
+ * Das ist der häufigste Ort, an dem ein Aktensystem leckt: eine Personalakte
+ * der Stufe 1, auf der „3 Fälle" steht, verrät die Existenz von Ermittlungen,
+ * die der Leser nicht sehen darf. Deshalb steckt der Filter in der Abfrage und
+ * die Zählung entsteht aus dem gefilterten Ergebnis — nie aus einem eigenen
+ * `count` ohne Filter. Siehe docs/05-akten-und-vorlagen.md, Rückverweise.
+ */
+export async function loadBacklinks(
+  p: EffectivePermissions,
+  file: { id: string; userId: string | null },
+) {
+  const wenDieAkteMeint: Prisma.CaseParticipantWhereInput[] = [{ personnelFileId: file.id }]
+  // Dieselbe Person kann über ihre Personalakte oder über ihr Discord-Konto
+  // eingetragen sein. Beides zählt, sonst fehlen Fälle.
+  if (file.userId) wenDieAkteMeint.push({ userId: file.userId })
+
+  const rows = await db.caseParticipant.findMany({
+    where: {
+      AND: [{ OR: wenDieAkteMeint }, { case: { is: visibleCaseWhere(p) } }],
+    },
+    select: {
+      role: true,
+      case: {
+        select: {
+          id: true,
+          caseNumber: true,
+          title: true,
+          status: true,
+          classification: true,
+          updatedAt: true,
+        },
+      },
+    },
+    orderBy: { createdAt: 'desc' },
+    take: 200,
+  })
+
+  // Eine Person kann in einem Fall mehrere Rollen haben; jede Rolle bekommt
+  // ihren Eintrag, der Fall steht dann in beiden Gruppen.
+  const nachRolle = new Map<string, typeof rows>()
+  for (const row of rows) {
+    const gruppe = nachRolle.get(row.role) ?? []
+    gruppe.push(row)
+    nachRolle.set(row.role, gruppe)
+  }
+
+  return {
+    total: rows.length,
+    byRole: [...nachRolle.entries()].map(([role, eintraege]) => ({ role, eintraege })),
+  }
+}

web/lib/sections/render.ts

@@ -0,0 +1,123 @@
+import { isInputField, type TemplateField } from '@/lib/templates/fields'
+import { redactForLevel, type Segment } from '@/lib/redaction'
+import { AccessError, ConflictError } from '@/lib/errors'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import type { Prisma } from '@afis/db'
+
+/**
+ * Abschnitte: der ausgefüllte Inhalt einer Vorlage.
+ *
+ * Eine Fallakte trägt sie direkt, ein Dokument ebenso. Die Regeln sind
+ * dieselben, deshalb stehen sie hier einmal und nicht zweimal: welche Stufe
+ * ein Feld verlangt, was ein zu niedrig eingestufter Leser bekommt, und wann
+ * ein Speichern ein Konflikt ist.
+ */
+
+/** Was ein Leser sieht, dessen Stufe für ein Feld nicht reicht. */
+export type Placeholder = { redacted: true; requiredLevel: number }
+
+/** Die Spalten, die `CaseSection` und `DocumentSection` gemeinsam haben. */
+export type SectionRow = {
+  fieldKey: string
+  value: unknown
+  minClearance: number
+  currentVersion: number
+  updatedAt: Date
+  updatedById: string | null
+}
+
+export type RenderedSection = {
+  fieldKey: string
+  field: TemplateField
+  version: number
+  updatedAt: Date | null
+  updatedById: string | null
+} & (
+  | { visible: true; value: unknown; segments: Segment[] | null }
+  | { visible: false; value: Placeholder }
+)
+
+/**
+ * Prisma trennt „Feld nicht setzen" von „JSON null". Ein leerer Abschnitt ist
+ * inhaltlich JSON null, nicht das Fehlen des Feldes.
+ */
+export function asJson(value: unknown): Prisma.InputJsonValue {
+  return (value ?? null) as Prisma.InputJsonValue
+}
+
+/**
+ * Wendet die Stufe des Lesers auf die Abschnitte an.
+ *
+ * Felder über seiner Stufe werden **hier**, also serverseitig, durch einen
+ * Platzhalter ersetzt. Der echte Wert verlässt den Server nicht — nie im
+ * Client ausblenden. Dasselbe gilt für Schwärzungen im Fließtext, die als
+ * Segmente zurückkommen.
+ */
+export function renderSections(
+  fields: TemplateField[],
+  rows: SectionRow[],
+  p: EffectivePermissions,
+): RenderedSection[] {
+  const byKey = new Map(rows.map((row) => [row.fieldKey, row]))
+
+  return fields.map((field): RenderedSection => {
+    const row = byKey.get(field.key)
+    const required = Math.max(field.minClearance ?? 0, row?.minClearance ?? 0)
+    const common = {
+      fieldKey: field.key,
+      field,
+      version: row?.currentVersion ?? 0,
+      updatedAt: row?.updatedAt ?? null,
+      updatedById: row?.updatedById ?? null,
+    }
+
+    if (!p.isAdmin && required > p.clearanceLevel) {
+      return { ...common, visible: false, value: { redacted: true, requiredLevel: required } }
+    }
+
+    const value = row?.value ?? null
+    const segments =
+      isInputField(field) && field.type === 'longtext' && typeof value === 'string'
+        ? redactForLevel(value, p.clearanceLevel)
+        : null
+
+    return { ...common, visible: true, value, segments }
+  })
+}
+
+/**
+ * Prüft ein Speichern, bevor es geschrieben wird, und liefert die neue
+ * Feldstufe und Versionsnummer.
+ *
+ * Wirft `AccessError`, wenn die Stufe nicht reicht, und `ConflictError`, wenn
+ * der Abschnitt sich seit dem Laden verändert hat. Beides gilt für Fallakten
+ * und Dokumente gleichermaßen.
+ */
+export function planSectionSave(input: {
+  p: EffectivePermissions
+  field: TemplateField
+  existing: Pick<SectionRow, 'minClearance' | 'currentVersion' | 'value' | 'updatedById'> | null
+  baseVersion: number
+  minClearance?: number
+}): { nextClearance: number; nextVersion: number } {
+  const { p, field, existing } = input
+
+  if (!isInputField(field)) throw new AccessError('field-unknown')
+
+  // Wer ein Feld nicht lesen darf, darf es auch nicht überschreiben.
+  const required = Math.max(field.minClearance ?? 0, existing?.minClearance ?? 0)
+  if (!p.isAdmin && required > p.clearanceLevel) throw new AccessError('clearance-too-low')
+
+  const nextClearance = input.minClearance ?? existing?.minClearance ?? field.minClearance ?? 0
+  if (nextClearance > p.clearanceLevel && !p.isAdmin) throw new AccessError('clearance-too-low')
+
+  if ((existing?.currentVersion ?? 0) !== input.baseVersion) {
+    throw new ConflictError({
+      value: existing?.value ?? null,
+      version: existing?.currentVersion ?? 0,
+      updatedById: existing?.updatedById ?? null,
+    })
+  }
+
+  return { nextClearance, nextVersion: (existing?.currentVersion ?? 0) + 1 }
+}