Abteilungen als Ebene über der Personalakte

Punkt 3 der Wünsche.

Die Abteilung stand als Freitext in der Personalakte. Damit liess sich nichts
fragen: „SHD", „Shd" und „Sicherheitsdienst" waren drei Abteilungen. Sie ist
jetzt ein eigenes Modell, im Adminbereich verwaltbar, und die drei vorhandenen
Freitexte sind in der Migration zu Abteilungen geworden.

**Eine Fallakte trägt keine Abteilung.** Sie gehört zu einer, wenn eine
beteiligte Person ihr angehört — abgeleitet über CaseParticipant und die
Personalakte. Eine eingetragene Zuordnung wäre nach zwei Wochen falsch: Leute
wechseln, Beteiligte kommen dazu, und niemand pflegt das nach. Dasselbe gilt
für die Dokumente: ein Dokument unmittelbar an der Abteilung wäre halb
verdrahtet, weil die Vorlagen über TemplateUse nur Fall- und Personalakte
kennen.

Die Abteilungsseite zeigt Mitglieder, abgeleitete Fälle und Dokumente,
Vermerke, Chat und ein Kreisdiagramm der Fallarten; die Übersicht eines über
alle Abteilungen. Das Diagramm ist serverseitig gerendertes SVG — eine
Bibliothek wäre das Teuerste auf der Seite gewesen. Die Segmente sind
Abstufungen von --steel und nicht die Stufenfarben: ein Tortenstück in Oxidrot
würde als „streng geheim" gelesen.

Die Zusammenfassung ist die gefährliche Stelle. Eine Abteilungsseite fasst
zusammen, was einzeln längst geschützt ist, und eine Zusammenfassung, die nicht
filtert, verrät mehr als jede Einzelansicht. Deshalb läuft hier jede Liste und
jede Zahl durch dieselben Fragmente wie überall; ein Test prüft, dass die Summe
der Diagrammanteile mit der Länge der Liste übereinstimmt. Wo jemand
Personalakten gar nicht sehen darf, steht null und keine Null.

Vermerke erben Regel 2 unverändert: kein DELETE, Version bei jeder Änderung,
Grabstein bei jeder Zurücknahme, als Regel und Trigger in der Datenbank. Ohne
Korrekturkette, Anhänge und Karenzzeit — was Beweiswert hat, gehört in eine
Fallakte.

Nebenbei: das Zugriffsprotokoll hängt jetzt am dafür vorgesehenen Recht
audit.read statt an admin.

packages/db/prisma/migrations/20260904100000_abteilungen/migration.sql

