Phase 1: Anmeldung, Rechte und Rollenverwaltung

Auth.js übernimmt nur den OAuth-Ablauf mit state und PKCE, Scope identify. Das
Zugangstoken des Nutzers wird danach verworfen: die Rollen holt der Bot mit
seinem eigenen Token. Die Sitzung steht in der Datenbank, im Cookie liegt nur
userId und sessionId. Ohne die Zeile in Session ist das Cookie wertlos, und nur
so lässt sich eine Sitzung zurückziehen.

Wer sich anmelden darf, steckt in lib/auth/signInPolicy.ts statt im Callback:
das ist die Regel, an der alles hängt, und sie gehört einzeln prüfbar. Kein
Guild-Mitglied, kein Zugang. Keine Rolle mit grantsMembership, kein Zugang.
Notfall-Admins umgehen die Rolle, aber nicht die Guild-Mitgliedschaft.

RoleMapping trägt jetzt grantsMembership, category und isPresent. Der Worker
spiegelt jede Rolle der Guild hierher, damit im Adminbereich nichts von Hand
eingetragen werden muss. Gelöschte Rollen werden nicht entfernt, sondern auf
isPresent = false gesetzt: beim Umzug auf den echten Server bleiben sie als
Vorlage stehen.

Der Worker gleicht über Gateway-Ereignisse und zusätzlich alle fünf Minuten
voll ab. Verliert jemand seine AfiS-Rolle, beendet er dessen Sitzungen sofort
und setzt isActive auf false - der Datensatz bleibt, damit Autorenangaben in
alten Akten gültig bleiben. Das passiert im Worker und nicht in der Web-App,
weil es dort erst beim nächsten Request des Betroffenen griffe.

Zwei Widersprüche der Dokumente aufgelöst, festgehalten in
docs/13-entscheidungen.md: der Ausschluss schlägt auch den Admin (das
Codebeispiel in 03-auth-und-rechte.md übergeht ihn, die Reihenfolge eine Zeile
darüber nicht), und versiegelte Akten fallen im Where-Fragment heraus statt in
einer Prüfung danach.

45 Tests, davon die Negativfälle aus docs/03 gegen eine echte Datenbank: Stufe 2
sieht die Stufe-4-Akte nicht und findet sie auch nicht in der Trefferzahl, ein
Ausgeschlossener mit Stufe 5 kommt nicht heran, ein Rollenentzug beendet die
Sitzungen, und ein Ausfall der Discord-API sieht nicht aus wie eine verweigerte
Mitgliedschaft.

web/lib/auth/current.ts

@@ -0,0 +1,94 @@
+import { notFound, redirect } from 'next/navigation'
+import { auth } from '@/auth'
+import { db } from '@/lib/db'
+import { loadSession } from '@/lib/auth/session'
+import { resolvePermissions } from '@/lib/auth/effective'
+import { ensureListening } from '@/lib/realtime/listener'
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+export type CurrentUser = {
+  id: string
+  displayName: string
+  username: string
+  avatarHash: string | null
+  sessionId: string
+  permissions: EffectivePermissions
+}
+
+/**
+ * Der angemeldete Nutzer für genau diesen Request, oder `null`.
+ *
+ * Drei Prüfungen, alle serverseitig:
+ *  1. Das Cookie trägt eine gültige Signatur (Auth.js)
+ *  2. Die Sitzungszeile existiert noch und ist nicht abgelaufen
+ *  3. Der Nutzer trägt weiterhin eine Rolle, die zur Anmeldung berechtigt
+ *
+ * Schritt 3 ist doppelt gemoppelt — der Worker beendet Sitzungen beim
+ * Rollenverlust bereits von sich aus — aber genau das ist der Sinn: fällt der
+ * Worker aus, verliert trotzdem niemand unbemerkt seinen Ausschluss.
+ */
+export async function getCurrentUser(): Promise<CurrentUser | null> {
+  const token = await auth()
+  const sessionId = (token as { sessionId?: string } | null)?.sessionId
+  if (!sessionId) return null
+
+  // Der LISTEN-Client wird beim ersten Request des Prozesses aufgebaut.
+  await ensureListening()
+
+  const session = await loadSession(sessionId)
+  if (!session) return null
+
+  const user = await db.user.findUnique({
+    where: { id: session.userId },
+    select: { id: true, displayName: true, username: true, avatarHash: true, isActive: true },
+  })
+  if (!user || !user.isActive) return null
+
+  const permissions = await resolvePermissions(session.userId)
+  if (!permissions.hasMembership && !permissions.isAdmin) return null
+
+  return {
+    id: user.id,
+    displayName: user.displayName,
+    username: user.username,
+    avatarHash: user.avatarHash,
+    sessionId: session.id,
+    permissions,
+  }
+}
+
+/** Für Seiten, die eine Anmeldung voraussetzen. */
+export async function requireUser(): Promise<CurrentUser> {
+  const user = await getCurrentUser()
+  if (!user) redirect('/anmelden')
+  return user
+}
+
+/**
+ * Für Seiten und Aktionen, die ein Recht voraussetzen.
+ *
+ * Fehlt das Recht, gibt es 404 statt 403. Existenz ist auch eine Information:
+ * aus einem 403 liesse sich ablesen, dass es die Seite gibt.
+ * Siehe docs/03-auth-und-rechte.md.
+ */
+export async function requirePermission(permission: Permission): Promise<CurrentUser> {
+  const user = await requireUser()
+  if (!user.permissions.isAdmin && !user.permissions.permissions.has(permission)) {
+    notFound()
+  }
+  return user
+}
+
+/**
+ * Für Server Actions: wirft, statt umzuleiten. Jede Server Action prüft die
+ * Berechtigung erneut, egal was die Oberfläche vorher versteckt hat.
+ * Siehe docs/07-dateien-und-sicherheit.md.
+ */
+export async function requirePermissionForAction(permission: Permission): Promise<CurrentUser> {
+  const user = await getCurrentUser()
+  if (!user) throw new Error('Nicht angemeldet')
+  if (!user.permissions.isAdmin && !user.permissions.permissions.has(permission)) {
+    throw new Error('Keine Berechtigung')
+  }
+  return user
+}