@@ -0,0 +1,256 @@
+-- Abteilungen: die Ebene über der Personalakte.
+--
+-- Bisher stand die Abteilung als Freitext in der Personalakte. Damit liess sich
+-- niemand fragen, was es zu einer Abteilung insgesamt gibt — jede Schreibweise
+-- war eine eigene Abteilung. Als eigenes Modell ist sie verwaltbar, und die
+-- Zuordnung einer Fallakte ergibt sich aus ihren Beteiligten und deren
+-- Personalakten. Eine Fallakte trägt deshalb **keine** Abteilung: die
+-- Zuordnung soll aktuell bleiben, wenn sich die Beteiligten ändern.
+
+CREATE TABLE "Department" (
+    "id"           TEXT         NOT NULL,
+    "key"          TEXT         NOT NULL,
+    "name"         TEXT         NOT NULL,
+    "description"  TEXT,
+    "minClearance" INTEGER      NOT NULL DEFAULT 0,
+    "isArchived"   BOOLEAN      NOT NULL DEFAULT false,
+    "createdById"  TEXT,
+    "createdAt"    TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt"    TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "Department_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX "Department_key_key" ON "Department"("key");
+CREATE INDEX "Department_isArchived_name_idx" ON "Department"("isArchived", "name");
+
+-- Die Personalakte zeigt jetzt auf die Abteilung.
+ALTER TABLE "PersonnelFile" ADD COLUMN "departmentId" TEXT;
+
+-- Was schon als Freitext dastand, wird zur Abteilung. Der Schlüssel ist der
+-- getrimmte Text in Grossbuchstaben, der Name der Text selbst — beides lässt
+-- sich im Adminbereich nachziehen.
+INSERT INTO "Department" ("id", "key", "name", "updatedAt")
+SELECT gen_random_uuid()::text,
+       upper(btrim("department")),
+       btrim("department"),
+       CURRENT_TIMESTAMP
+  FROM (SELECT DISTINCT "department" FROM "PersonnelFile"
+         WHERE "department" IS NOT NULL AND btrim("department") <> '') AS vorhanden;
+
+UPDATE "PersonnelFile" p
+   SET "departmentId" = d."id"
+  FROM "Department" d
+ WHERE p."department" IS NOT NULL
+   AND upper(btrim(p."department")) = d."key";
+
+-- Zwei Suchauslöser hängen am Freitextfeld und müssen vorher weg. Sie kommen
+-- gleich darunter wieder, dann über die Beziehung: gesucht wird nach dem Namen
+-- der Abteilung, nicht mehr nach der Schreibweise in der Akte.
+DROP TRIGGER IF EXISTS personnel_search_trg ON "PersonnelFile";
+DROP TRIGGER IF EXISTS search_on_personnel ON "PersonnelFile";
+
+ALTER TABLE "PersonnelFile" DROP COLUMN "department";
+
+CREATE OR REPLACE FUNCTION personnel_refresh_search_vector() RETURNS trigger AS $$
+DECLARE
+  abteilung text := '';
+BEGIN
+  IF NEW."departmentId" IS NOT NULL THEN
+    SELECT coalesce(d."name", '') || ' ' || coalesce(d."key", '')
+      INTO abteilung FROM "Department" d WHERE d."id" = NEW."departmentId";
+  END IF;
+
+  NEW."searchVector" :=
+    setweight(to_tsvector('german', coalesce(NEW."displayName", '')), 'A')
+    ||
+    setweight(to_tsvector('german',
+      coalesce(NEW."rank", '') || ' ' || coalesce(abteilung, '') || ' ' ||
+      coalesce(array_to_string(NEW."statusTags", ' '), '')), 'B');
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER personnel_search_trg
+  BEFORE INSERT OR UPDATE OF "displayName", "rank", "departmentId", "statusTags"
+  ON "PersonnelFile"
+  FOR EACH ROW EXECUTE FUNCTION personnel_refresh_search_vector();
+
+CREATE OR REPLACE FUNCTION refresh_personnel_search(target_id text) RETURNS void AS $$
+DECLARE
+  stufe int;
+  vec tsvector;
+BEGIN
+  DELETE FROM "SearchIndex" WHERE "targetType" = 'personnel' AND "targetId" = target_id;
+
+  SELECT setweight(to_tsvector('german', p."displayName"), 'A')
+      || setweight(to_tsvector('german',
+           coalesce(p."rank", '') || ' ' ||
+           coalesce(d."name", '') || ' ' || coalesce(d."key", '') || ' ' ||
+           coalesce(array_to_string(p."statusTags", ' '), '')), 'B')
+      || setweight(to_tsvector('german', coalesce(p."note", '')), 'C')
+    INTO vec
+    FROM "PersonnelFile" p
+    LEFT JOIN "Department" d ON d."id" = p."departmentId"
+   WHERE p."id" = target_id;
+
+  IF vec IS NULL THEN
+    RETURN;
+  END IF;
+
+  FOR stufe IN 0..5 LOOP
+    INSERT INTO "SearchIndex" ("targetType", "targetId", "minClearance", "vector")
+    VALUES ('personnel', target_id, stufe, vec);
+  END LOOP;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER search_on_personnel
+  AFTER INSERT OR UPDATE OF "displayName", "rank", "departmentId", "statusTags", "note"
+  ON "PersonnelFile"
+  FOR EACH ROW EXECUTE FUNCTION search_index_trigger();
+
+-- Bestehende Zeilen einmal nachziehen, sonst tragen sie den alten Vektor und
+-- die Suche findet die Abteilung nicht.
+UPDATE "PersonnelFile" SET "displayName" = "displayName";
+
+ALTER TABLE "PersonnelFile"
+    ADD CONSTRAINT "PersonnelFile_departmentId_fkey"
+    FOREIGN KEY ("departmentId") REFERENCES "Department"("id")
+    ON DELETE SET NULL ON UPDATE CASCADE;
+
+CREATE INDEX "PersonnelFile_departmentId_idx" ON "PersonnelFile"("departmentId");
+
+-- Ein Dokument hängt weiterhin an einer Fall- oder Personalakte. Eine
+-- Abteilung als dritter Besitzer wäre eine halbe Sache: die Vorlagen kennen
+-- über TemplateUse nur die beiden Orte, und ein Feld, das nichts füllen kann,
+-- ist schlimmer als keins. Was zu einer Abteilung an Dokumenten gehört, wird
+-- wie alles andere abgeleitet — über ihre Mitglieder und deren Fälle.
+
+-- Der Chat bekommt einen dritten Ort. Der CHECK aus der vorigen Migration wird
+-- entsprechend erweitert: genau einer, weiterhin.
+ALTER TABLE "ChatMessage" ADD COLUMN "departmentId" TEXT;
+ALTER TABLE "ChatMessage"
+    ADD CONSTRAINT "ChatMessage_departmentId_fkey"
+    FOREIGN KEY ("departmentId") REFERENCES "Department"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+CREATE INDEX "ChatMessage_departmentId_createdAt_idx"
+    ON "ChatMessage"("departmentId", "createdAt" DESC);
+
+ALTER TABLE "ChatMessage" DROP CONSTRAINT "ChatMessage_genau_ein_ort";
+ALTER TABLE "ChatMessage"
+    ADD CONSTRAINT "ChatMessage_genau_ein_ort"
+    CHECK (num_nonnulls("caseId", "personnelFileId", "departmentId") = 1);
+
+CREATE OR REPLACE FUNCTION chat_immutable_guard() RETURNS trigger AS $$
+BEGIN
+  IF NEW."authorId"        IS DISTINCT FROM OLD."authorId"
+  OR NEW."createdAt"       IS DISTINCT FROM OLD."createdAt"
+  OR NEW."caseId"          IS DISTINCT FROM OLD."caseId"
+  OR NEW."personnelFileId" IS DISTINCT FROM OLD."personnelFileId"
+  OR NEW."departmentId"    IS DISTINCT FROM OLD."departmentId" THEN
+    RAISE EXCEPTION 'authorId, createdAt und der Ort einer ChatMessage sind unveränderlich';
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- ===========================================================================
+-- Vermerke an einer Abteilung.
+--
+-- Dieselben Zusicherungen wie beim Verlauf einer Akte (harte Regel 2): kein
+-- DELETE, jede Änderung erzeugt eine Version, jede Zurücknahme lässt einen
+-- Grabstein stehen. Die Regeln stehen in der Datenbank und nicht nur in der
+-- Anwendung — die Anwendung kann man umgehen.
+-- ===========================================================================
+
+CREATE TABLE "DepartmentEntry" (
+    "id"               TEXT         NOT NULL,
+    "departmentId"     TEXT         NOT NULL,
+    "body"             TEXT         NOT NULL,
+    "minClearance"     INTEGER      NOT NULL DEFAULT 0,
+    "authorId"         TEXT         NOT NULL,
+    "createdAt"        TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "version"          INTEGER      NOT NULL DEFAULT 1,
+    "editedAt"         TIMESTAMP(3),
+    "editedById"       TEXT,
+    "retractedAt"      TIMESTAMP(3),
+    "retractedById"    TEXT,
+    "retractionReason" TEXT,
+
+    CONSTRAINT "DepartmentEntry_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "DepartmentEntryVersion" (
+    "id"           TEXT         NOT NULL,
+    "entryId"      TEXT         NOT NULL,
+    "version"      INTEGER      NOT NULL,
+    "body"         TEXT         NOT NULL,
+    "minClearance" INTEGER      NOT NULL,
+    "editedById"   TEXT         NOT NULL,
+    "editedAt"     TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "DepartmentEntryVersion_pkey" PRIMARY KEY ("id")
+);
+
+ALTER TABLE "DepartmentEntry"
+    ADD CONSTRAINT "DepartmentEntry_departmentId_fkey"
+    FOREIGN KEY ("departmentId") REFERENCES "Department"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE "DepartmentEntryVersion"
+    ADD CONSTRAINT "DepartmentEntryVersion_entryId_fkey"
+    FOREIGN KEY ("entryId") REFERENCES "DepartmentEntry"("id")
+    ON DELETE RESTRICT ON UPDATE CASCADE;
+
+CREATE INDEX "DepartmentEntry_departmentId_createdAt_idx"
+    ON "DepartmentEntry"("departmentId", "createdAt" DESC);
+CREATE INDEX "DepartmentEntry_authorId_idx" ON "DepartmentEntry"("authorId");
+CREATE UNIQUE INDEX "DepartmentEntryVersion_entryId_version_key"
+    ON "DepartmentEntryVersion"("entryId", "version");
+CREATE INDEX "DepartmentEntryVersion_entryId_version_idx"
+    ON "DepartmentEntryVersion"("entryId", "version" DESC);
+
+CREATE RULE dept_entry_no_delete AS ON DELETE TO "DepartmentEntry" DO INSTEAD NOTHING;
+CREATE RULE dept_entry_version_no_delete
+    AS ON DELETE TO "DepartmentEntryVersion" DO INSTEAD NOTHING;
+
+-- Autor, Entstehungszeit und Abteilung sind unantastbar. Wer etwas anderes
+-- sagen will, zieht zurück und schreibt neu — und genau das ist dann sichtbar.
+CREATE OR REPLACE FUNCTION dept_entry_immutable_guard() RETURNS trigger AS $$
+BEGIN
+  IF NEW."authorId"     IS DISTINCT FROM OLD."authorId"
+  OR NEW."createdAt"    IS DISTINCT FROM OLD."createdAt"
+  OR NEW."departmentId" IS DISTINCT FROM OLD."departmentId" THEN
+    RAISE EXCEPTION 'authorId, createdAt und die Abteilung eines Vermerks sind unveränderlich';
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER dept_entry_immutable_guard_trg
+  BEFORE UPDATE ON "DepartmentEntry"
+  FOR EACH ROW EXECUTE FUNCTION dept_entry_immutable_guard();
+
+-- Eine Version darf nur eines: die Stufe mitziehen, wenn der Vermerk höher
+-- eingestuft wird. Sonst läse jemand den ursprünglichen Text in der Historie.
+CREATE OR REPLACE FUNCTION dept_entry_version_guard() RETURNS trigger AS $$
+BEGIN
+  IF NEW."id"         IS DISTINCT FROM OLD."id"
+  OR NEW."entryId"    IS DISTINCT FROM OLD."entryId"
+  OR NEW."version"    IS DISTINCT FROM OLD."version"
+  OR NEW."body"       IS DISTINCT FROM OLD."body"
+  OR NEW."editedById" IS DISTINCT FROM OLD."editedById"
+  OR NEW."editedAt"   IS DISTINCT FROM OLD."editedAt" THEN
+    RAISE EXCEPTION 'Versionen eines Abteilungsvermerks sind unveränderlich';
+  END IF;
+  IF NEW."minClearance" < OLD."minClearance" THEN
+    RAISE EXCEPTION 'Die Stufe einer Version kann nur steigen';
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER dept_entry_version_guard_trg
+  BEFORE UPDATE ON "DepartmentEntryVersion"
+  FOR EACH ROW EXECUTE FUNCTION dept_entry_version_guard();

packages/db/prisma/schema.prisma

@@ -475,7 +475,10 @@ model PersonnelFile {
   userId      String? // null bei Personen ohne Discord-Konto
   displayName String
   rank        String?
-  department  String?
+  /// Die Abteilung, der diese Person angehoert. Vorher stand hier ein
+  /// Freitext; als Beziehung laesst sich fragen, was es zu einer Abteilung
+  /// insgesamt gibt. Siehe docs/13-entscheidungen.md.
+  departmentId String?
 
   /// Mehrere Etiketten zugleich: "Gekuendigt" und "Verhaftet" schliessen
   /// einander nicht aus. Die Werte sind Schluessel aus PersonnelStatusTag.
@@ -493,6 +496,7 @@ model PersonnelFile {
   searchVector Unsupported("tsvector")?
 
   user         User?                 @relation(fields: [userId], references: [id])
+  department   Department?           @relation(fields: [departmentId], references: [id], onDelete: SetNull)
   messages     ChatMessage[]
   participants CaseParticipant[]
   documents    Document[]
@@ -500,6 +504,7 @@ model PersonnelFile {
 
   @@index([displayName])
   @@index([userId])
+  @@index([departmentId])
   @@index([classification])
   @@index([statusTags], type: Gin)
   @@index([searchVector], map: "personnel_search_idx", type: Gin)
@@ -721,6 +726,7 @@ model ChatMessage {
   id              String @id // clientseitig erzeugt, UUIDv7
   caseId          String?
   personnelFileId String?
+  departmentId    String?
   authorId    String
   body        String
   replyToId   String?
@@ -736,12 +742,14 @@ model ChatMessage {
 
   case          Case?          @relation(fields: [caseId], references: [id], onDelete: Cascade)
   personnelFile PersonnelFile? @relation(fields: [personnelFileId], references: [id], onDelete: Cascade)
+  department    Department?    @relation(fields: [departmentId], references: [id], onDelete: Cascade)
   replyTo   ChatMessage?   @relation("replies", fields: [replyToId], references: [id])
   replies   ChatMessage[]  @relation("replies")
   reactions ChatReaction[]
 
   @@index([caseId, createdAt(sort: Desc)])
   @@index([personnelFileId, createdAt(sort: Desc)])
+  @@index([departmentId, createdAt(sort: Desc)])
   @@index([authorId])
   @@index([replyToId])
   @@index([mentions], type: Gin)
@@ -837,6 +845,82 @@ model NotificationOutbox {
   @@index([caseId])
 }
 
+/// Eine Abteilung der Foundation.
+///
+/// Fast jede Person gehoert einer an, und die Abteilung ist die Ebene ueber
+/// der Personalakte: was zu ihr aktenkundig ist, ergibt sich aus ihren
+/// Mitgliedern. Deshalb traegt eine Fallakte **keine** Abteilung — die
+/// Zuordnung entsteht ueber die Beteiligten und deren Personalakten und ist
+/// damit immer aktuell. Siehe docs/13-entscheidungen.md.
+model Department {
+  id          String  @id @default(uuid(7))
+  key         String  @unique // "SHD"
+  name        String
+  description String?
+
+  /// Wer diese Stufe nicht hat, sieht die Abteilung nicht. Sie steht auf 0,
+  /// solange nichts dagegen spricht: dass es den Sicherheitsdienst gibt, ist
+  /// kein Geheimnis. Was in ihm aktenkundig ist, filtert weiterhin jede Liste
+  /// fuer sich.
+  minClearance Int     @default(0)
+  isArchived   Boolean @default(false)
+
+  createdById String?
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  members   PersonnelFile[]
+  messages  ChatMessage[]
+  entries   DepartmentEntry[]
+
+  @@index([isArchived, name])
+}
+
+/// Ein Vermerk an einer Abteilung.
+///
+/// Dieselbe Zusicherung wie beim Verlauf einer Akte, in schmalerer Form: es
+/// gibt kein DELETE, jede Aenderung erzeugt eine Version, jede Zuruecknahme
+/// laesst einen Grabstein stehen. Was fehlt, sind die Teile, die nur eine
+/// Ermittlung braucht — Korrekturkette, Anhaenge, Karenzzeit. Ein
+/// Abteilungsvermerk ist ein laufendes Protokoll, kein Beweismittel.
+model DepartmentEntry {
+  id           String   @id // clientseitig erzeugt, UUIDv7
+  departmentId String
+  body         String
+  minClearance Int      @default(0)
+  authorId     String // unveraenderlich
+  createdAt    DateTime @default(now()) // unveraenderlich
+
+  version    Int       @default(1)
+  editedAt   DateTime?
+  editedById String?
+
+  retractedAt      DateTime?
+  retractedById    String?
+  retractionReason String?
+
+  department Department               @relation(fields: [departmentId], references: [id], onDelete: Cascade)
+  versions   DepartmentEntryVersion[]
+
+  @@index([departmentId, createdAt(sort: Desc)])
+  @@index([authorId])
+}
+
+/// Strikt anhaengend, enthaelt jeweils den VORHERIGEN Stand.
+model DepartmentEntryVersion {
+  id           String          @id @default(uuid(7))
+  entryId      String
+  version      Int
+  body         String
+  minClearance Int
+  editedById   String
+  editedAt     DateTime        @default(now())
+  entry        DepartmentEntry @relation(fields: [entryId], references: [id])
+
+  @@unique([entryId, version])
+  @@index([entryId, version(sort: Desc)])
+}
+
 /// Suchindex, **je Freigabestufe ein Vektor**.
 ///
 /// Der Vektor zur Stufe N enthaelt alles, was ein Leser dieser Stufe sehen

web/app/(app)/abteilungen/[key]/DepartmentEntries.tsx

@@ -0,0 +1,326 @@
+'use client'
+
+import { useState, useTransition } from 'react'
+import { uuidv7 } from '@/lib/uuidv7'
+import { departmentEntryText, departmentText } from '@/lib/i18n/departments'
+import { commonText } from '@/lib/i18n/common'
+import { createEntryAction, editEntryAction, retractEntryAction } from './actions'
+
+export type EntryView = {
+  id: string
+  body: string
+  minClearance: number
+  authorId: string
+  authorName: string
+  createdAt: string
+  version: number
+  editedAt: string | null
+  retractedAt: string | null
+  retractedByName: string | null
+  retractionReason: string | null
+}
+
+/**
+ * Die Vermerke einer Abteilung.
+ *
+ * Dieselbe Zusicherung wie im Verlauf einer Akte, und sie steht auch so da:
+ * ein geänderter Vermerk trägt seine Fassungsnummer, ein zurückgezogener
+ * bleibt als Grabstein mit Grund und Namen stehen. Nichts verschwindet.
+ */
+export function DepartmentEntries({
+  departmentKey,
+  entries,
+  currentUserId,
+  canWrite,
+  canRetract,
+  canEditAny,
+  canEditOwn,
+  levels,
+}: {
+  departmentKey: string
+  entries: EntryView[]
+  currentUserId: string
+  canWrite: boolean
+  canRetract: boolean
+  canEditAny: boolean
+  canEditOwn: boolean
+  levels: { level: number; name: string }[]
+}) {
+  const [liste, setListe] = useState(entries)
+  const [text, setText] = useState('')
+  const [stufe, setStufe] = useState(0)
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [pending, startTransition] = useTransition()
+
+  function schreiben() {
+    const inhalt = text.trim()
+    if (!inhalt) return
+
+    const id = uuidv7()
+    setFehler(null)
+
+    startTransition(async () => {
+      const ergebnis = await createEntryAction({
+        id,
+        departmentKey,
+        body: inhalt,
+        minClearance: stufe,
+      })
+      if (!ergebnis.ok) {
+        setFehler(ergebnis.error)
+        return
+      }
+      setListe((bisher) => [
+        {
+          id,
+          body: inhalt,
+          minClearance: stufe,
+          authorId: currentUserId,
+          authorName: '',
+          createdAt: new Date().toISOString(),
+          version: 1,
+          editedAt: null,
+          retractedAt: null,
+          retractedByName: null,
+          retractionReason: null,
+        },
+        ...bisher,
+      ])
+      setText('')
+    })
+  }
+
+  return (
+    <div>
+      {canWrite ? (
+        <div className="mb-8 border border-line p-4">
+          <label className="block">
+            <span className="font-condensed text-2xs text-text-dim">
+              {departmentEntryText.body}
+            </span>
+            <textarea
+              value={text}
+              onChange={(event) => setText(event.target.value)}
+              rows={3}
+              className="field mt-1.5 w-full"
+            />
+          </label>
+
+          <div className="mt-3 flex flex-wrap items-center gap-4">
+            <label className="flex items-center gap-2 text-2xs text-text-dim">
+              {departmentEntryText.minClearance}
+              <select
+                value={stufe}
+                onChange={(event) => setStufe(Number(event.target.value))}
+                className="field"
+              >
+                {levels.map((level) => (
+                  <option key={level.level} value={level.level}>
+                    {level.level} · {level.name}
+                  </option>
+                ))}
+              </select>
+            </label>
+
+            <button
+              type="button"
+              onClick={schreiben}
+              disabled={pending || text.trim().length === 0}
+              aria-busy={pending}
+              className="btn btn-primary"
+            >
+              {pending ? departmentEntryText.saving : departmentEntryText.save}
+            </button>
+            {fehler ? <span className="font-condensed text-2xs text-stamp-4">{fehler}</span> : null}
+          </div>
+
+          <p className="mt-3 text-2xs text-text-dim">{departmentEntryText.hint}</p>
+        </div>
+      ) : null}
+
+      {liste.length === 0 ? <p className="text-text-dim">{departmentText.entriesEmpty}</p> : null}
+
+      <ul className="timeline space-y-6">
+        {liste.map((vermerk) => (
+          <Vermerk
+            key={vermerk.id}
+            vermerk={vermerk}
+            departmentKey={departmentKey}
+            canEdit={
+              canEditAny || (canEditOwn && vermerk.authorId === currentUserId)
+            }
+            canRetract={canRetract}
+            onChange={(neu) =>
+              setListe((bisher) => bisher.map((v) => (v.id === neu.id ? neu : v)))
+            }
+          />
+        ))}
+      </ul>
+    </div>
+  )
+}
+
+function Vermerk({
+  vermerk,
+  departmentKey,
+  canEdit,
+  canRetract,
+  onChange,
+}: {
+  vermerk: EntryView
+  departmentKey: string
+  canEdit: boolean
+  canRetract: boolean
+  onChange: (neu: EntryView) => void
+}) {
+  const [modus, setModus] = useState<'lesen' | 'aendern' | 'zurueckziehen'>('lesen')
+  const [text, setText] = useState(vermerk.body)
+  const [grund, setGrund] = useState('')
+  const [fehler, setFehler] = useState<string | null>(null)
+  const [pending, startTransition] = useTransition()
+  const zurueckgezogen = vermerk.retractedAt !== null
+
+  return (
+    <li>
+      <div className="flex flex-wrap items-baseline gap-x-4 gap-y-1">
+        <span className="font-condensed text-2xs text-text-dim">{vermerk.authorName}</span>
+        <time className="text-2xs text-text-dim">
+          {new Date(vermerk.createdAt).toLocaleString('de-DE')}
+        </time>
+        {vermerk.editedAt ? (
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentEntryText.edited(vermerk.version)}
+          </span>
+        ) : null}
+        {vermerk.minClearance > 0 ? (
+          <span className="font-mono text-2xs text-text-dim">
+            {departmentEntryText.minClearance} {vermerk.minClearance}
+          </span>
+        ) : null}
+      </div>
+
+      {zurueckgezogen ? (
+        <p className="mt-1 border-l-(length:--spacing-edge) border-stamp-4 pl-3 text-sm text-text-dim">
+          {departmentEntryText.retractedBy(
+            vermerk.retractedByName ?? '',
+            vermerk.retractionReason ?? '',
+          )}
+        </p>
+      ) : modus === 'aendern' ? (
+        <div className="mt-2">
+          <textarea
+            value={text}
+            onChange={(event) => setText(event.target.value)}
+            rows={4}
+            className="field w-full"
+          />
+          <div className="mt-2 flex flex-wrap items-center gap-3">
+            <button
+              type="button"
+              disabled={pending}
+              aria-busy={pending}
+              className="btn btn-sm btn-primary"
+              onClick={() =>
+                startTransition(async () => {
+                  const ergebnis = await editEntryAction({
+                    id: vermerk.id,
+                    departmentKey,
+                    body: text,
+                  })
+                  if (!ergebnis.ok) {
+                    setFehler(ergebnis.error)
+                    return
+                  }
+                  onChange({
+                    ...vermerk,
+                    body: text,
+                    version: vermerk.version + 1,
+                    editedAt: new Date().toISOString(),
+                  })
+                  setModus('lesen')
+                })
+              }
+            >
+              {departmentEntryText.editSave}
+            </button>
+            <button type="button" onClick={() => setModus('lesen')} className="btn btn-sm">
+              {departmentEntryText.cancel}
+            </button>
+          </div>
+        </div>
+      ) : (
+        <p className="mt-1 text-sm whitespace-pre-wrap">{vermerk.body}</p>
+      )}
+
+      {modus === 'zurueckziehen' ? (
+        <div className="mt-2">
+          <label className="block">
+            <span className="font-condensed text-2xs text-text-dim">
+              {departmentEntryText.retractReason}
+            </span>
+            <input
+              value={grund}
+              onChange={(event) => setGrund(event.target.value)}
+              className="field mt-1.5 w-full max-w-sm"
+            />
+          </label>
+          <div className="mt-2 flex flex-wrap items-center gap-3">
+            <button
+              type="button"
+              disabled={pending || grund.trim().length < 10}
+              aria-busy={pending}
+              className="btn btn-sm text-stamp-4"
+              onClick={() =>
+                startTransition(async () => {
+                  const ergebnis = await retractEntryAction({
+                    id: vermerk.id,
+                    departmentKey,
+                    reason: grund,
+                  })
+                  if (!ergebnis.ok) {
+                    setFehler(ergebnis.error)
+                    return
+                  }
+                  onChange({
+                    ...vermerk,
+                    retractedAt: new Date().toISOString(),
+                    retractionReason: grund,
+                  })
+                  setModus('lesen')
+                })
+              }
+            >
+              {departmentEntryText.retract}
+            </button>
+            <button type="button" onClick={() => setModus('lesen')} className="btn btn-sm">
+              {departmentEntryText.cancel}
+            </button>
+          </div>
+        </div>
+      ) : null}
+
+      {!zurueckgezogen && modus === 'lesen' ? (
+        <div className="mt-2 flex flex-wrap gap-3">
+          {canEdit ? (
+            <button type="button" onClick={() => setModus('aendern')} className="btn btn-sm">
+              {departmentEntryText.edit}
+            </button>
+          ) : null}
+          {canRetract ? (
+            <button
+              type="button"
+              onClick={() => setModus('zurueckziehen')}
+              className="btn btn-sm text-stamp-4"
+            >
+              {departmentEntryText.retract}
+            </button>
+          ) : null}
+        </div>
+      ) : null}
+
+      {fehler ? (
+        <p className="mt-2 font-condensed text-2xs text-stamp-4">{fehler || commonText.unknown}</p>
+      ) : null}
+    </li>
+  )
+}

web/app/(app)/abteilungen/[key]/actions.ts

@@ -0,0 +1,79 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import { requireUser } from '@/lib/auth/current'
+import { AccessError } from '@/lib/errors'
+import { createEntry, editEntry, retractEntry } from '@/lib/departments/entries'
+import { de } from '@/lib/i18n/de'
+
+export type ActionResult = { ok: true } | { ok: false; error: string }
+
+function toMessage(error: unknown): string {
+  if (error instanceof AccessError) {
+    return de.actionErrors[error.code] ?? de.actionErrors.default!
+  }
+  console.error('[abteilungsvermerk] unerwartet', error)
+  return de.actionErrors.default!
+}
+
+const createSchema = z.object({
+  id: z.string().min(1).max(64),
+  departmentKey: z.string().min(1).max(21),
+  body: z.string().min(1).max(20_000),
+  minClearance: z.coerce.number().int().min(0).max(5),
+})
+
+export async function createEntryAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = createSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors['entry-empty']! }
+
+  try {
+    await createEntry(user.permissions, parsed.data)
+    revalidatePath(`/abteilungen/${parsed.data.departmentKey}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}
+
+const editSchema = z.object({
+  id: z.string().min(1).max(64),
+  departmentKey: z.string().min(1).max(21),
+  body: z.string().min(1).max(20_000),
+})
+
+export async function editEntryAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = editSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors['entry-empty']! }
+
+  try {
+    await editEntry(user.permissions, parsed.data)
+    revalidatePath(`/abteilungen/${parsed.data.departmentKey}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}
+
+const retractSchema = z.object({
+  id: z.string().min(1).max(64),
+  departmentKey: z.string().min(1).max(21),
+  reason: z.string().min(10).max(500),
+})
+
+export async function retractEntryAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = retractSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors['reason-required']! }
+
+  try {
+    await retractEntry(user.permissions, parsed.data)
+    revalidatePath(`/abteilungen/${parsed.data.departmentKey}`)
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}

web/app/(app)/abteilungen/[key]/page.tsx

@@ -0,0 +1,328 @@
+import type { Metadata } from 'next'
+import { Suspense } from 'react'
+import Link from 'next/link'
+import { notFound } from 'next/navigation'
+import { db } from '@/lib/db'
+import { requireUser } from '@/lib/auth/current'
+import {
+  caseTypesOfDepartment,
+  listDepartmentCases,
+  listDepartmentDocuments,
+  listMembers,
+  loadVisibleDepartment,
+} from '@/lib/departments/service'
+import { listEntries } from '@/lib/departments/entries'
+import { loadChatView } from '@/lib/chat/load'
+import { de } from '@/lib/i18n/de'
+import { PieChart } from '@/components/PieChart'
+import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
+import { SkeletonLine } from '@/components/Skeleton'
+import { ChatLazy } from '@/components/chat/ChatLazy'
+import { DepartmentEntries } from './DepartmentEntries'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+export const dynamic = 'force-dynamic'
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ key: string }>
+}): Promise<Metadata> {
+  const user = await requireUser()
+  const { key } = await params
+  const abteilung = await loadVisibleDepartment(user.permissions, key)
+  return { title: abteilung?.name ?? de.department.one }
+}
+
+/**
+ * Eine Abteilung.
+ *
+ * Dasselbe Bild wie eine Personalakte, eine Stufe höher: wer gehört dazu, was
+ * ist dazu aktenkundig, was ist dazu vermerkt, und worüber wird geredet. Der
+ * Unterschied ist, dass hier **nichts eingetragen** wird — die Fälle ergeben
+ * sich aus den Beteiligten und deren Personalakten.
+ */
+export default async function DepartmentPage({ params }: { params: Promise<{ key: string }> }) {
+  const user = await requireUser()
+  const { key } = await params
+
+  const abteilung = await loadVisibleDepartment(user.permissions, key)
+  // Kein Zugriff heisst 404, nicht 403.
+  if (!abteilung) notFound()
+
+  const [levels, verteilung] = await Promise.all([
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+    caseTypesOfDepartment(user.permissions, abteilung.id),
+  ])
+  const levelName = new Map(levels.map((l) => [l.level, l.name]))
+
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <header>
+        <div className="flex flex-wrap items-baseline gap-x-4 gap-y-2">
+          <span className="font-mono text-xs text-text-dim">{abteilung.key}</span>
+          <span className="font-condensed text-2xs text-text-dim">{de.department.one}</span>
+          {abteilung.isArchived ? (
+            <span className="font-condensed text-2xs text-text-dim">
+              {de.department.archived}
+            </span>
+          ) : null}
+        </div>
+        <h1 className="mt-2 font-condensed">{abteilung.name}</h1>
+        {abteilung.description ? (
+          <p className="mt-2 max-w-(--container-measure) text-sm text-text-dim">
+            {abteilung.description}
+          </p>
+        ) : null}
+      </header>
+
+      <section className="mt-8 border border-line p-5">
+        <h2 className="font-condensed text-xs text-text-dim">{de.department.chart}</h2>
+        <div className="mt-4">
+          <PieChart
+            slices={verteilung}
+            emptyLabel={de.department.chartEmpty}
+            totalLabel={de.department.chartTotal}
+          />
+        </div>
+        <p className="mt-4 max-w-(--container-measure) text-2xs text-text-dim">
+          {de.department.derivedHint}
+        </p>
+      </section>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.department.members}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="50%" />}>
+            <Members
+              departmentId={abteilung.id}
+              permissions={user.permissions}
+              levelName={levelName}
+            />
+          </Suspense>
+        </div>
+      </section>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.department.cases}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="60%" />}>
+            <Cases
+              departmentId={abteilung.id}
+              permissions={user.permissions}
+              levelName={levelName}
+            />
+          </Suspense>
+        </div>
+      </section>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.department.documents}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="55%" />}>
+            <Documents departmentId={abteilung.id} permissions={user.permissions} />
+          </Suspense>
+        </div>
+      </section>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.departmentEntry.heading}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="60%" />}>
+            <Entries
+              departmentKey={abteilung.key}
+              departmentId={abteilung.id}
+              user={user}
+              levels={levels}
+            />
+          </Suspense>
+        </div>
+      </section>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.chat.heading}</h2>
+        <div className="mt-4">
+          <Suspense fallback={<SkeletonLine width="60%" />}>
+            <ChatBlock departmentId={abteilung.id} user={user} />
+          </Suspense>
+        </div>
+      </section>
+    </main>
+  )
+}
+
+async function Members({
+  departmentId,
+  permissions,
+  levelName,
+}: {
+  departmentId: string
+  permissions: EffectivePermissions
+  levelName: Map<number, string>
+}) {
+  const mitglieder = await listMembers(permissions, departmentId)
+  if (mitglieder.length === 0) {
+    return <p className="text-text-dim">{de.department.membersEmpty}</p>
+  }
+
+  return (
+    <ul className="border-t border-line">
+      {mitglieder.map((person) => (
+        <li key={person.id} className="border-b border-line">
+          <Link
+            href={`/personalakten/${person.id}`}
+            className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-2 pl-3 text-text no-underline"
+            style={classificationEdgeStyle(person.classification)}
+          >
+            <span className="grow">{person.displayName}</span>
+            {person.rank ? (
+              <span className="font-condensed text-2xs text-text-dim">{person.rank}</span>
+            ) : null}
+            <StampMark
+              level={person.classification}
+              name={levelName.get(person.classification) ?? de.common.unknown}
+            />
+          </Link>
+        </li>
+      ))}
+    </ul>
+  )
+}
+
+async function Cases({
+  departmentId,
+  permissions,
+  levelName,
+}: {
+  departmentId: string
+  permissions: EffectivePermissions
+  levelName: Map<number, string>
+}) {
+  const faelle = await listDepartmentCases(permissions, departmentId)
+  if (faelle.length === 0) return <p className="text-text-dim">{de.department.casesEmpty}</p>
+
+  return (
+    <ul className="border-t border-line">
+      {faelle.map((akte) => (
+        <li key={akte.id} className="border-b border-line">
+          <Link
+            href={`/faelle/${akte.caseNumber}`}
+            className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-2 pl-3 text-text no-underline"
+            style={classificationEdgeStyle(akte.classification)}
+          >
+            <span className="font-mono text-xs text-text-dim">{akte.caseNumber}</span>
+            <span className="grow">{akte.title}</span>
+            <span className="font-condensed text-2xs text-text-dim">
+              {de.case.statusNames[akte.status] ?? akte.status}
+            </span>
+            <StampMark
+              level={akte.classification}
+              name={levelName.get(akte.classification) ?? de.common.unknown}
+            />
+          </Link>
+        </li>
+      ))}
+    </ul>
+  )
+}
+
+async function Documents({
+  departmentId,
+  permissions,
+}: {
+  departmentId: string
+  permissions: EffectivePermissions
+}) {
+  const dokumente = await listDepartmentDocuments(permissions, departmentId)
+  if (dokumente.length === 0) {
+    return <p className="text-text-dim">{de.department.documentsEmpty}</p>
+  }
+
+  return (
+    <ul className="border-t border-line">
+      {dokumente.map((dokument) => (
+        <li key={dokument.id} className="border-b border-line">
+          <Link
+            href={`/dokumente/${dokument.documentNumber}`}
+            className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-2 text-text no-underline"
+          >
+            <span className="font-mono text-xs text-text-dim">{dokument.documentNumber}</span>
+            <span className="grow">{dokument.title}</span>
+          </Link>
+        </li>
+      ))}
+    </ul>
+  )
+}
+
+async function Entries({
+  departmentKey,
+  departmentId,
+  user,
+  levels,
+}: {
+  departmentKey: string
+  departmentId: string
+  user: { id: string; permissions: EffectivePermissions }
+  levels: { level: number; name: string }[]
+}) {
+  const vermerke = await listEntries(user.permissions, departmentId)
+  const autoren = await db.user.findMany({
+    where: { id: { in: [...new Set(vermerke.flatMap((v) => [v.authorId, v.retractedById ?? ''])) ].filter(Boolean) } },
+    select: { id: true, displayName: true },
+  })
+  const nameVon = new Map(autoren.map((a) => [a.id, a.displayName]))
+
+  return (
+    <DepartmentEntries
+      departmentKey={departmentKey}
+      currentUserId={user.id}
+      canWrite={user.permissions.isAdmin || user.permissions.permissions.has('entry.create')}
+      canRetract={user.permissions.isAdmin || user.permissions.permissions.has('entry.retract')}
+      canEditAny={user.permissions.isAdmin || user.permissions.permissions.has('entry.edit_any')}
+      canEditOwn={user.permissions.isAdmin || user.permissions.permissions.has('entry.edit_own')}
+      levels={levels.filter((l) => l.level <= user.permissions.clearanceLevel)}
+      entries={vermerke.map((vermerk) => ({
+        id: vermerk.id,
+        body: vermerk.body,
+        minClearance: vermerk.minClearance,
+        authorId: vermerk.authorId,
+        authorName: nameVon.get(vermerk.authorId) ?? vermerk.authorId,
+        createdAt: vermerk.createdAt.toISOString(),
+        version: vermerk.version,
+        editedAt: vermerk.editedAt?.toISOString() ?? null,
+        retractedAt: vermerk.retractedAt?.toISOString() ?? null,
+        retractedByName: vermerk.retractedById
+          ? (nameVon.get(vermerk.retractedById) ?? vermerk.retractedById)
+          : null,
+        retractionReason: vermerk.retractionReason,
+      }))}
+    />
+  )
+}
+
+async function ChatBlock({
+  departmentId,
+  user,
+}: {
+  departmentId: string
+  user: { id: string; permissions: EffectivePermissions }
+}) {
+  const ansicht = await loadChatView(user.permissions, {
+    kind: 'department',
+    departmentId,
+  })
+
+  return (
+    <ChatLazy
+      scope={{ kind: 'department', departmentId }}
+      topic={`department:${departmentId}`}
+      initial={ansicht.messages}
+      initialReactions={ansicht.reactions}
+      currentUserId={user.id}
+      lastReadAt={ansicht.lastReadAt}
+      canAdopt={false}
+      mentionNames={ansicht.mentionNames}
+    />
+  )
+}

web/app/(app)/abteilungen/loading.tsx

@@ -0,0 +1,15 @@
+import { SkeletonLine } from '@/components/Skeleton'
+
+/** Skelett statt Spinner, siehe docs/09-performance-und-ux.md. */
+export default function Loading() {
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <SkeletonLine width="12rem" />
+      <div className="mt-8 space-y-3">
+        <SkeletonLine />
+        <SkeletonLine width="70%" />
+        <SkeletonLine width="55%" />
+      </div>
+    </main>
+  )
+}

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

@@ -0,0 +1,75 @@
+import type { Metadata } from 'next'
+import Link from 'next/link'
+import { requireUser } from '@/lib/auth/current'
+import { casesPerDepartment, listDepartments } from '@/lib/departments/service'
+import { de } from '@/lib/i18n/de'
+import { PieChart } from '@/components/PieChart'
+
+export const metadata: Metadata = { title: de.department.heading }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Alle Abteilungen, und wo sich etwas häuft.
+ *
+ * Das Diagramm beantwortet die Frage, mit der man auf diese Seite kommt: zu
+ * welcher Abteilung gibt es die meisten Fälle. Gezählt wird nur, was der
+ * Fragende auch sehen darf — eine Zahl, die mehr zählt als seine Liste
+ * hergibt, wäre selbst eine Auskunft.
+ */
+export default async function DepartmentsPage() {
+  const user = await requireUser()
+  const [abteilungen, verteilung] = await Promise.all([
+    listDepartments(user.permissions),
+    casesPerDepartment(user.permissions),
+  ])
+
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <h1 className="font-condensed">{de.department.heading}</h1>
+      <p className="mt-1 max-w-(--container-measure) text-2xs text-text-dim">
+        {de.department.intro}
+      </p>
+
+      {abteilungen.length === 0 ? (
+        <p className="mt-10 text-text-dim">{de.department.empty}</p>
+      ) : (
+        <>
+          <section className="mt-8 border border-line p-5">
+            <h2 className="font-condensed text-xs text-text-dim">{de.department.chartAll}</h2>
+            <div className="mt-4">
+              <PieChart
+                slices={verteilung}
+                emptyLabel={de.department.chartEmpty}
+                totalLabel={de.department.chartTotal}
+              />
+            </div>
+          </section>
+
+          <ul className="mt-10 border-t border-line">
+            {abteilungen.map((abteilung) => (
+              <li key={abteilung.id} className="border-b border-line">
+                <Link
+                  href={`/abteilungen/${abteilung.key}`}
+                  className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-3 text-text no-underline"
+                >
+                  <span className="font-mono text-xs text-text-dim">{abteilung.key}</span>
+                  <span className="grow">{abteilung.name}</span>
+                  {abteilung.description ? (
+                    <span className="w-full text-2xs text-text-dim sm:w-auto sm:grow-[2]">
+                      {abteilung.description}
+                    </span>
+                  ) : null}
+                  {abteilung.memberCount === null ? null : (
+                    <span className="font-condensed text-2xs text-text-dim">
+                      {de.department.memberCount(abteilung.memberCount)}
+                    </span>
+                  )}
+                </Link>
+              </li>
+            ))}
+          </ul>
+        </>
+      )}
+    </main>
+  )
+}

web/app/(app)/admin/abteilungen/DepartmentForm.tsx

@@ -0,0 +1,161 @@
+'use client'
+
+import { useActionState, useState } from 'react'
+import { departmentAdminText } from '@/lib/i18n/departments'
+import {
+  createDepartmentAction,
+  updateDepartmentAction,
+  type ActionResult,
+} from './actions'
+
+type Existing = {
+  id: string
+  key: string
+  name: string
+  description: string | null
+  minClearance: number
+  isArchived: boolean
+  memberCount: number | null
+}
+
+/**
+ * Anlegen und Ändern in einem Formular.
+ *
+ * Das Kürzel steht nach dem Anlegen fest: es steckt in der Adresse jeder
+ * Abteilungsseite, und ein wandernder Bezeichner macht geteilte Links wertlos.
+ * Wer sich vertan hat, legt neu an und archiviert die alte — archivieren
+ * statt löschen, weil an einer Abteilung Vermerke und Zuordnungen hängen.
+ */
+export function DepartmentForm({
+  levels,
+  existing,
+}: {
+  levels: { level: number; name: string }[]
+  existing?: Existing
+}) {
+  const [state, action, pending] = useActionState<ActionResult | null, FormData>(
+    existing ? updateDepartmentAction : createDepartmentAction,
+    null,
+  )
+  const [offen, setOffen] = useState(!existing)
+
+  if (existing && !offen) {
+    return (
+      <div className="flex flex-wrap items-baseline gap-x-4 gap-y-1">
+        <span className="font-mono text-xs text-text-dim">{existing.key}</span>
+        <span className="grow">{existing.name}</span>
+        {existing.memberCount === null ? null : (
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentAdminText.members} {existing.memberCount}
+          </span>
+        )}
+        {existing.isArchived ? (
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentAdminText.archived}
+          </span>
+        ) : null}
+        <button type="button" onClick={() => setOffen(true)} className="btn btn-sm">
+          {departmentAdminText.edit}
+        </button>
+      </div>
+    )
+  }
+
+  return (
+    <form action={action} className="max-w-(--container-measure) space-y-4">
+      {existing ? <input type="hidden" name="id" value={existing.id} /> : null}
+
+      <div className="grid gap-4 sm:grid-cols-2">
+        <label className="block">
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentAdminText.key}
+          </span>
+          {existing ? (
+            <p className="mt-1.5 font-mono text-sm">{existing.key}</p>
+          ) : (
+            <>
+              <input name="key" required maxLength={21} className="field mt-1.5 w-full font-mono" />
+              <span className="mt-1 block text-2xs text-text-dim">
+                {departmentAdminText.keyHint}
+              </span>
+            </>
+          )}
+        </label>
+
+        <label className="block">
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentAdminText.name}
+          </span>
+          <input
+            name="name"
+            required
+            maxLength={120}
+            defaultValue={existing?.name}
+            className="field mt-1.5 w-full"
+          />
+        </label>
+      </div>
+
+      <label className="block">
+        <span className="font-condensed text-2xs text-text-dim">
+          {departmentAdminText.description}
+        </span>
+        <textarea
+          name="description"
+          rows={2}
+          maxLength={500}
+          defaultValue={existing?.description ?? ''}
+          className="field mt-1.5 w-full"
+        />
+      </label>
+
+      <div className="flex flex-wrap items-end gap-6">
+        <label className="block">
+          <span className="font-condensed text-2xs text-text-dim">
+            {departmentAdminText.minClearance}
+          </span>
+          <select
+            name="minClearance"
+            defaultValue={existing?.minClearance ?? 0}
+            className="field mt-1.5"
+          >
+            {levels.map((level) => (
+              <option key={level.level} value={level.level}>
+                {level.level} · {level.name}
+              </option>
+            ))}
+          </select>
+          <span className="mt-1 block text-2xs text-text-dim">
+            {departmentAdminText.minClearanceHint}
+          </span>
+        </label>
+
+        {existing ? (
+          <label className="flex items-center gap-2 pb-2 text-sm">
+            <input type="checkbox" name="isArchived" defaultChecked={existing.isArchived} />
+            {departmentAdminText.archived}
+          </label>
+        ) : null}
+      </div>
+
+      <div className="flex flex-wrap items-center gap-4">
+        <button type="submit" disabled={pending} aria-busy={pending} className="btn btn-primary">
+          {existing ? departmentAdminText.save : departmentAdminText.create}
+        </button>
+        {existing ? (
+          <button type="button" onClick={() => setOffen(false)} className="btn btn-sm">
+            {departmentAdminText.cancel}
+          </button>
+        ) : null}
+        {state?.ok ? (
+          <span className="font-condensed text-2xs text-text-dim">
+            {existing ? departmentAdminText.saved : departmentAdminText.created}
+          </span>
+        ) : null}
+        {state && !state.ok ? (
+          <span className="font-condensed text-2xs text-stamp-4">{state.error}</span>
+        ) : null}
+      </div>
+    </form>
+  )
+}

web/app/(app)/admin/abteilungen/actions.ts

@@ -0,0 +1,69 @@
+'use server'
+
+import { revalidatePath } from 'next/cache'
+import { z } from 'zod'
+import { requireUser } from '@/lib/auth/current'
+import { AccessError } from '@/lib/errors'
+import { createDepartment, updateDepartment } from '@/lib/departments/service'
+import { de } from '@/lib/i18n/de'
+
+export type ActionResult = { ok: true } | { ok: false; error: string }
+
+function toMessage(error: unknown): string {
+  if (error instanceof AccessError) {
+    return de.actionErrors[error.code] ?? de.actionErrors.default!
+  }
+  console.error('[abteilungen] unerwartet', error)
+  return de.actionErrors.default!
+}
+
+const createSchema = z.object({
+  key: z.string().min(1).max(21),
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).optional(),
+  minClearance: z.coerce.number().int().min(0).max(5),
+})
+
+export async function createDepartmentAction(
+  _prev: ActionResult | null,
+  formData: FormData,
+): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = createSchema.safeParse(Object.fromEntries(formData))
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await createDepartment(user.permissions, parsed.data)
+    revalidatePath('/admin/abteilungen')
+    revalidatePath('/abteilungen')
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}
+
+const updateSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1).max(120),
+  description: z.string().max(500).optional(),
+  minClearance: z.coerce.number().int().min(0).max(5),
+  isArchived: z.union([z.literal('on'), z.undefined()]).transform((wert) => wert === 'on'),
+})
+
+export async function updateDepartmentAction(
+  _prev: ActionResult | null,
+  formData: FormData,
+): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = updateSchema.safeParse(Object.fromEntries(formData))
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await updateDepartment(user.permissions, parsed.data)
+    revalidatePath('/admin/abteilungen')
+    revalidatePath('/abteilungen')
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}

web/app/(app)/admin/abteilungen/page.tsx

@@ -0,0 +1,69 @@
+import type { Metadata } from 'next'
+import { requireUser } from '@/lib/auth/current'
+import { notFound } from 'next/navigation'
+import { db } from '@/lib/db'
+import { listDepartments } from '@/lib/departments/service'
+import { de } from '@/lib/i18n/de'
+import { DepartmentForm } from './DepartmentForm'
+
+export const metadata: Metadata = { title: de.departmentAdmin.heading }
+export const dynamic = 'force-dynamic'
+
+/**
+ * Abteilungen verwalten.
+ *
+ * Angelegt wird hier, zugeordnet in der Personalakte: die Zugehörigkeit ist
+ * eine Angabe über die Person und gehört in ihre Akte, nicht in eine Liste im
+ * Adminbereich.
+ */
+export default async function DepartmentAdminPage() {
+  const user = await requireUser()
+  if (!user.permissions.isAdmin && !user.permissions.permissions.has('roles.manage')) {
+    notFound()
+  }
+
+  const [abteilungen, levels] = await Promise.all([
+    listDepartments(user.permissions, { includeArchived: true }),
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+  ])
+
+  const erlaubteStufen = levels.filter(
+    (level) => user.permissions.isAdmin || level.level <= user.permissions.clearanceLevel,
+  )
+
+  return (
+    <section>
+      <h2 className="font-condensed">{de.departmentAdmin.heading}</h2>
+      <p className="mt-1 max-w-(--container-measure) text-2xs text-text-dim">
+        {de.departmentAdmin.intro}
+      </p>
+
+      <div className="mt-6">
+        <DepartmentForm levels={erlaubteStufen} />
+      </div>
+
+      {abteilungen.length === 0 ? (
+        <p className="mt-10 text-text-dim">{de.departmentAdmin.empty}</p>
+      ) : (
+        <ul className="mt-10 border-t border-line">
+          {abteilungen.map((abteilung) => (
+            <li key={abteilung.id} className="border-b border-line py-4">
+              <DepartmentForm
+                levels={erlaubteStufen}
+                existing={{
+                  id: abteilung.id,
+                  key: abteilung.key,
+                  name: abteilung.name,
+                  description: abteilung.description,
+                  minClearance: abteilung.minClearance,
+                  isArchived: abteilung.isArchived,
+                  memberCount: abteilung.memberCount,
+                }}
+              />
+            </li>
+          ))}
+        </ul>
+      )}
+    </section>
+  )
+}

web/app/(app)/admin/protokoll/page.tsx

@@ -17,7 +17,7 @@ type Params = Record<string, string | string[] | undefined>
  * die Spur bei jeder schreibenden Aktion und bei jedem Lesezugriff ab Stufe 3,
  * ohne Ausnahme und ohne Möglichkeit, sie zu unterdrücken.
  *
- * Nur für die Leitung. Das folgt aus dem, was drinsteht: eine Zeile nennt
+ * Nur mit dem Recht `audit.read`. Das folgt aus dem, was drinsteht: eine Zeile nennt
  * Aktenzeichen und Namen, und schon die Existenz einer Zeile verrät, dass es
  * einen Vorgang gibt. Ein „gefiltertes Protokoll für alle" wäre ein Weg, die
  * Sichtbarkeitsregeln von hinten aufzurollen.
@@ -30,7 +30,7 @@ export default async function AuditLogPage({
 }: {
   searchParams: Promise<Params>
 }) {
-  await requirePermission('admin')
+  await requirePermission('audit.read')
   const params = await searchParams
 
   const wert = (name: string): string | undefined => {

web/app/(app)/admin/sections.ts

@@ -21,11 +21,17 @@ export type AdminSection = {
 }
 
 export function adminSections(p: EffectivePermissions): AdminSection[] {
-  const darf = (recht: 'roles.manage' | 'template.manage' | 'admin'): boolean =>
+  const darf = (recht: 'roles.manage' | 'template.manage' | 'audit.read' | 'admin'): boolean =>
     p.isAdmin || (recht !== 'admin' && p.permissions.has(recht))
 
   const alle: (AdminSection & { sichtbar: boolean })[] = [
     { key: 'roles', href: '/admin/rollen', sichtbar: darf('roles.manage'), ...text('roles') },
+    {
+      key: 'departments',
+      href: '/admin/abteilungen',
+      sichtbar: darf('roles.manage'),
+      ...text('departments'),
+    },
     {
       key: 'templates',
       href: '/admin/vorlagen',
@@ -33,7 +39,7 @@ export function adminSections(p: EffectivePermissions): AdminSection[] {
       ...text('templates'),
     },
     { key: 'policy', href: '/admin/richtlinie', sichtbar: darf('admin'), ...text('policy') },
-    { key: 'log', href: '/admin/protokoll', sichtbar: darf('admin'), ...text('log') },
+    { key: 'log', href: '/admin/protokoll', sichtbar: darf('audit.read'), ...text('log') },
     { key: 'system', href: '/admin/system', sichtbar: darf('admin'), ...text('system') },
   ]
 
@@ -49,5 +55,10 @@ function text(key: string): { label: string; description: string } {
 
 /** Ob jemand die Verwaltung überhaupt sieht. Für die Kopfzeile. */
 export function hasAdminAccess(p: EffectivePermissions): boolean {
-  return p.isAdmin || p.permissions.has('roles.manage') || p.permissions.has('template.manage')
+  return (
+    p.isAdmin ||
+    p.permissions.has('roles.manage') ||
+    p.permissions.has('template.manage') ||
+    p.permissions.has('audit.read')
+  )
 }

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

@@ -28,6 +28,7 @@ function toMessage(error: unknown): string {
 const scope = z.union([
   z.object({ kind: z.literal('case'), caseNumber: z.string().min(1) }),
   z.object({ kind: z.literal('personnel'), fileId: z.string().min(1) }),
+  z.object({ kind: z.literal('department'), departmentId: z.string().min(1) }),
 ])
 
 const sendSchema = z.object({
@@ -114,7 +115,7 @@ export async function adoptAsEntryAction(input: unknown): Promise<ActionResult>
 }
 
 const readSchema = z.object({
-  scopeType: z.enum(['case', 'personnel']),
+  scopeType: z.enum(['case', 'personnel', 'department']),
   scopeId: z.string().min(1),
 })
 

web/app/(app)/layout.tsx

@@ -44,6 +44,7 @@ export default async function AppLayout({ children }: { children: React.ReactNod
             <Link href="/uebersicht">{de.nav.dashboard}</Link>
             <Link href="/faelle">{de.nav.cases}</Link>
             {darfPersonal ? <Link href="/personalakten">{de.nav.personnel}</Link> : null}
+            <Link href="/abteilungen">{de.nav.departments}</Link>
             {hasAdminAccess(user.permissions) ? (
               <Link href="/admin">{de.nav.admin}</Link>
             ) : null}

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

@@ -15,7 +15,8 @@ type File = {
   id: string
   displayName: string
   rank: string | null
-  department: string | null
+  departmentId: string | null
+  department: { id: string; key: string; name: string } | null
   statusTags: string[]
   note: string | null
   classification: number
@@ -34,11 +35,16 @@ export function PersonnelHead({
   canEdit,
   levels,
   statusTags,
+  departments,
 }: {
   file: File
   canEdit: boolean
   levels: { level: number; name: string }[]
   statusTags: { key: string; name: string; colorToken: string }[]
+  /** Die Abteilungen zur Auswahl. Freitext gibt es hier nicht mehr: sonst wäre
+      jede Schreibweise eine eigene Abteilung, und genau das war der Grund für
+      das Modell. */
+  departments: { id: string; key: string; name: string }[]
 }) {
   const [editing, setEditing] = useState(false)
   const [state, action, pending] = useActionState<ActionResult | null, FormData>(
@@ -51,7 +57,7 @@ export function PersonnelHead({
       <div>
         <dl className="grid gap-x-8 gap-y-2 text-sm sm:grid-cols-2">
           <Zeile label={personnelText.rank} value={file.rank} />
-          <Zeile label={personnelText.department} value={file.department} />
+          <Zeile label={personnelText.department} value={file.department?.name ?? null} />
           <Zeile
             label={personnelText.linkedAccount}
             value={file.userId ? file.userId : personnelText.noAccount}
@@ -100,7 +106,23 @@ export function PersonnelHead({
       <Feld id="displayName" label={personnelText.name} defaultValue={file.displayName} required />
       <div className="grid gap-4 sm:grid-cols-2">
         <Feld id="rank" label={personnelText.rank} defaultValue={file.rank} />
-        <Feld id="department" label={personnelText.department} defaultValue={file.department} />
+        <label className="block">
+          <span className="font-condensed text-2xs text-text-dim">
+            {personnelText.department}
+          </span>
+          <select
+            name="departmentId"
+            defaultValue={file.departmentId ?? ''}
+            className="field mt-1.5 w-full"
+          >
+            <option value="">{personnelText.noDepartment}</option>
+            {departments.map((abteilung) => (
+              <option key={abteilung.id} value={abteilung.id}>
+                {abteilung.name}
+              </option>
+            ))}
+          </select>
+        </label>
       </div>
 
       <fieldset>

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

@@ -14,6 +14,7 @@ import {
 import { listDocuments, listTemplatesFor } from '@/lib/documents/service'
 import { canWritePersonnel } from '@/lib/access/documentWrite'
 import { trackOpen } from '@/lib/recent/track'
+import { listDepartments } from '@/lib/departments/service'
 import { loadChatView } from '@/lib/chat/load'
 import { ChatLazy } from '@/components/chat/ChatLazy'
 import { de } from '@/lib/i18n/de'
@@ -218,9 +219,10 @@ export default async function PersonnelPage({ params }: { params: Promise<{ id:
 
   await trackOpen(user.id, 'PERSONNEL', akte.id)
 
-  const [levels, statusTags] = await Promise.all([
+  const [levels, statusTags, abteilungen] = await Promise.all([
     db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
     listStatusTags(),
+    listDepartments(user.permissions),
   ])
   const level = levels.find((l) => l.level === akte.classification)
   const canEdit = canWritePersonnel(user.permissions, akte.classification).ok
@@ -243,6 +245,7 @@ export default async function PersonnelPage({ params }: { params: Promise<{ id:
             canEdit={canEdit}
             levels={levels.filter((l) => l.level <= user.permissions.clearanceLevel)}
             statusTags={statusTags}
+            departments={abteilungen}
           />
         </div>
       </section>

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

@@ -32,7 +32,7 @@ function toMessage(error: unknown): string {
 const kopfdaten = {
   displayName: z.string().min(2).max(120),
   rank: z.string().max(60).optional(),
-  department: z.string().max(60).optional(),
+  departmentId: z.string().max(64).optional(),
   note: z.string().max(2000).optional(),
 }
 

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

@@ -16,11 +16,13 @@ export function NewPersonnelForm({
   members,
   levels,
   statusTags,
+  departments,
   defaultLevel,
 }: {
   members: { id: string; displayName: string }[]
   levels: { level: number; name: string }[]
   statusTags: { key: string; name: string }[]
+  departments: { id: string; key: string; name: string }[]
   defaultLevel: number
 }) {
   const [state, action, pending] = useActionState<ActionResult | null, FormData>(
@@ -53,7 +55,19 @@ export function NewPersonnelForm({
 
       <div className="grid gap-5 sm:grid-cols-2">
         <Feld id="rank" label={personnelText.rank} />
-        <Feld id="department" label={personnelText.department} />
+        <label className="block">
+          <span className="font-condensed text-2xs text-text-dim">
+            {personnelText.department}
+          </span>
+          <select name="departmentId" defaultValue="" className="field mt-1.5 w-full">
+            <option value="">{personnelText.noDepartment}</option>
+            {departments.map((abteilung) => (
+              <option key={abteilung.id} value={abteilung.id}>
+                {abteilung.name}
+              </option>
+            ))}
+          </select>
+        </label>
       </div>
 
       <fieldset>

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

@@ -2,6 +2,7 @@ import type { Metadata } from 'next'
 import { db } from '@/lib/db'
 import { requirePermission } from '@/lib/auth/current'
 import { listStatusTags } from '@/lib/personnel/service'
+import { listDepartments } from '@/lib/departments/service'
 import { de } from '@/lib/i18n/de'
 import { NewPersonnelForm } from './NewPersonnelForm'
 
@@ -11,7 +12,7 @@ export const dynamic = 'force-dynamic'
 export default async function NewPersonnelPage() {
   const user = await requirePermission('personnel.edit')
 
-  const [levels, members, statusTags] = await Promise.all([
+  const [levels, members, statusTags, abteilungen] = 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.
@@ -22,6 +23,7 @@ export default async function NewPersonnelPage() {
       select: { id: true, displayName: true },
     }),
     listStatusTags(),
+    listDepartments(user.permissions),
   ])
 
   return (
@@ -34,6 +36,7 @@ export default async function NewPersonnelPage() {
         members={members}
         levels={levels.filter((level) => level.level <= user.permissions.clearanceLevel)}
         statusTags={statusTags}
+        departments={abteilungen}
         defaultLevel={Math.min(1, user.permissions.clearanceLevel)}
       />
     </main>

web/app/api/stream/route.ts

@@ -3,6 +3,7 @@ import { db } from '@/lib/db'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visibleMessageWhere } from '@/lib/access/chatFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { visibleDepartmentWhere } from '@/lib/access/departmentFilter'
 import { visibleAttachmentWhere } from '@/lib/access/attachmentFilter'
 import { resolveCasePreviews, type CasePreview } from '@/lib/chat/preview'
 import { extractCaseNumbers, type ChatMessageView } from '@/lib/chat/view'
@@ -154,6 +155,19 @@ async function erlaubteThemen(user: CurrentUser, gewuenscht: string[]): Promise<
     themen.push(...sichtbar.map((akte) => `personnel:${akte.id}` as Topic))
   }
 
+  const abteilungIds = gewuenscht
+    .filter((t) => t.startsWith('department:'))
+    .map((t) => t.slice(11))
+    .filter(Boolean)
+
+  if (abteilungIds.length > 0) {
+    const sichtbar = await db.department.findMany({
+      where: { AND: [visibleDepartmentWhere(user.permissions), { id: { in: abteilungIds } }] },
+      select: { id: true },
+    })
+    themen.push(...sichtbar.map((abteilung) => `department:${abteilung.id}` as Topic))
+  }
+
   return themen
 }
 
@@ -168,7 +182,8 @@ async function nachliefern(
 ): Promise<void> {
   const fallIds = themen.filter((t) => t.startsWith('case:')).map((t) => t.slice(5))
   const personalIds = themen.filter((t) => t.startsWith('personnel:')).map((t) => t.slice(10))
-  if (fallIds.length === 0 && personalIds.length === 0) return
+  const abteilungIds = themen.filter((t) => t.startsWith('department:')).map((t) => t.slice(11))
+  if (fallIds.length === 0 && personalIds.length === 0 && abteilungIds.length === 0) return
 
   try {
     const verpasst = await db.chatMessage.findMany({
@@ -176,7 +191,13 @@ async function nachliefern(
         AND: [
           visibleMessageWhere(user.permissions),
           { id: { gt: seit } },
-          { OR: [{ caseId: { in: fallIds } }, { personnelFileId: { in: personalIds } }] },
+          {
+            OR: [
+              { caseId: { in: fallIds } },
+              { personnelFileId: { in: personalIds } },
+              { departmentId: { in: abteilungIds } },
+            ],
+          },
         ],
       },
       orderBy: { id: 'asc' },
@@ -204,6 +225,7 @@ const NACHRICHT = {
   createdAt: true,
   caseId: true,
   personnelFileId: true,
+  departmentId: true,
 } as const
 
 /**

web/components/PieChart.tsx

@@ -0,0 +1,127 @@
+/**
+ * Ein Kreisdiagramm.
+ *
+ * **Serverseitig gerendertes SVG, kein Skript.** Eine Diagrammbibliothek wäre
+ * hier das Teuerste auf der Seite; die Rechnung ist ein Dutzend Zeilen
+ * Trigonometrie, und das Ergebnis lädt ohne ein Byte JavaScript.
+ *
+ * Die Farben kommen **nicht** aus dem Stufensystem. Die sechs
+ * Klassifizierungsfarben sind das einzige Buntsystem der Anwendung und
+ * bedeuten dort etwas Bestimmtes; ein Tortenstück in Oxidrot würde als
+ * „streng geheim" gelesen. Die Segmente sind deshalb Abstufungen von
+ * `--steel`, von kräftig nach blass.
+ *
+ * Die Beschriftung steht daneben als Liste mit Zahlen, nicht nur als Farbe im
+ * Kreis: Farbe allein darf keine Angabe tragen, siehe docs/10-design-system.md.
+ * Damit ist das Diagramm der Schmuck und die Liste die Auskunft.
+ */
+export type Slice = { label: string; value: number }
+
+const GROESSE = 160
+const RADIUS = 70
+
+export function PieChart({
+  slices,
+  emptyLabel,
+  totalLabel,
+}: {
+  slices: Slice[]
+  emptyLabel: string
+  /** „12 Fälle" — steht in der Mitte und sagt, worauf sich die Anteile beziehen. */
+  totalLabel: (total: number) => string
+}) {
+  const gesamt = slices.reduce((summe, stueck) => summe + stueck.value, 0)
+  if (gesamt === 0) return <p className="text-text-dim">{emptyLabel}</p>
+
+  let begonnen = 0
+  const segmente = slices.map((stueck, index) => {
+    const anteil = stueck.value / gesamt
+    const start = begonnen
+    begonnen += anteil
+    return {
+      ...stueck,
+      anteil,
+      farbe: farbeFuer(index, slices.length),
+      pfad: kreisAusschnitt(start, begonnen),
+    }
+  })
+
+  return (
+    <div className="flex flex-wrap items-center gap-8">
+      <svg
+        width={GROESSE}
+        height={GROESSE}
+        viewBox={`0 0 ${GROESSE} ${GROESSE}`}
+        role="img"
+        aria-hidden
+        className="flex-none"
+      >
+        {segmente.length === 1 ? (
+          // Ein einziger Anteil ist ein voller Kreis. Als Pfad gezeichnet
+          // würde er zu einer Linie zusammenfallen.
+          <circle
+            cx={GROESSE / 2}
+            cy={GROESSE / 2}
+            r={RADIUS}
+            fill={segmente[0]!.farbe}
+            stroke="var(--color-surface)"
+          />
+        ) : (
+          segmente.map((segment) => (
+            <path
+              key={segment.label}
+              d={segment.pfad}
+              fill={segment.farbe}
+              stroke="var(--color-surface)"
+              strokeWidth={1}
+            />
+          ))
+        )}
+      </svg>
+
+      <dl className="min-w-0 grow space-y-1">
+        <div className="mb-2 font-condensed text-2xs text-text-dim">{totalLabel(gesamt)}</div>
+        {segmente.map((segment) => (
+          <div key={segment.label} className="flex items-baseline gap-3">
+            <span
+              aria-hidden
+              className="inline-block h-2.5 w-2.5 flex-none rounded-full"
+              style={{ backgroundColor: segment.farbe }}
+            />
+            <dt className="min-w-0 grow truncate text-sm">{segment.label}</dt>
+            <dd className="font-mono text-2xs text-text-dim">
+              {segment.value} · {Math.round(segment.anteil * 100)}%
+            </dd>
+          </div>
+        ))}
+      </dl>
+    </div>
+  )
+}
+
+/**
+ * Abstufungen von `--steel`, gleichmässig verteilt. Bei einem einzigen
+ * Segment die volle Farbe, sonst von kräftig nach blass — so bleibt die
+ * Reihenfolge der Liste auch im Kreis ablesbar.
+ */
+function farbeFuer(index: number, anzahl: number): string {
+  if (anzahl === 1) return 'var(--color-accent)'
+  const anteil = 100 - Math.round((index / (anzahl - 1)) * 65)
+  return `color-mix(in srgb, var(--color-accent) ${anteil}%, var(--color-panel))`
+}
+
+/** Ein Kreisausschnitt von `start` bis `ende`, beide als Anteil von 0 bis 1. */
+function kreisAusschnitt(start: number, ende: number): string {
+  const mitte = GROESSE / 2
+  const [x1, y1] = punkt(start)
+  const [x2, y2] = punkt(ende)
+  const grosserBogen = ende - start > 0.5 ? 1 : 0
+  return `M ${mitte} ${mitte} L ${x1} ${y1} A ${RADIUS} ${RADIUS} 0 ${grosserBogen} 1 ${x2} ${y2} Z`
+}
+
+function punkt(anteil: number): [number, number] {
+  // Bei zwölf Uhr anfangen, im Uhrzeigersinn.
+  const winkel = anteil * 2 * Math.PI - Math.PI / 2
+  const mitte = GROESSE / 2
+  return [mitte + RADIUS * Math.cos(winkel), mitte + RADIUS * Math.sin(winkel)]
+}

web/components/chat/Chat.tsx

@@ -20,6 +20,7 @@ import type { ChatMessageView } from '@/lib/chat/view'
 export type ChatScopeView =
   | { kind: 'case'; caseNumber: string; caseId: string }
   | { kind: 'personnel'; fileId: string }
+  | { kind: 'department'; departmentId: string }
 
 type Reaktion = { messageId: string; userId: string; key: string }
 
@@ -104,7 +105,12 @@ export function Chat({
   // Beim Verlassen der Seite die Lesemarke setzen, nicht beim Öffnen: sonst
   // wäre die Trennlinie beim Neuladen sofort weg.
   useEffect(() => {
-    const scopeId = scope.kind === 'case' ? scope.caseId : scope.fileId
+    const scopeId =
+      scope.kind === 'case'
+        ? scope.caseId
+        : scope.kind === 'personnel'
+          ? scope.fileId
+          : scope.departmentId
     return () => {
       void markReadAction({ scopeType: scope.kind, scopeId })
     }
@@ -139,7 +145,9 @@ export function Chat({
         scope:
           scope.kind === 'case'
             ? { kind: 'case', caseNumber: scope.caseNumber }
-            : { kind: 'personnel', fileId: scope.fileId },
+            : scope.kind === 'personnel'
+              ? { kind: 'personnel', fileId: scope.fileId }
+              : { kind: 'department', departmentId: scope.departmentId },
         body: inhalt,
         replyToId: optimistisch.replyToId,
       })

web/e2e/smoke.spec.ts

@@ -34,7 +34,11 @@ test.describe('Geschuetzte Bereiche', () => {
     '/personalakten',
     '/personalakten/neu',
     '/personalakten/irgendeine',
+    '/abteilungen',
+    '/abteilungen/SHD',
     '/admin',
+    '/admin/abteilungen',
+    '/admin/protokoll',
     '/suche',
     '/faelle/AfiS-2026-0001/export',
     '/faelle/AfiS-2026-0001/beteiligte',

web/lib/access/chatFilter.ts

@@ -2,6 +2,7 @@ import type { Prisma } from '@afis/db'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { visibleDepartmentWhere } from '@/lib/access/departmentFilter'
 
 /**
  * Chat: der formlose Teil, der **an einer Akte hängt**.
@@ -22,5 +23,7 @@ export function visibleMessageWhere(p: EffectivePermissions): Prisma.ChatMessage
     orte.push({ personnelFile: { is: visiblePersonnelWhere(p) } })
   }
 
+  orte.push({ department: { is: visibleDepartmentWhere(p) } })
+
   return { OR: orte }
 }

web/lib/access/departmentFilter.ts

@@ -0,0 +1,40 @@
+import type { Prisma } from '@afis/db'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Abteilungen, die ein Nutzer sehen darf.
+ *
+ * Anders als bei Akten gilt hier **nicht** „Existenz ist auch eine
+ * Information": dass es den Sicherheitsdienst gibt, weiss jeder im Haus, und
+ * eine Abteilung, die niemand findet, kann auch niemand einer Person zuordnen.
+ * Sie steht deshalb standardmässig auf Stufe 0.
+ *
+ * Die Stufe gibt es trotzdem, für den Fall, dass eine Abteilung selbst nicht
+ * allgemein bekannt sein soll. Und sie gilt dann für alles, was **an** der
+ * Abteilung hängt: ihre Vermerke und ihren Chat.
+ *
+ * Was in ihr aktenkundig ist, filtert dagegen weiterhin jede Liste für sich —
+ * die Mitglieder über `visiblePersonnelWhere`, die Fälle über
+ * `visibleCaseWhere`. Eine sichtbare Abteilung ist kein Zugang zu ihrem Inhalt.
+ */
+export function visibleDepartmentWhere(p: EffectivePermissions): Prisma.DepartmentWhereInput {
+  if (p.isAdmin) return {}
+  return { minClearance: { lte: p.clearanceLevel } }
+}
+
+/**
+ * Vermerke einer Abteilung: die Abteilung muss sichtbar sein **und** die
+ * Feldstufe des Vermerks darf die Stufe des Lesers nicht übersteigen. Derselbe
+ * Aufbau wie bei den Verlaufseinträgen einer Akte.
+ */
+export function visibleDepartmentEntryWhere(
+  p: EffectivePermissions,
+): Prisma.DepartmentEntryWhereInput {
+  if (p.isAdmin) return { department: { is: visibleDepartmentWhere(p) } }
+  return {
+    AND: [
+      { department: { is: visibleDepartmentWhere(p) } },
+      { minClearance: { lte: p.clearanceLevel } },
+    ],
+  }
+}

web/lib/audit/write.ts

@@ -44,6 +44,12 @@ export type AuditAction =
   | 'attachment.read'
   | 'attachment.release'
   | 'chat.adopt'
+  | 'department.create'
+  | 'department.update'
+  | 'department.assign'
+  | 'department.entry.create'
+  | 'department.entry.edit'
+  | 'department.entry.retract'
   | 'roles.update'
   | 'export.pdf'
   | 'export.approve'

web/lib/chat/load.ts

@@ -13,7 +13,7 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  */
 export async function loadChatView(p: EffectivePermissions, scope: ChatScope) {
   const { ort, nachrichten } = await listMessages(p, scope)
-  const scopeId = ort.caseId ?? ort.personnelFileId!
+  const scopeId = ort.caseId ?? ort.personnelFileId ?? ort.departmentId!
 
   const [autoren, vorschauen, reaktionen, lastReadAt, mitglieder] = await Promise.all([
     db.user.findMany({
@@ -22,7 +22,11 @@ export async function loadChatView(p: EffectivePermissions, scope: ChatScope) {
     }),
     resolveCasePreviews(p, nachrichten.flatMap((n) => extractCaseNumbers(n.body))),
     listReactions(p, nachrichten.map((n) => n.id)),
-    loadReadMarker(p, ort.caseId ? 'case' : 'personnel', scopeId),
+    loadReadMarker(
+      p,
+      ort.caseId ? 'case' : ort.personnelFileId ? 'personnel' : 'department',
+      scopeId,
+    ),
     // Für die Anzeige der Erwähnungen: Benutzername auf Anzeigename.
     db.user.findMany({
       where: { isActive: true },

web/lib/chat/service.ts

@@ -4,10 +4,17 @@ import { AccessError, must } from '@/lib/errors'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visibleMessageWhere } from '@/lib/access/chatFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { visibleDepartmentWhere } from '@/lib/access/departmentFilter'
 import { canEditCase } from '@/lib/access/caseWrite'
 import { extractMentionNames } from '@/lib/chat/mentions'
 import type { ReactionKey } from '@/lib/chat/terms'
-import { caseTopic, personnelTopic, publish, type Topic } from '@/lib/realtime/publish'
+import {
+  caseTopic,
+  departmentTopic,
+  personnelTopic,
+  publish,
+  type Topic,
+} from '@/lib/realtime/publish'
 import { enqueueCaseNotification, enqueuePersonnelNotification } from '@/lib/notify/enqueue'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
@@ -28,6 +35,7 @@ import type { Prisma } from '@afis/db'
 export type ChatScope =
   | { kind: 'case'; caseNumber: string }
   | { kind: 'personnel'; fileId: string }
+  | { kind: 'department'; departmentId: string }
 
 const NACHRICHT = {
   id: true,
@@ -41,6 +49,7 @@ const NACHRICHT = {
   createdAt: true,
   caseId: true,
   personnelFileId: true,
+  departmentId: true,
 } satisfies Prisma.ChatMessageSelect
 
 /**
@@ -51,7 +60,13 @@ const NACHRICHT = {
 export async function resolveScope(
   p: EffectivePermissions,
   scope: ChatScope,
-): Promise<{ caseId?: string; personnelFileId?: string; topic: Topic; label: string } | null> {
+): Promise<{
+  caseId?: string
+  personnelFileId?: string
+  departmentId?: string
+  topic: Topic
+  label: string
+} | null> {
   if (scope.kind === 'case') {
     const akte = await db.case.findFirst({
       where: { AND: [visibleCaseWhere(p), { caseNumber: scope.caseNumber }] },
@@ -60,6 +75,20 @@ export async function resolveScope(
     return akte ? { caseId: akte.id, topic: caseTopic(akte.id), label: akte.caseNumber } : null
   }
 
+  if (scope.kind === 'department') {
+    const abteilung = await db.department.findFirst({
+      where: { AND: [visibleDepartmentWhere(p), { id: scope.departmentId }] },
+      select: { id: true, key: true },
+    })
+    return abteilung
+      ? {
+          departmentId: abteilung.id,
+          topic: departmentTopic(abteilung.id),
+          label: abteilung.key,
+        }
+      : null
+  }
+
   // Personalakten setzen neben der Stufe ein eigenes Recht voraus.
   if (!p.isAdmin && !p.permissions.has('personnel.read')) return null
 
@@ -89,7 +118,9 @@ export async function listMessages(
 
   const wo: Prisma.ChatMessageWhereInput = ort.caseId
     ? { caseId: ort.caseId }
-    : { personnelFileId: ort.personnelFileId }
+    : ort.personnelFileId
+      ? { personnelFileId: ort.personnelFileId }
+      : { departmentId: ort.departmentId }
 
   const nachrichten = await db.chatMessage.findMany({
     where: { AND: [wo, ...(options.since ? [{ id: { gt: options.since } }] : [])] },
@@ -156,7 +187,11 @@ export async function sendMessage(
     const ziel = await db.chatMessage.findFirst({
       where: {
         id: input.replyToId,
-        ...(ort.caseId ? { caseId: ort.caseId } : { personnelFileId: ort.personnelFileId }),
+        ...(ort.caseId
+          ? { caseId: ort.caseId }
+          : ort.personnelFileId
+            ? { personnelFileId: ort.personnelFileId }
+            : { departmentId: ort.departmentId }),
       },
       select: { id: true },
     })
@@ -169,6 +204,7 @@ export async function sendMessage(
         id: input.id,
         caseId: ort.caseId ?? null,
         personnelFileId: ort.personnelFileId ?? null,
+        departmentId: ort.departmentId ?? null,
         authorId: p.userId,
         body: text,
         replyToId,
@@ -382,9 +418,14 @@ export async function adoptAsEntry(
   return { entryId }
 }
 
-function themaVon(nachricht: { caseId: string | null; personnelFileId: string | null }): Topic {
+function themaVon(nachricht: {
+  caseId: string | null
+  personnelFileId: string | null
+  departmentId: string | null
+}): Topic {
   if (nachricht.caseId) return caseTopic(nachricht.caseId)
-  return personnelTopic(nachricht.personnelFileId!)
+  if (nachricht.personnelFileId) return personnelTopic(nachricht.personnelFileId)
+  return departmentTopic(nachricht.departmentId!)
 }
 
 // ---------------------------------------------------------------------------
@@ -400,7 +441,7 @@ function themaVon(nachricht: { caseId: string | null; personnelFileId: string |
  */
 export async function loadReadMarker(
   p: EffectivePermissions,
-  scopeType: 'case' | 'personnel',
+  scopeType: 'case' | 'personnel' | 'department',
   scopeId: string,
 ): Promise<Date | null> {
   const marker = await db.readMarker.findUnique({
@@ -412,7 +453,7 @@ export async function loadReadMarker(
 
 export async function markRead(
   p: EffectivePermissions,
-  scopeType: 'case' | 'personnel',
+  scopeType: 'case' | 'personnel' | 'department',
   scopeId: string,
   at: Date = new Date(),
 ): Promise<void> {

web/lib/departments/entries.ts

@@ -0,0 +1,186 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit/write'
+import { AccessError } from '@/lib/errors'
+import {
+  visibleDepartmentEntryWhere,
+  visibleDepartmentWhere,
+} from '@/lib/access/departmentFilter'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Vermerke an einer Abteilung.
+ *
+ * Harte Regel 2 aus CLAUDE.md gilt hier genauso wie im Verlauf einer Akte:
+ * **es gibt kein Löschen.** Jede Änderung legt den vorherigen Stand als
+ * Version ab, jede Zurücknahme lässt einen Grabstein stehen, und beides sieht
+ * jeder, der den Vermerk sehen darf. Die Regeln stehen in der Datenbank
+ * (`dept_entry_no_delete`, `dept_entry_immutable_guard`) und nicht nur hier.
+ *
+ * Schmaler als der Aktenverlauf ist er trotzdem: keine Korrekturkette, keine
+ * Anhänge, keine Karenzzeit. Ein Abteilungsvermerk ist ein laufendes
+ * Protokoll, kein Beweismittel — die Ermittlung gehört in eine Fallakte.
+ */
+
+const AUSWAHL = {
+  id: true,
+  body: true,
+  minClearance: true,
+  authorId: true,
+  createdAt: true,
+  version: true,
+  editedAt: true,
+  editedById: true,
+  retractedAt: true,
+  retractedById: true,
+  retractionReason: true,
+} as const
+
+export async function listEntries(p: EffectivePermissions, departmentId: string, take = 50) {
+  return db.departmentEntry.findMany({
+    where: { AND: [visibleDepartmentEntryWhere(p), { departmentId }] },
+    orderBy: { createdAt: 'desc' },
+    take,
+    select: AUSWAHL,
+  })
+}
+
+/** Wer Vermerke schreiben darf. Dasselbe Recht wie für den Aktenverlauf. */
+function darfSchreiben(p: EffectivePermissions): boolean {
+  return p.isAdmin || p.permissions.has('entry.create')
+}
+
+export async function createEntry(
+  p: EffectivePermissions,
+  input: { id: string; departmentKey: string; body: string; minClearance: number },
+): Promise<{ id: string }> {
+  if (!darfSchreiben(p)) throw new AccessError('no-permission')
+
+  const abteilung = await db.department.findFirst({
+    where: { AND: [visibleDepartmentWhere(p), { key: input.departmentKey }] },
+    select: { id: true, key: true },
+  })
+  if (!abteilung) throw new AccessError('not-found')
+
+  const text = input.body.trim()
+  if (text.length === 0) throw new AccessError('entry-empty')
+
+  // Niemand schreibt über seiner eigenen Stufe: sonst legte man einen Vermerk
+  // an, den man selbst nicht mehr lesen kann. Dieselbe Regel wie bei Akten.
+  if (!p.isAdmin && input.minClearance > p.clearanceLevel) {
+    throw new AccessError('clearance-too-low')
+  }
+
+  // Dieselbe Kennung zweimal erzeugt keinen zweiten Vermerk.
+  const vorhanden = await db.departmentEntry.findUnique({
+    where: { id: input.id },
+    select: { id: true },
+  })
+  if (vorhanden) return vorhanden
+
+  await db.$transaction(async (tx) => {
+    await tx.departmentEntry.create({
+      data: {
+        id: input.id,
+        departmentId: abteilung.id,
+        body: text,
+        minClearance: input.minClearance,
+        authorId: p.userId,
+      },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.entry.create',
+      targetType: 'DepartmentEntry',
+      targetId: input.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { department: abteilung.key, minClearance: input.minClearance },
+    })
+  })
+
+  return { id: input.id }
+}
+
+/**
+ * Ändern. Der vorherige Stand wird zur Version — in derselben Transaktion,
+ * sonst gäbe es einen Moment, in dem der alte Text nirgends mehr steht.
+ */
+export async function editEntry(
+  p: EffectivePermissions,
+  input: { id: string; body: string },
+): Promise<void> {
+  const vermerk = await db.departmentEntry.findFirst({
+    where: { AND: [visibleDepartmentEntryWhere(p), { id: input.id }] },
+    select: { id: true, body: true, minClearance: true, authorId: true, version: true },
+  })
+  if (!vermerk) throw new AccessError('not-found')
+
+  const eigener = vermerk.authorId === p.userId
+  const darf =
+    p.isAdmin ||
+    (eigener && p.permissions.has('entry.edit_own')) ||
+    p.permissions.has('entry.edit_any')
+  if (!darf) throw new AccessError('no-permission')
+
+  const text = input.body.trim()
+  if (text.length === 0) throw new AccessError('entry-empty')
+  if (text === vermerk.body) return
+
+  await db.$transaction(async (tx) => {
+    await tx.departmentEntryVersion.create({
+      data: {
+        entryId: vermerk.id,
+        version: vermerk.version,
+        body: vermerk.body,
+        minClearance: vermerk.minClearance,
+        editedById: p.userId,
+      },
+    })
+    await tx.departmentEntry.update({
+      where: { id: vermerk.id },
+      data: { body: text, version: vermerk.version + 1, editedAt: new Date(), editedById: p.userId },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.entry.edit',
+      targetType: 'DepartmentEntry',
+      targetId: vermerk.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { version: vermerk.version + 1 },
+    })
+  })
+}
+
+/**
+ * Zurückziehen. Kein Löschen: der Vermerk bleibt als Grabstein stehen, mit
+ * Grund und Namen. Wer etwas anderes sagen will, schreibt einen neuen.
+ */
+export async function retractEntry(
+  p: EffectivePermissions,
+  input: { id: string; reason: string },
+): Promise<void> {
+  const vermerk = await db.departmentEntry.findFirst({
+    where: { AND: [visibleDepartmentEntryWhere(p), { id: input.id }] },
+    select: { id: true, retractedAt: true },
+  })
+  if (!vermerk) throw new AccessError('not-found')
+  if (!p.isAdmin && !p.permissions.has('entry.retract')) throw new AccessError('no-permission')
+  if (vermerk.retractedAt) return
+
+  const grund = input.reason.trim()
+  if (grund.length === 0) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.departmentEntry.update({
+      where: { id: vermerk.id },
+      data: { retractedAt: new Date(), retractedById: p.userId, retractionReason: grund },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.entry.retract',
+      targetType: 'DepartmentEntry',
+      targetId: vermerk.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { reason: grund },
+    })
+  })
+}

web/lib/departments/service.ts

@@ -0,0 +1,377 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit/write'
+import { AccessError } from '@/lib/errors'
+import { visibleDepartmentWhere } from '@/lib/access/departmentFilter'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
+import { canWritePersonnel } from '@/lib/access/documentWrite'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+import type { Prisma } from '@afis/db'
+
+/**
+ * Abteilungen — die Ebene über der Personalakte.
+ *
+ * Der Aufbau ist derselbe wie bei der Personalakte, nur eine Stufe höher: was
+ * zu einer Abteilung aktenkundig ist, **wird abgeleitet und nicht
+ * eingetragen**. Eine Fallakte trägt keine Abteilung; sie gehört zu einer,
+ * wenn eine beteiligte Person dieser Abteilung angehört.
+ *
+ * Das ist die wichtigste Festlegung hier. Eine eingetragene Abteilung an der
+ * Akte wäre schnell veraltet — Leute wechseln, Beteiligte kommen dazu — und
+ * niemand würde sie nachpflegen. Abgeleitet stimmt sie immer.
+ *
+ * Jede Abfrage läuft durch dieselben Sichtbarkeitsfragmente wie überall sonst.
+ * Eine sichtbare Abteilung ist kein Zugang zu ihrem Inhalt.
+ */
+
+export type DepartmentSummary = {
+  id: string
+  key: string
+  name: string
+  description: string | null
+  minClearance: number
+  isArchived: boolean
+  /** `null`, wenn der Fragende Personalakten gar nicht sehen darf. Nicht `0` —
+      eine Null wäre die Auskunft „hier ist niemand", und die steht ihm nicht zu. */
+  memberCount: number | null
+}
+
+/** Alle Abteilungen, die dieser Nutzer sehen darf. */
+export async function listDepartments(
+  p: EffectivePermissions,
+  options: { includeArchived?: boolean } = {},
+): Promise<DepartmentSummary[]> {
+  const abteilungen = await db.department.findMany({
+    where: {
+      AND: [
+        visibleDepartmentWhere(p),
+        ...(options.includeArchived ? [] : [{ isArchived: false }]),
+      ],
+    },
+    orderBy: { name: 'asc' },
+    select: {
+      id: true,
+      key: true,
+      name: true,
+      description: true,
+      minClearance: true,
+      isArchived: true,
+    },
+  })
+  if (abteilungen.length === 0) return []
+
+  // Die Mitgliederzahl zählt nur, was der Nutzer auch sehen dürfte — sonst
+  // verriete die Zahl, wie viele Personalakten über seiner Stufe liegen.
+  if (!darfPersonal(p)) {
+    return abteilungen.map((abteilung) => ({ ...abteilung, memberCount: null }))
+  }
+
+  const zaehler = await Promise.all(
+    abteilungen.map((abteilung) =>
+      db.personnelFile.count({
+        where: { AND: [visiblePersonnelWhere(p), { departmentId: abteilung.id }] },
+      }),
+    ),
+  )
+
+  return abteilungen.map((abteilung, i) => ({ ...abteilung, memberCount: zaehler[i]! }))
+}
+
+export async function loadVisibleDepartment(p: EffectivePermissions, key: string) {
+  return db.department.findFirst({
+    where: { AND: [visibleDepartmentWhere(p), { key }] },
+    select: {
+      id: true,
+      key: true,
+      name: true,
+      description: true,
+      minClearance: true,
+      isArchived: true,
+    },
+  })
+}
+
+function darfPersonal(p: EffectivePermissions): boolean {
+  return p.isAdmin || p.permissions.has('personnel.read')
+}
+
+/** Die Mitglieder einer Abteilung, gefiltert wie jede Personalaktenliste. */
+export async function listMembers(p: EffectivePermissions, departmentId: string) {
+  if (!darfPersonal(p)) return []
+  return db.personnelFile.findMany({
+    where: { AND: [visiblePersonnelWhere(p), { departmentId }] },
+    orderBy: { displayName: 'asc' },
+    select: {
+      id: true,
+      displayName: true,
+      rank: true,
+      statusTags: true,
+      classification: true,
+    },
+  })
+}
+
+/**
+ * Das Where-Fragment für „Fälle dieser Abteilung".
+ *
+ * Über die Beteiligten und deren Personalakten. Beide Richtungen zählen: ob
+ * jemand Ermittler oder Betroffener ist, ändert nichts daran, dass der Fall
+ * die Abteilung betrifft — für die Zugehörigkeit ist die Rolle unerheblich,
+ * für den Zugriff nicht (siehe lib/cases/terms.ts).
+ */
+function caseOfDepartment(departmentId: string): Prisma.CaseWhereInput {
+  return {
+    participants: { some: { personnelFile: { is: { departmentId } } } },
+  }
+}
+
+export async function listDepartmentCases(
+  p: EffectivePermissions,
+  departmentId: string,
+  take = 25,
+) {
+  return db.case.findMany({
+    where: { AND: [visibleCaseWhere(p), caseOfDepartment(departmentId)] },
+    orderBy: { updatedAt: 'desc' },
+    take,
+    select: {
+      id: true,
+      caseNumber: true,
+      title: true,
+      status: true,
+      templateKey: true,
+      classification: true,
+      updatedAt: true,
+    },
+  })
+}
+
+/**
+ * Dokumente der Abteilung — abgeleitet wie alles hier.
+ *
+ * Zwei Wege dorthin: das Dokument hängt an der Personalakte eines Mitglieds,
+ * oder an einer Fallakte, die diese Abteilung betrifft. Ein Dokument
+ * unmittelbar an der Abteilung gibt es nicht: die Vorlagen kennen über
+ * `TemplateUse` nur Fall- und Personalakte, und ein Besitzer, für den es keine
+ * Vorlage gibt, wäre ein Feld, das nichts füllen kann.
+ */
+export async function listDepartmentDocuments(
+  p: EffectivePermissions,
+  departmentId: string,
+  take = 25,
+) {
+  const gehoertDazu: Prisma.DocumentWhereInput = {
+    OR: [
+      { case: { is: caseOfDepartment(departmentId) } },
+      ...(darfPersonal(p)
+        ? [{ personnelFile: { is: { departmentId } } } as Prisma.DocumentWhereInput]
+        : []),
+    ],
+  }
+
+  return db.document.findMany({
+    where: { AND: [visibleDocumentWhere(p), gehoertDazu] },
+    orderBy: { updatedAt: 'desc' },
+    take,
+    select: {
+      id: true,
+      documentNumber: true,
+      title: true,
+      status: true,
+      classification: true,
+      updatedAt: true,
+    },
+  })
+}
+
+export type Slice = { label: string; value: number }
+
+/**
+ * Womit diese Abteilung aktenkundig ist, nach Fallart.
+ *
+ * Gezählt wird über **dieselbe** Bedingung wie die Liste. Ein Diagramm, das
+ * mehr Fälle zeigt als die Liste hergibt, wäre selbst eine Auskunft — genau
+ * wie ein Facettenzähler. Siehe harte Regel 6.
+ */
+export async function caseTypesOfDepartment(
+  p: EffectivePermissions,
+  departmentId: string,
+): Promise<Slice[]> {
+  const gruppen = await db.case.groupBy({
+    by: ['templateKey'],
+    where: { AND: [visibleCaseWhere(p), caseOfDepartment(departmentId)] },
+    _count: { _all: true },
+  })
+
+  return gruppen
+    .map((gruppe) => ({ label: gruppe.templateKey, value: gruppe._count._all }))
+    .sort((a, b) => b.value - a.value)
+}
+
+/**
+ * Die Gegenrichtung: welche Abteilung wie viele Fälle hat.
+ *
+ * Das ist die Frage, mit der die Übersicht der Abteilungen anfängt — wo häuft
+ * sich etwas. Auch hier zählt nur, was der Fragende sehen darf.
+ */
+export async function casesPerDepartment(p: EffectivePermissions): Promise<Slice[]> {
+  const abteilungen = await db.department.findMany({
+    where: { AND: [visibleDepartmentWhere(p), { isArchived: false }] },
+    select: { id: true, name: true },
+  })
+
+  const zahlen = await Promise.all(
+    abteilungen.map((abteilung) =>
+      db.case.count({
+        where: { AND: [visibleCaseWhere(p), caseOfDepartment(abteilung.id)] },
+      }),
+    ),
+  )
+
+  return abteilungen
+    .map((abteilung, i) => ({ label: abteilung.name, value: zahlen[i]! }))
+    .filter((eintrag) => eintrag.value > 0)
+    .sort((a, b) => b.value - a.value)
+}
+
+// ---------------------------------------------------------------------------
+// Verwaltung
+// ---------------------------------------------------------------------------
+
+function darfVerwalten(p: EffectivePermissions): boolean {
+  return p.isAdmin || p.permissions.has('roles.manage')
+}
+
+export async function createDepartment(
+  p: EffectivePermissions,
+  input: { key: string; name: string; description?: string | null; minClearance: number },
+): Promise<{ key: string }> {
+  if (!darfVerwalten(p)) throw new AccessError('no-permission')
+  // Eine Abteilung anzulegen, die man selbst nicht sieht, ergibt keinen Sinn —
+  // dieselbe Regel wie bei Akten und Dokumenten.
+  if (!p.isAdmin && input.minClearance > p.clearanceLevel) {
+    throw new AccessError('clearance-too-low')
+  }
+
+  const key = input.key.trim().toUpperCase()
+  if (!/^[A-Z0-9][A-Z0-9-]{0,20}$/.test(key)) throw new AccessError('department-key-invalid')
+
+  const name = input.name.trim()
+  if (name.length === 0) throw new AccessError('department-name-missing')
+
+  const vorhanden = await db.department.findUnique({ where: { key }, select: { id: true } })
+  if (vorhanden) throw new AccessError('department-key-taken')
+
+  const abteilung = await db.$transaction(async (tx) => {
+    const angelegt = await tx.department.create({
+      data: {
+        key,
+        name,
+        description: input.description?.trim() || null,
+        minClearance: input.minClearance,
+        createdById: p.userId,
+      },
+      select: { id: true, key: true },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.create',
+      targetType: 'Department',
+      targetId: angelegt.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { key, name },
+    })
+    return angelegt
+  })
+
+  return { key: abteilung.key }
+}
+
+export async function updateDepartment(
+  p: EffectivePermissions,
+  input: {
+    id: string
+    name: string
+    description?: string | null
+    minClearance: number
+    isArchived: boolean
+  },
+): Promise<void> {
+  if (!darfVerwalten(p)) throw new AccessError('no-permission')
+  if (!p.isAdmin && input.minClearance > p.clearanceLevel) {
+    throw new AccessError('clearance-too-low')
+  }
+
+  const abteilung = await db.department.findFirst({
+    where: { AND: [visibleDepartmentWhere(p), { id: input.id }] },
+    select: { id: true },
+  })
+  if (!abteilung) throw new AccessError('not-found')
+
+  const name = input.name.trim()
+  if (name.length === 0) throw new AccessError('department-name-missing')
+
+  await db.$transaction(async (tx) => {
+    await tx.department.update({
+      where: { id: input.id },
+      data: {
+        name,
+        description: input.description?.trim() || null,
+        minClearance: input.minClearance,
+        isArchived: input.isArchived,
+      },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.update',
+      targetType: 'Department',
+      targetId: input.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { name, minClearance: input.minClearance, isArchived: input.isArchived },
+    })
+  })
+}
+
+/**
+ * Eine Person einer Abteilung zuordnen — oder die Zuordnung aufheben.
+ *
+ * Setzt dasselbe Recht voraus wie das Ändern der Personalakte selbst: die
+ * Zugehörigkeit steht in der Akte, und wer sie nicht schreiben darf, darf auch
+ * das nicht.
+ */
+export async function assignToDepartment(
+  p: EffectivePermissions,
+  input: { personnelFileId: string; departmentId: string | null },
+): Promise<void> {
+  const akte = await db.personnelFile.findFirst({
+    where: { AND: [visiblePersonnelWhere(p), { id: input.personnelFileId }] },
+    select: { id: true, classification: true, departmentId: true },
+  })
+  if (!akte || !darfPersonal(p)) throw new AccessError('not-found')
+
+  const erlaubt = canWritePersonnel(p, akte.classification)
+  if (!erlaubt.ok) throw new AccessError(erlaubt.reason)
+
+  if (input.departmentId) {
+    const ziel = await db.department.findFirst({
+      where: { AND: [visibleDepartmentWhere(p), { id: input.departmentId, isArchived: false }] },
+      select: { id: true },
+    })
+    if (!ziel) throw new AccessError('not-found')
+  }
+
+  await db.$transaction(async (tx) => {
+    await tx.personnelFile.update({
+      where: { id: akte.id },
+      data: { departmentId: input.departmentId },
+    })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'department.assign',
+      targetType: 'PersonnelFile',
+      targetId: akte.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: akte.departmentId, to: input.departmentId },
+    })
+  })
+}

web/lib/i18n/admin.ts

@@ -50,6 +50,12 @@ export const auditText = {
     'attachment.read': 'Datei abgerufen',
     'attachment.release': 'Datei freigegeben',
     'chat.adopt': 'Nachricht als Vermerk übernommen',
+    'department.create': 'Abteilung angelegt',
+    'department.update': 'Abteilung geändert',
+    'department.assign': 'Abteilung zugeordnet',
+    'department.entry.create': 'Abteilungsvermerk angelegt',
+    'department.entry.edit': 'Abteilungsvermerk geändert',
+    'department.entry.retract': 'Abteilungsvermerk zurückgezogen',
     'roles.update': 'Rollenzuordnung geändert',
     'export.pdf': 'PDF erzeugt',
     'export.approve': 'Export freigegeben',
@@ -70,6 +76,8 @@ export const auditText = {
     RoleMapping: 'Rollenzuordnung',
     ChangePolicy: 'Änderungsrichtlinie',
     Database: 'Datenbank',
+    Department: 'Abteilung',
+    DepartmentEntry: 'Abteilungsvermerk',
   } as Record<string, string>,
 } as const
 
@@ -78,6 +86,7 @@ export const adminText = {
   intro: 'Rollen, Vorlagen, Regeln und das Protokoll der Abteilung.',
   sections: {
     roles: 'Rollen',
+    departments: 'Abteilungen',
     templates: 'Vorlagen',
     policy: 'Änderungsrichtlinie',
     log: 'Protokoll',
@@ -85,6 +94,7 @@ export const adminText = {
   } as Record<string, string>,
   descriptions: {
     roles: 'Welche Discord-Rolle welche Freigabestufe und welche Rechte trägt.',
+    departments: 'Die Abteilungen der Foundation. Zugeordnet wird in der Personalakte.',
     templates: 'Aufbau der Fallakten und Dokumente, Bausteine und Fassungen.',
     policy: 'Ob und wie lange Verlaufseinträge nachträglich geändert werden dürfen.',
     log: 'Wer was wo getan hat. Vollständig und nicht änderbar.',

web/lib/i18n/common.ts

@@ -27,6 +27,10 @@ export const commonText = {
  */
 export const actionErrorsText = {
   'not-found': 'Die Akte gibt es nicht, oder du darfst sie nicht sehen.',
+  'department-key-invalid':
+    'Kürzel: Grossbuchstaben, Ziffern und Bindestrich, höchstens 21 Zeichen.',
+  'department-key-taken': 'Dieses Kürzel gibt es schon.',
+  'department-name-missing': 'Die Abteilung braucht einen Namen.',
   'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
   'no-permission': 'Dir fehlt das nötige Recht.',
   'read-only': 'Der Datensatz ist schreibgeschützt.',
@@ -40,6 +44,7 @@ export const actionErrorsText = {
   'participant-target': 'Entweder ein Discord-Konto oder eine Personalakte, nicht beides.',
   'link-self': 'Eine Akte lässt sich nicht mit sich selbst verknüpfen.',
   'message-empty': 'Die Nachricht ist leer.',
+  'entry-empty': 'Der Vermerk ist leer.',
   'message-too-long': 'Die Nachricht ist länger als 4000 Zeichen.',
   'message-withdrawn': 'Die Nachricht wurde zurückgezogen.',
   'adopt-needs-case': 'Nur eine Nachricht aus einem Aktenchat wird zum Vermerk.',

web/lib/i18n/de.ts

@@ -41,6 +41,11 @@ import { chatText } from '@/lib/i18n/chat'
 import { personnelText, assignmentText } from '@/lib/i18n/people'
 import { documentText, attachmentText } from '@/lib/i18n/documents'
 import { exportText } from '@/lib/i18n/export'
+import {
+  departmentText,
+  departmentAdminText,
+  departmentEntryText,
+} from '@/lib/i18n/departments'
 import {
   adminText,
   auditText,
@@ -70,6 +75,9 @@ export const de = {
   document: documentText,
   attachment: attachmentText,
   export: exportText,
+  department: departmentText,
+  departmentAdmin: departmentAdminText,
+  departmentEntry: departmentEntryText,
   common: commonText,
   actionErrors: actionErrorsText,
   errors: errorsText,

web/lib/i18n/departments.ts

@@ -0,0 +1,69 @@
+/**
+ * Abteilungen. Die Bezeichnungen der Abteilungen selbst stehen **nicht** hier:
+ * das sind Daten, im Adminbereich änderbar, so wie die Namen der
+ * Freigabestufen. Siehe CLAUDE.md, Sprachkonvention.
+ */
+export const departmentText = {
+  heading: 'Abteilungen',
+  one: 'Abteilung',
+  intro: 'Was zu einer Abteilung aktenkundig ist, ergibt sich aus ihren Mitgliedern.',
+  empty: 'Noch keine Abteilung. Die Abteilungsleitung legt sie im Adminbereich an.',
+  members: 'Mitglieder',
+  membersEmpty: 'Dieser Abteilung ist niemand zugeordnet.',
+  memberCount: (n: number) => (n === 1 ? '1 Mitglied' : `${n} Mitglieder`),
+  cases: 'Fallakten',
+  casesEmpty: 'Zu dieser Abteilung ist keine Fallakte offen einsehbar.',
+  documents: 'Dokumente',
+  documentsEmpty: 'Kein Dokument zu dieser Abteilung.',
+  entries: 'Vermerke',
+  entriesEmpty: 'Noch kein Vermerk. Ersten Vermerk schreiben.',
+  chart: 'Fallarten',
+  chartAll: 'Fälle je Abteilung',
+  chartEmpty: 'Noch keine Fallakte, aus der sich etwas ablesen liesse.',
+  chartTotal: (n: number) => (n === 1 ? '1 Fallakte' : `${n} Fallakten`),
+  minClearance: 'Mindeststufe',
+  archived: 'Archiviert',
+  derivedHint:
+    'Eine Fallakte gehört zu dieser Abteilung, wenn eine beteiligte Person ihr angehört. Die Zuordnung wird nicht eingetragen, sondern ergibt sich — damit stimmt sie auch, wenn sich die Beteiligten ändern.',
+} as const
+
+export const departmentAdminText = {
+  heading: 'Abteilungen',
+  intro:
+    'Die Abteilungen der Foundation. Personen werden in ihrer Personalakte zugeordnet.',
+  create: 'Abteilung anlegen',
+  createTitle: 'Neue Abteilung',
+  key: 'Kürzel',
+  keyHint: 'Grossbuchstaben, Ziffern und Bindestrich. Steht später in der Adresse.',
+  name: 'Name',
+  description: 'Beschreibung',
+  minClearance: 'Mindeststufe',
+  minClearanceHint: 'Wer diese Stufe nicht hat, sieht die Abteilung nicht.',
+  archived: 'Archiviert',
+  archivedHint: 'Archivierte Abteilungen stehen nicht mehr zur Auswahl.',
+  save: 'Abteilung speichern',
+  edit: 'Ändern',
+  cancel: 'Abbrechen',
+  saved: 'Abteilung gespeichert',
+  created: 'Abteilung angelegt',
+  empty: 'Noch keine Abteilung angelegt.',
+  members: 'Mitglieder',
+} as const
+
+export const departmentEntryText = {
+  heading: 'Vermerke',
+  add: 'Vermerk schreiben',
+  body: 'Vermerk',
+  save: 'Vermerk speichern',
+  saving: 'Wird gespeichert',
+  edit: 'Ändern',
+  editSave: 'Änderung speichern',
+  cancel: 'Abbrechen',
+  retract: 'Zurückziehen',
+  retractReason: 'Grund der Zurücknahme',
+  retracted: 'Zurückgezogen',
+  retractedBy: (wer: string, grund: string) => `Zurückgezogen von ${wer}: ${grund}`,
+  edited: (v: number) => `geändert, Fassung ${v}`,
+  minClearance: 'Sichtbar ab Stufe',
+  hint: 'Vermerke lassen sich ändern und zurückziehen, aber nie unsichtbar machen: jede Fassung bleibt, jede Zurücknahme hinterlässt einen Grabstein.',
+} as const

web/lib/i18n/people.ts

@@ -17,6 +17,7 @@ export const personnelText = {
   name: 'Name',
   rank: 'Dienstgrad',
   department: 'Abteilung',
+  noDepartment: 'Keine Abteilung',
   status: 'Status',
   statusHint: 'Mehrere möglich. „Gekündigt" und „Verhaftet" schließen einander nicht aus.',
   statusNone: 'Kein Status gesetzt',

web/lib/i18n/shell.ts

@@ -20,6 +20,7 @@ export const navText = {
   dashboard: 'Übersicht',
   cases: 'Fallakten',
   personnel: 'Personalakten',
+  departments: 'Abteilungen',
   search: 'Suche',
   admin: 'Admin',
   skipToContent: 'Zum Inhalt springen',
@@ -180,6 +181,7 @@ export const paletteText = {
     { href: '/faelle', label: 'Fallakten' },
     { href: '/faelle/neu', label: 'Neue Fallakte' },
     { href: '/personalakten', label: 'Personalakten' },
+    { href: '/abteilungen', label: 'Abteilungen' },
     { href: '/suche', label: 'Suche' },
     { href: '/admin', label: 'Admin' },
     { href: '/admin/protokoll', label: 'Protokoll' },

web/lib/personnel/service.ts

@@ -21,7 +21,8 @@ const KOPFDATEN = {
   userId: true,
   displayName: true,
   rank: true,
-  department: true,
+  departmentId: true,
+  department: { select: { id: true, key: true, name: true } },
   statusTags: true,
   note: true,
   classification: true,
@@ -57,7 +58,8 @@ export async function listPersonnelFiles(
               OR: [
                 { displayName: { contains: begriff, mode: 'insensitive' as const } },
                 { rank: { contains: begriff, mode: 'insensitive' as const } },
-                { department: { contains: begriff, mode: 'insensitive' as const } },
+                { department: { is: { name: { contains: begriff, mode: 'insensitive' as const } } } },
+                { department: { is: { key: { contains: begriff, mode: 'insensitive' as const } } } },
               ],
             },
           ]
@@ -84,7 +86,7 @@ export async function createPersonnelFile(
     displayName: string
     userId?: string | null
     rank?: string | null
-    department?: string | null
+    departmentId?: string | null
     statusTags?: string[]
     note?: string | null
     classification: number
@@ -101,7 +103,7 @@ export async function createPersonnelFile(
         displayName: name,
         userId: input.userId || null,
         rank: input.rank?.trim() || null,
-        department: input.department?.trim() || null,
+        departmentId: input.departmentId || null,
         statusTags: await gueltigeStatusEtiketten(input.statusTags),
         note: input.note?.trim() || null,
         classification: input.classification,
@@ -130,7 +132,7 @@ export async function updatePersonnelFile(
   input: {
     displayName?: string
     rank?: string | null
-    department?: string | null
+    departmentId?: string | null
     statusTags?: string[]
     note?: string | null
   },
@@ -148,8 +150,8 @@ export async function updatePersonnelFile(
       data: {
         ...(name !== undefined ? { displayName: name } : {}),
         ...(input.rank !== undefined ? { rank: input.rank?.trim() || null } : {}),
-        ...(input.department !== undefined
+        ...(input.departmentId !== undefined
-          ? { department: input.department?.trim() || null }
+          ? { departmentId: input.departmentId || null }
           : {}),
         ...(input.statusTags !== undefined
           ? { statusTags: await gueltigeStatusEtiketten(input.statusTags) }

web/lib/realtime/publish.ts

@@ -29,7 +29,11 @@ export type EventKind =
   | 'export.ready'
 
 /** Wer das Ereignis angeht. */
-export type Topic = `case:${string}` | `personnel:${string}` | `user:${string}`
+export type Topic =
+  | `case:${string}`
+  | `personnel:${string}`
+  | `department:${string}`
+  | `user:${string}`
 
 export function caseTopic(caseId: string): Topic {
   return `case:${caseId}`
@@ -37,6 +41,9 @@ export function caseTopic(caseId: string): Topic {
 export function personnelTopic(fileId: string): Topic {
   return `personnel:${fileId}`
 }
+export function departmentTopic(departmentId: string): Topic {
+  return `department:${departmentId}`
+}
 export function userTopic(userId: string): Topic {
   return `user:${userId}`
 }

web/tests/abteilungen.test.ts

@@ -0,0 +1,290 @@
+// @vitest-environment node
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { db } from '@/lib/db'
+import {
+  assignToDepartment,
+  caseTypesOfDepartment,
+  casesPerDepartment,
+  listDepartmentCases,
+  listDepartments,
+  listMembers,
+} from '@/lib/departments/service'
+import { createEntry, editEntry, listEntries, retractEntry } from '@/lib/departments/entries'
+import { AccessError } from '@/lib/errors'
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+/**
+ * Die Abteilung ist die Ebene über der Personalakte, und sie fasst zusammen,
+ * was einzeln bereits geschützt ist. Genau darin liegt die Gefahr: eine
+ * Zusammenfassung, die nicht filtert, verrät mehr als jede Einzelansicht.
+ * Geprüft wird deshalb jede Liste und jede Zahl gegen einen zu niedrig
+ * eingestuften Leser.
+ */
+const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
+const suite = url ? describe : describe.skip
+
+const marke = `abt-${Date.now()}`
+
+function perms(
+  userId: string,
+  clearanceLevel: number,
+  options: { isAdmin?: boolean; permissions?: Permission[] } = {},
+): EffectivePermissions {
+  return {
+    userId,
+    clearanceLevel,
+    permissions: new Set<Permission>(options.permissions ?? []),
+    isAdmin: options.isAdmin ?? false,
+    hasMembership: true,
+  }
+}
+
+suite('Abteilungen', () => {
+  const nutzer = { stufe1: `${marke}-s1`, stufe4: `${marke}-s4` }
+  let abteilungId = ''
+  let abteilungKey = ''
+  let geheimeAbteilungKey = ''
+  let personOffenId = ''
+  let personGeheimId = ''
+  let offenId = ''
+  let geheimId = ''
+
+  beforeAll(async () => {
+    for (const id of Object.values(nutzer)) {
+      await db.user.create({ data: { id, username: id, displayName: id } })
+    }
+    const vorlage = await db.documentTemplate.create({
+      data: { key: `${marke}-vorlage`, version: 1, name: 'Korruption', fields: [] },
+    })
+    const vorlage2 = await db.documentTemplate.create({
+      data: { key: `${marke}-bussgeld`, version: 1, name: 'Bussgeld', fields: [] },
+    })
+
+    const abteilung = await db.department.create({
+      data: { key: `${marke}-SHD`.slice(0, 21).toUpperCase(), name: 'Sicherheitsdienst' },
+    })
+    abteilungId = abteilung.id
+    abteilungKey = abteilung.key
+
+    const geheim = await db.department.create({
+      data: { key: `${marke}-GEH`.slice(0, 21).toUpperCase(), name: 'Verdeckt', minClearance: 4 },
+    })
+    geheimeAbteilungKey = geheim.key
+
+    // Zwei Mitglieder: eines für jeden sichtbar, eines auf Stufe 4.
+    const offenePerson = await db.personnelFile.create({
+      data: {
+        displayName: `${marke} Offene Person`,
+        classification: 1,
+        departmentId: abteilung.id,
+      },
+    })
+    const geheimePerson = await db.personnelFile.create({
+      data: {
+        displayName: `${marke} Geheime Person`,
+        classification: 4,
+        departmentId: abteilung.id,
+      },
+    })
+    personOffenId = offenePerson.id
+    personGeheimId = geheimePerson.id
+
+    const gemeinsam = { createdById: nutzer.stufe4 }
+    const offen = await db.case.create({
+      data: {
+        ...gemeinsam,
+        templateId: vorlage.id,
+        templateKey: vorlage.key,
+        caseNumber: `Abt-2026-${Date.now().toString(36)}o`,
+        title: 'Offener Vorgang',
+        classification: 1,
+        status: 'OPEN',
+      },
+    })
+    const geheimerFall = await db.case.create({
+      data: {
+        ...gemeinsam,
+        templateId: vorlage2.id,
+        templateKey: vorlage2.key,
+        caseNumber: `Abt-2026-${Date.now().toString(36)}g`,
+        title: 'Streng vertraulich',
+        classification: 4,
+        status: 'OPEN',
+      },
+    })
+    offenId = offen.id
+    geheimId = geheimerFall.id
+
+    // Beide Fälle hängen über eine Person an der Abteilung.
+    await db.caseParticipant.create({
+      data: { caseId: offen.id, personnelFileId: offenePerson.id, role: 'SUBJECT' },
+    })
+    await db.caseParticipant.create({
+      data: { caseId: geheimerFall.id, personnelFileId: offenePerson.id, role: 'SUSPECT' },
+    })
+  })
+
+  afterAll(async () => {
+    await db.$disconnect()
+  })
+
+  it('verbirgt eine Abteilung über der eigenen Stufe', async () => {
+    const niedrig = await listDepartments(perms(nutzer.stufe1, 1))
+    expect(niedrig.map((a) => a.key)).not.toContain(geheimeAbteilungKey)
+
+    const hoch = await listDepartments(perms(nutzer.stufe4, 4))
+    expect(hoch.map((a) => a.key)).toContain(geheimeAbteilungKey)
+  })
+
+  it('zählt als Mitglieder nur, was der Fragende sehen darf', async () => {
+    const mitRecht = (stufe: number) =>
+      listDepartments(perms(nutzer.stufe1, stufe, { permissions: ['personnel.read'] }))
+
+    const niedrig = (await mitRecht(1)).find((a) => a.key === abteilungKey)
+    const hoch = (await mitRecht(4)).find((a) => a.key === abteilungKey)
+
+    // Sonst verriete die Zahl, wie viele Personalakten über seiner Stufe liegen.
+    expect(niedrig?.memberCount).toBe(1)
+    expect(hoch?.memberCount).toBe(2)
+
+    // Ohne das Recht auf Personalakten steht dort keine Zahl, auch keine Null:
+    // eine Null wäre die Auskunft „hier ist niemand".
+    const ohneRecht = await listDepartments(perms(nutzer.stufe4, 4))
+    expect(ohneRecht.find((a) => a.key === abteilungKey)?.memberCount).toBeNull()
+  })
+
+  it('zeigt Mitglieder nur mit dem Recht auf Personalakten', async () => {
+    const ohneRecht = await listMembers(perms(nutzer.stufe4, 4), abteilungId)
+    expect(ohneRecht).toHaveLength(0)
+
+    const mitRecht = await listMembers(
+      perms(nutzer.stufe4, 4, { permissions: ['personnel.read'] }),
+      abteilungId,
+    )
+    expect(mitRecht.map((m) => m.id)).toEqual(
+      expect.arrayContaining([personOffenId, personGeheimId]),
+    )
+  })
+
+  it('hält eine zu hoch eingestufte Akte aus Liste und Diagramm heraus', async () => {
+    const niedrig = perms(nutzer.stufe1, 1)
+
+    const liste = await listDepartmentCases(niedrig, abteilungId)
+    expect(liste.map((a) => a.id)).toContain(offenId)
+    expect(liste.map((a) => a.id)).not.toContain(geheimId)
+
+    // Und die Zahl im Diagramm stimmt mit der Liste überein — ein Zähler, der
+    // mehr zählt als die Liste zeigt, wäre selbst eine Auskunft.
+    const verteilung = await caseTypesOfDepartment(niedrig, abteilungId)
+    const summe = verteilung.reduce((s, stueck) => s + stueck.value, 0)
+    expect(summe).toBe(liste.length)
+    expect(verteilung.map((s) => s.label)).not.toContain(`${marke}-bussgeld`)
+
+    // Stufe 4 sieht beide.
+    const hoch = await caseTypesOfDepartment(perms(nutzer.stufe4, 4), abteilungId)
+    expect(hoch.reduce((s, stueck) => s + stueck.value, 0)).toBe(2)
+  })
+
+  it('zählt auch über Abteilungen hinweg nur Sichtbares', async () => {
+    const niedrig = await casesPerDepartment(perms(nutzer.stufe1, 1))
+    const eintrag = niedrig.find((s) => s.label === 'Sicherheitsdienst')
+    expect(eintrag?.value).toBe(1)
+
+    const hoch = await casesPerDepartment(perms(nutzer.stufe4, 4))
+    expect(hoch.find((s) => s.label === 'Sicherheitsdienst')?.value).toBe(2)
+  })
+
+  it('lässt nur zuordnen, wer die Personalakte auch ändern darf', async () => {
+    await expect(
+      assignToDepartment(perms(nutzer.stufe1, 1, { permissions: ['personnel.read'] }), {
+        personnelFileId: personOffenId,
+        departmentId: abteilungId,
+      }),
+    ).rejects.toThrow(AccessError)
+
+    await assignToDepartment(
+      perms(nutzer.stufe4, 4, { permissions: ['personnel.read', 'personnel.edit'] }),
+      { personnelFileId: personOffenId, departmentId: null },
+    )
+    const danach = await db.personnelFile.findUniqueOrThrow({ where: { id: personOffenId } })
+    expect(danach.departmentId).toBeNull()
+
+    // Wieder zurück, damit die übrigen Prüfungen ihre Grundlage behalten.
+    await assignToDepartment(
+      perms(nutzer.stufe4, 4, { permissions: ['personnel.read', 'personnel.edit'] }),
+      { personnelFileId: personOffenId, departmentId: abteilungId },
+    )
+  })
+
+  describe('Vermerke', () => {
+    const schreiber = () =>
+      perms(nutzer.stufe4, 4, {
+        permissions: ['entry.create', 'entry.edit_own', 'entry.retract'],
+      })
+
+    it('verbirgt einen Vermerk über der Stufe des Lesers', async () => {
+      const id = `${marke}-v1`
+      await createEntry(schreiber(), {
+        id,
+        departmentKey: abteilungKey,
+        body: 'Nur für die Leitung',
+        minClearance: 4,
+      })
+
+      const niedrig = await listEntries(perms(nutzer.stufe1, 1), abteilungId)
+      expect(niedrig.map((v) => v.id)).not.toContain(id)
+
+      const hoch = await listEntries(perms(nutzer.stufe4, 4), abteilungId)
+      expect(hoch.map((v) => v.id)).toContain(id)
+    })
+
+    it('lässt niemanden über seiner eigenen Stufe schreiben', async () => {
+      await expect(
+        createEntry(perms(nutzer.stufe1, 1, { permissions: ['entry.create'] }), {
+          id: `${marke}-v2`,
+          departmentKey: abteilungKey,
+          body: 'Zu hoch gegriffen',
+          minClearance: 4,
+        }),
+      ).rejects.toThrow(AccessError)
+    })
+
+    it('bewahrt bei einer Änderung den vorherigen Stand', async () => {
+      const id = `${marke}-v3`
+      await createEntry(schreiber(), {
+        id,
+        departmentKey: abteilungKey,
+        body: 'Erster Stand',
+        minClearance: 0,
+      })
+      await editEntry(schreiber(), { id, body: 'Zweiter Stand' })
+
+      const fassungen = await db.departmentEntryVersion.findMany({ where: { entryId: id } })
+      expect(fassungen).toHaveLength(1)
+      expect(fassungen[0]?.body).toBe('Erster Stand')
+
+      const jetzt = await db.departmentEntry.findUniqueOrThrow({ where: { id } })
+      expect(jetzt.body).toBe('Zweiter Stand')
+      expect(jetzt.version).toBe(2)
+    })
+
+    it('lässt beim Zurückziehen einen Grabstein stehen', async () => {
+      const id = `${marke}-v4`
+      await createEntry(schreiber(), {
+        id,
+        departmentKey: abteilungKey,
+        body: 'Wird zurückgezogen',
+        minClearance: 0,
+      })
+      await retractEntry(schreiber(), { id, reason: 'Verwechslung mit einem anderen Vorgang' })
+
+      const danach = await db.departmentEntry.findUniqueOrThrow({ where: { id } })
+      expect(danach.retractedAt).not.toBeNull()
+      expect(danach.retractionReason).toContain('Verwechslung')
+
+      // Und er ist weiterhin da: es gibt kein Löschen.
+      await db.departmentEntry.deleteMany({ where: { id } })
+      expect(await db.departmentEntry.findUnique({ where: { id } })).not.toBeNull()
+    })
+  })
+})