feat(legal): FKS-Quellenangabe, Auslandtransfer-Doku, Journal-Warnung, Region-Fix (v1.9.1)

Compliance-Runde 2 (ohne Doppelstrukturen; baut auf v1.7–v1.9 auf):

FKS/FEUKOS (dokumentierte schriftliche Genehmigung 17.02.2026):
- legal.ts: fksAttribution (exakte Quellenangabe, Genehmigungsdatum, Nutzungshinweis) + operatorType
- Neue Seite /quellen-und-lizenzen (+ Footer/Sitemap-Link)
- FKS-Abschnitt in Nutzungsbedingungen (§10a); Quellenangabe im Symbol-Panel und in PDF/PNG-Export
- Terminologie entschärft: "offizielle FKS/BABS-Signaturen" -> "FEUKOS-Symbole der FKS"
  (keine Partnerschaft/Zertifizierung/Empfehlung suggeriert)
- FKS_ATTRIBUTION als Dokumenttyp (Migration-Seed, LegalDocumentType), Kontexte erweitert
- licenses-and-attributions.md aktualisiert; .gitignore: private-legal-evidence/

Datenschutz/Transparenz:
- [REGION]-Platzhalter in der Subprozessorenliste durch öffentlich bekannte Firmensitze ersetzt
  (keine Platzhalter mehr öffentlich sichtbar)
- Journal-Freitext-Warnung (keine schutzwürdigen Daten)

Docs: current-state-audit, international-data-transfers, backup-and-restore,
privacy-risk-assessment, manual-action-checklist

Tests: Krypto-Round-Trip (crypto-secret); legal-config-Test aktualisiert; 17 grün. tsc+build ok.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.env.example

@@ -32,3 +32,17 @@ NODE_ENV=development
 # Gitea Registry Login für Watchtower (automatische Image-Updates)
 GITEA_REGISTRY_USER=adminpepe
 GITEA_REGISTRY_PASS=dein_gitea_token_oder_passwort
+
+# --- Backup (automatischer DB- + Datei-Backup-Container) ---
+# Aufbewahrungsdauer in Tagen (muss zur Datenschutzerklaerung passen)
+BACKUP_RETENTION_DAYS=30
+# Intervall in Stunden (24 = taeglich)
+BACKUP_INTERVAL_HOURS=24
+
+# --- GUI-Backup (SFTP/Nextcloud, verschluesselt) ---
+# Noetig fuer den automatischen Zeitplan (interner Scheduler ruft /api/cron/backup):
+CRON_SECRET=langer-zufaelliger-wert-min-32-zeichen
+# Optional: eigener Schluessel zum Verschluesseln der gespeicherten Zugangsdaten
+# (Default: NEXTAUTH_SECRET). Wenn gesetzt, NICHT mehr aendern (sonst sind gespeicherte
+# Zugangsdaten/Passphrase nicht mehr entschluesselbar):
+# BACKUP_ENC_KEY=eigener-langer-schluessel

.gitignore

@@ -65,3 +65,6 @@ Reglement_*/
 
 # Stack env (contains secrets)
 stack.env
+
+# Private rechtliche Nachweise (NICHT committen: z.B. FKS-Freigabe-E-Mail)
+private-legal-evidence/

Dockerfile

@@ -28,7 +28,8 @@ RUN --mount=type=cache,target=/app/.next/cache npm run build
 
 # Stage 3: Runner
 FROM node:20-alpine AS runner
-RUN apk add --no-cache openssl
+# openssl (Prisma) + postgresql16-client (pg_dump/pg_restore für GUI-Backup, passend zu postgres:16)
+RUN apk add --no-cache openssl postgresql16-client
 
 ENV NODE_ENV=production
 ENV NEXT_TELEMETRY_DISABLED=1
@@ -44,7 +45,7 @@ USER nextjs
 
 # Install only the unbundled runtime deps needed by the custom server.
 # Running as USER nextjs means files are already correctly owned — no slow chown -R needed afterwards.
-RUN npm install --omit=dev --legacy-peer-deps socket.io@4.7.4 @react-pdf/renderer@4.3.2 qrcode@1.5.4 --no-save
+RUN npm install --omit=dev --legacy-peer-deps socket.io@4.7.4 @react-pdf/renderer@4.3.2 qrcode@1.5.4 ssh2-sftp-client@12.1.1 webdav@5.10.0 archiver@8.0.0 --no-save
 
 COPY --chown=nextjs:nodejs --from=builder /app/.next/standalone ./
 COPY --chown=nextjs:nodejs --from=builder /app/.next/static ./.next/static

ROADMAP.md

@@ -74,6 +74,40 @@ Legende Aufwand: 🟢 klein · 🟡 mittel · 🔴 gross
 - Offen (später): Berechnungsparameter pro Mandant, mehrere Leitungen/Pumpenkette,
   Elevation-Proxy mit Cache, Ergebnis als speicherbares Lageplan-Objekt.
 
+## Zusatz – Modul-Baukasten (Einsatz-Cockpit) ✅ v1.5.0
+
+- [x] Journal-Monolith zerlegt: SOMA + Pendenzen als eigenständige Module,
+  gemeinsame Typen, Karten-Hülle (`ModuleCard`)
+- [x] Modul-Registry (`src/lib/modules.ts`) + Konfiguration pro Mandant
+  (`tenants.modulesConfig`), API `GET/PUT /api/tenant/modules`
+- [x] „Module verwalten"-Dialog: an/aus, Reihenfolge, eigene Module erstellen
+- [x] Generisches Tabellen-Modul (Spaltentypen Text/Haken/Zeit) mit eigener
+  Daten-API (`module_items`), Live-Sync über journal-refresh
+- [x] Vorlagen: Checkliste, Atemschutz-Überwachung, Kräfte vor Ort,
+  Lagemeldungen, leeres Modul
+- Offen (später): Übungs-Cockpit auf denselben Baukasten umstellen,
+  Modul-Daten in Rapport-PDF übernehmen
+
+## Zusatz – Offline-Karten ✅ v1.5.1
+
+- [x] Kacheln des Einsatzgebiets werden beim Öffnen eines Einsatzes automatisch
+  vorgeladen (Zoom 13–18, ~800 m Radius, max. 400 Kacheln, Parallelität 6)
+- [x] Nutzt exakt das MapLibre-Subdomain-Schema `(x+y) % 3` → Cache-Keys passen
+- [x] Bereits gecachte Kacheln werden übersprungen; Marker pro Einsatz (14 Tage)
+- [x] SW cachte Kacheln schon Cache-First — jetzt auch nie besuchte Bereiche da
+- Offen (später): Satellit/Swisstopo vorladen, grösserer Radius wählbar
+
+## Zusatz – Krokier-Lagebild ✅ v1.6.0
+
+- [x] **Nordpfeil** als Karten-Overlay, dreht mit dem Bearing mit
+- [x] **Windrichtung** (8 Richtungen) setzbar, am Projekt gespeichert
+  (`Project.windDirection`), als Windrose mit Drift-Pfeil angezeigt
+- [x] **Export als Dokument**: Nordpfeil + Massstabsbalken + Windanzeige werden
+  in PNG & PDF eingebrannt; PDF zusätzlich mit **Symbol-Legende** (Namen aus
+  /api/icons) und bestehender Kopfzeile (Einsatz/Ort/Zeit/Nr)
+- Offen (später): Absperr-/Gefahrenkreis mit Meter-Eingabe, Einheiten
+  beschriften + Favoriten-Leiste, normgerechte taktische Zeichen
+
 ## Phase 5 – Kür
 
 - [x] **5.1 – Linien-Typ-Abfrage** 🟡 ✅

deploy/portainer-stack.yml

@@ -86,11 +86,57 @@ services:
     networks:
       - lageplan-net
 
+  # --- Automatisches Backup: täglicher DB-Dump + Datei-Backup (30 Tage) ---
+  # Backups im Volume "backups_data". Für Off-Site auf einen NAS-Pfad umstellen, z.B.:
+  #   volumes: - /volume1/backups/lageplan:/backups
+  backup:
+    image: postgres:16-alpine
+    restart: unless-stopped
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      PGHOST: db
+      PGUSER: ${POSTGRES_USER}
+      PGPASSWORD: ${POSTGRES_PASSWORD}
+      PGDATABASE: ${POSTGRES_DB}
+      BACKUP_RETENTION_DAYS: ${BACKUP_RETENTION_DAYS:-30}
+      BACKUP_INTERVAL_HOURS: ${BACKUP_INTERVAL_HOURS:-24}
+    volumes:
+      - backups_data:/backups
+      - minio_data:/minio:ro
+    networks:
+      - lageplan-net
+    entrypoint:
+      - /bin/sh
+      - -c
+      - |
+        echo "[backup] Start - alle $${BACKUP_INTERVAL_HOURS}h, Aufbewahrung $${BACKUP_RETENTION_DAYS} Tage";
+        while true; do
+          TS=$$(date +%Y-%m-%d_%H%M%S);
+          mkdir -p /backups;
+          echo "[backup] $$TS Datenbank sichern...";
+          if pg_dump -h "$$PGHOST" -U "$$PGUSER" -d "$$PGDATABASE" -Fc -f "/backups/db_$$TS.dump"; then
+            echo "[backup] DB ok: db_$$TS.dump";
+          else
+            echo "[backup] DB FEHLGESCHLAGEN"; rm -f "/backups/db_$$TS.dump";
+          fi;
+          if [ -d /minio ]; then
+            tar czf "/backups/files_$$TS.tar.gz" -C /minio . 2>/dev/null && echo "[backup] Dateien ok: files_$$TS.tar.gz" || echo "[backup] Dateien uebersprungen";
+          fi;
+          find /backups -name "db_*.dump" -mtime +$$BACKUP_RETENTION_DAYS -delete 2>/dev/null || true;
+          find /backups -name "files_*.tar.gz" -mtime +$$BACKUP_RETENTION_DAYS -delete 2>/dev/null || true;
+          echo "[backup] fertig - naechstes in $${BACKUP_INTERVAL_HOURS}h";
+          sleep $$(( BACKUP_INTERVAL_HOURS * 3600 ));
+        done
+
 volumes:
   postgres_data:
     driver: local
   minio_data:
     driver: local
+  backups_data:
+    driver: local
 
 networks:
   lageplan-net:

docker-compose.yml

@@ -84,6 +84,49 @@ services:
     volumes:
       - ./prisma:/app/prisma
 
+  # Automatisches Backup: täglicher Postgres-Dump + Datei-Backup (MinIO), 30 Tage Aufbewahrung.
+  # Backups liegen im Volume "backups_data" (für Off-Site: unten auf einen Host-Pfad umstellen).
+  backup:
+    image: postgres:16-alpine
+    container_name: lageplan-backup
+    restart: unless-stopped
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      PGHOST: db
+      PGUSER: ${POSTGRES_USER:-lageplan}
+      PGPASSWORD: ${POSTGRES_PASSWORD:-lageplan_secret}
+      PGDATABASE: ${POSTGRES_DB:-lageplan}
+      BACKUP_RETENTION_DAYS: ${BACKUP_RETENTION_DAYS:-30}
+      BACKUP_INTERVAL_HOURS: ${BACKUP_INTERVAL_HOURS:-24}
+    volumes:
+      - backups_data:/backups
+      - minio_data:/minio:ro
+    entrypoint:
+      - /bin/sh
+      - -c
+      - |
+        echo "[backup] Start - alle $${BACKUP_INTERVAL_HOURS}h, Aufbewahrung $${BACKUP_RETENTION_DAYS} Tage";
+        while true; do
+          TS=$$(date +%Y-%m-%d_%H%M%S);
+          mkdir -p /backups;
+          echo "[backup] $$TS Datenbank sichern...";
+          if pg_dump -h "$$PGHOST" -U "$$PGUSER" -d "$$PGDATABASE" -Fc -f "/backups/db_$$TS.dump"; then
+            echo "[backup] DB ok: db_$$TS.dump";
+          else
+            echo "[backup] DB FEHLGESCHLAGEN"; rm -f "/backups/db_$$TS.dump";
+          fi;
+          if [ -d /minio ]; then
+            tar czf "/backups/files_$$TS.tar.gz" -C /minio . 2>/dev/null && echo "[backup] Dateien ok: files_$$TS.tar.gz" || echo "[backup] Dateien uebersprungen";
+          fi;
+          find /backups -name "db_*.dump" -mtime +$$BACKUP_RETENTION_DAYS -delete 2>/dev/null || true;
+          find /backups -name "files_*.tar.gz" -mtime +$$BACKUP_RETENTION_DAYS -delete 2>/dev/null || true;
+          echo "[backup] fertig - naechstes in $${BACKUP_INTERVAL_HOURS}h";
+          sleep $$(( BACKUP_INTERVAL_HOURS * 3600 ));
+        done
+
 volumes:
   postgres_data:
   minio_data:
+  backups_data:

docs/BACKUP.md

@@ -0,0 +1,115 @@
+# Backup & Restore — Lageplan
+
+Automatisches Backup als eigener Container (`backup`). Sichert **täglich**:
+- **Datenbank** (PostgreSQL) → `db_<zeitstempel>.dump` (pg_dump, custom/komprimiert)
+- **Hochgeladene Dateien** (MinIO: Pläne, Logos, Symbole) → `files_<zeitstempel>.tar.gz`
+
+**Aufbewahrung:** 30 Tage (ältere werden automatisch gelöscht) — passt zur Datenschutzerklärung.
+Einstellbar über `BACKUP_RETENTION_DAYS` und `BACKUP_INTERVAL_HOURS` (siehe `.env.example`).
+
+Die Backups liegen im Docker-Volume **`backups_data`** (Pfad im Container: `/backups`).
+
+---
+
+## Einrichtung
+
+Der `backup`-Service ist in `docker-compose.yml` und `deploy/portainer-stack.yml` enthalten.
+Nach dem nächsten Stack-Update (Portainer: Stack neu deployen) läuft er automatisch.
+
+Prüfen, dass er läuft und sichert:
+```
+docker logs lageplan-backup            # oder: docker compose logs backup
+docker compose exec backup ls -lh /backups
+```
+Beim ersten Start wird sofort ein Backup erstellt, danach alle 24 h.
+
+### Empfehlung: Backups aus dem Container heraus auf den NAS legen (Off-Site)
+Standardmässig liegen die Backups in einem Docker-Volume. Damit sie ausserhalb von Docker
+(z. B. auf einer NAS-Freigabe, die du separat sicherst) landen, im Stack den `backup`-Service auf
+einen **Host-Pfad** umstellen:
+```yaml
+    volumes:
+      - /volume1/backups/lageplan:/backups   # statt backups_data:/backups
+      - minio_data:/minio:ro
+```
+So kannst du die Dateien einfach kopieren/auf ein anderes Medium spiegeln. **Wichtig:** Ein Backup
+auf demselben Gerät wie die Daten schützt nicht vor Geräteausfall/Diebstahl — kopiere die Backups
+regelmässig an einen zweiten Ort.
+
+---
+
+## Wiederherstellen (Restore)
+
+> **Destruktiv.** Vorher die Web-App stoppen (`docker stop lageplan-web`) und sicherstellen, dass
+> niemand arbeitet.
+
+### 1) Datenbank
+```
+# Verfügbare Dumps anzeigen
+docker compose exec backup ls -lh /backups
+
+# Wiederherstellen (Dateiname einsetzen)
+docker compose exec backup pg_restore --clean --if-exists --no-owner \
+  -h db -U <POSTGRES_USER> -d <POSTGRES_DB> /backups/db_2026-07-23_030000.dump
+```
+
+### 2) Dateien (Uploads/MinIO)
+Da `/minio` im backup-Container schreibgeschützt ist, den Tarball in einen Container mit
+Schreibzugriff auf das MinIO-Volume entpacken:
+```
+docker run --rm -v minio_data:/data -v backups_data:/backups alpine \
+  sh -c "tar xzf /backups/files_2026-07-23_030000.tar.gz -C /data"
+```
+Danach Web-App wieder starten: `docker start lageplan-web`.
+
+---
+
+## Restore-Test (mindestens 1× durchführen und hier notieren)
+
+Ein Backup ist erst dann ein Backup, wenn ein Restore nachweislich funktioniert.
+Empfehlung: **halbjährlich** auf einer Testumgebung durchspielen.
+
+| Datum | Getestet von | Ergebnis | Bemerkung |
+|-------|--------------|----------|-----------|
+|       |              |          |           |
+
+---
+
+## Was ist NICHT im Backup?
+- Zahlungsdaten liegen bei Stripe (nicht in der App).
+- E-Mails liegen beim SMTP-Anbieter.
+- Secrets (`NEXTAUTH_SECRET`, MinIO-Keys) — separat sicher aufbewahren (Passwort-Manager),
+  sie stehen nicht in den Backups.
+
+---
+
+# GUI-Backup (verschlüsselt, extern: SFTP / Nextcloud)
+
+Zusätzlich zum lokalen Container-Backup gibt es ein **über die Oberfläche konfigurierbares**,
+verschlüsseltes Off-Site-Backup. Als **SERVER_ADMIN**: **Administration → Backup**.
+
+- **Ziele:** SFTP oder Nextcloud (WebDAV).
+- **Verschlüsselung:** AES-256-GCM mit einer **Passphrase** (im Passwort-Manager aufbewahren —
+  ohne sie ist kein Restore möglich). Zugangsdaten werden verschlüsselt in der DB gespeichert.
+- **Zeitplan:** aus / täglich / wöchentlich + Aufbewahrung in Tagen (prunt alte Backups am Ziel).
+- **Ablauf:** Speichern → **Verbindung testen** → **Jetzt sichern**. Der automatische Lauf braucht
+  `CRON_SECRET` (siehe `.env.example`); der interne Scheduler prüft stündlich die Fälligkeit.
+
+Hochgeladen wird eine Datei `lageplan_<zeitstempel>.tar.gz.enc` (enthält `database.dump` + `files/`).
+
+## Restore eines GUI-Backups
+```
+# 1) Datei vom Ziel herunterladen, dann entschlüsseln (Passphrase bereithalten):
+node scripts/decrypt-backup.js lageplan_2026-07-23-03-00-00.tar.gz.enc backup.tar.gz "DEINE-PASSPHRASE"
+
+# 2) Entpacken
+tar xzf backup.tar.gz          # -> database.dump + files/
+
+# 3) Datenbank wiederherstellen (destruktiv, App vorher stoppen)
+docker cp database.dump lageplan-db:/tmp/database.dump
+docker exec lageplan-db pg_restore --clean --if-exists --no-owner -U <POSTGRES_USER> -d <POSTGRES_DB> /tmp/database.dump
+
+# 4) Dateien zurück in MinIO (Ordner files/ in den Bucket)
+docker run --rm -v minio_data:/data -v "$PWD/files":/src alpine sh -c "cp -r /src/* /data/<MINIO_BUCKET>/ 2>/dev/null || true"
+```
+Danach App wieder starten. **Restore einmal testen** (Tabelle oben ausfüllen).

docs/TESTPLAN.md

@@ -0,0 +1,49 @@
+# Handy-/Einsatz-Testplan
+
+Kurzer, strukturierter Durchlauf nach jedem grösseren Deploy — am besten einmal
+am **Handy** und einmal am **Desktop**. Abhaken, was funktioniert.
+
+## 1. Einsatz anlegen
+- [ ] 🔥 **Neu → Neuer Einsatz**: Dialog öffnet, Standort wird automatisch als Ort vorgeschlagen
+- [ ] Titel eingeben → **Erstellen** → Karte startet am Einsatzort
+- [ ] Kopfzeile zeigt den Einsatz mittig (Status-Punkt rot, Nr, Titel, Ort), Uhr rechts
+
+## 2. Karte & Symbole (der wichtige Handy-Test)
+- [ ] Symbol **antippen** → Hinweis erscheint → **auf Karte tippen** platziert es
+- [ ] Mehrere gleiche Symbole nacheinander setzen → Zähler steigt → **Fertig**
+- [ ] Symbol antippen (auf der Karte) → drehen/skalieren/löschen
+- [ ] Zeichnen: Pfeil/Linie ziehen → Dialog fragt **Normal / Leitung / Rettungsachse**
+- [ ] Eigene **GPS-Position** sichtbar (Punkt + Genauigkeit), Karte bleibt am Einsatzort
+- [ ] **Vollbild-Button** (oben links) blendet die Browser-Leiste aus
+
+## 3. Auto-Bearbeitung
+- [ ] Ohne „Bearbeitung starten" direkt zeichnen können (Lock wird automatisch übernommen)
+- [ ] Zweites Gerät/Person: sieht Änderungen live, Karte ist dort gesperrt
+- [ ] Statuszeile zeigt „Sie bearbeiten" + **freigeben**
+
+## 4. Cockpit-Module (Baukasten)
+- [ ] Journal-Tab → **Module** (als Admin): Modul an/aus, Reihenfolge, eigenes Modul erstellen
+- [ ] Neues Modul (z.B. Atemschutz) erscheint im Cockpit, Zeilen anlegen/haken/löschen
+- [ ] Änderungen live auf zweitem Gerät sichtbar
+
+## 5. Journal & Rapport
+- [ ] Journal-Eintrag erfassen (mit Vorschlags-Leiste), Erledigt-Haken, Korrektur
+- [ ] SOMA/Pendenzen bedienen
+- [ ] **Rapport** erzeugen → PDF enthält Journal, SOMA, Pendenzen **und die eigenen Module**
+- [ ] Rapport per E-Mail / Drucken
+
+## 6. Übung
+- [ ] 🎓 **Neu → Neue Übung** → Übungs-Cockpit mit Zielen + Auswertung
+- [ ] Übungsziele mit Status (Erreicht/Teilweise/…), Auswertung speichert automatisch
+- [ ] Eigene Module erscheinen auch in der Übung
+
+## 7. Offline
+- [ ] Einsatz öffnen → Toast „Karte offline verfügbar" abwarten
+- [ ] Flugmodus an → Karte im Einsatzgebiet bleibt sichtbar, zeichnen möglich
+- [ ] Flugmodus aus → Änderungen werden synchronisiert (Statuszeile „Offline" verschwindet)
+
+## 8. Beenden
+- [ ] **Einsatz beenden** (Kopfzeile/Menü) → In-App-Bestätigung → gespeichert & geschlossen
+
+---
+_Bei Problemen: betroffenen Schritt notieren + ggf. Screenshot, dann gezielt fixen._

docs/legal/IMPLEMENTATION-REPORT.md

@@ -0,0 +1,83 @@
+# Compliance-Umsetzung — Abschlussbericht
+
+Stand: 2026-07-23 · Versionen 1.7.0 – 1.7.4 · sorgfältiger Entwurf, ersetzt keine juristische Prüfung.
+
+## A. Zusammenfassung
+- **Analyse**: 4 parallele Analysen (Legal/Claims, Dienstleister, Auth/Modelle/Admin, Export/Security/Cookies).
+- **Claims**: 20 werbliche/absolute Aussagen korrigiert (24/7, 100 %, DSG/DSGVO-konform, „keine Weitergabe",
+  „keine Übermittlung ins Ausland", „verschlüsselt"→„gehasht", 100 % der Spende, „Kein Unternehmen").
+- **Transparenz**: zentrale Legal-Config, neue Rechtsseiten, faktenbasierte Datenschutzerklärung mit
+  echter Subprozessorenliste.
+- **Consent**: revisionssichere Zustimmungsprotokollierung (LegalDocument/LegalAcceptance), Registrierung
+  mit getrennten Zustimmungen, blockierender Re-Consent-Dialog, Organisationsbestätigung (7 Pflicht-Checks),
+  Admin-Übersicht mit CSV-Export, Konto-Datenschutzseite.
+- **Risikoreduktion**: Export-Prüfhinweise (PDF/PNG), Dashboard-Hinweis, Berechnungs-/Geodaten-Hinweis,
+  private Routen `noindex`/`no-store`.
+
+## B. Geänderte/neue Dateien (Auszug)
+| Datei | Zweck | Änderung |
+|---|---|---|
+| src/config/legal.ts | Zentrale Rechtskonfiguration | NEU |
+| src/components/legal/legal-page.tsx | Shell für Rechtsseiten + Footer-Links | NEU |
+| src/app/nutzungsbedingungen/… | Nutzungsbedingungen | NEU |
+| src/app/verantwortungsvolle-nutzung/… | Verantwortungsvolle Nutzung | NEU |
+| src/app/sicherheit/… | Sicherheit | NEU |
+| src/app/unterstuetzen/… | Freiwilliger Unterstützungsbeitrag | NEU |
+| src/app/organisationen/datenschutzvereinbarung/… | AVV-Entwurf | NEU |
+| src/app/datenschutz/page.tsx | Datenschutzerklärung | NEUAUFBAU |
+| src/app/impressum/page.tsx | Impressum | Claims korrigiert |
+| src/app/page.tsx, spenden/…, admin/settings-tab | Landing/Spenden/Admin | Claims korrigiert |
+| prisma/schema.prisma, prisma/migrate.js | LegalDocument/LegalAcceptance + Seeding | Erweitert |
+| src/lib/legal.ts, legal-rules.ts, legal-content.ts | Consent-Logik | NEU |
+| src/app/api/legal/*, api/admin/legal/* | Consent-/Admin-APIs | NEU |
+| src/components/legal/legal-consent-gate.tsx | Re-Consent/Org-Bestätigung | NEU |
+| src/app/konto/datenschutz/… , src/app/admin/legal/… | Konto- & Admin-Ansicht | NEU |
+| src/app/register/page.tsx, api/auth/register | Zustimmung bei Registrierung | Erweitert |
+| src/hooks/use-map-export.ts | Export-Prüfhinweis | Erweitert |
+| src/components/legal/usage-notice-banner.tsx | Dashboard-Hinweis | NEU |
+| src/components/map/measure-panel.tsx | Berechnungs-Hinweis | Erweitert |
+| src/middleware.ts | noindex/no-store, /konto, /api/share | Erweitert |
+| src/app/sitemap.ts | neue Seiten | Erweitert |
+| docs/legal/*.md | Audit, Inventar, Subprozessoren, TOM, Retention, Incident, Lizenzen | NEU |
+| vitest.config.ts, src/**/__tests__ | Unit-Tests | NEU |
+
+## C. Datenbank
+- **Neue Tabellen**: `legal_documents`, `legal_acceptances` (idempotent in `prisma/migrate.js`).
+- **Neue Felder**: keine an bestehenden Tabellen (Consent liegt in eigenen Tabellen; Tenant-Felder
+  `privacyAccepted` etc. bestanden bereits).
+- **Migration**: läuft idempotent beim Container-Start (bestehendes Muster). Dokumente werden geseedet/aktiviert.
+- **Auswirkungen auf Bestand**: keine destruktiven Änderungen; bestehende Daten unberührt.
+
+## D. Konfiguration (neue ENV, optional — Defaults sind sichtbare Platzhalter)
+`LEGAL_OPERATOR_NAME`, `LEGAL_OPERATOR_FORM`, `LEGAL_POSTAL_ADDRESS`, `LEGAL_SUPPORT_EMAIL`,
+`LEGAL_PRIVACY_EMAIL`, `LEGAL_SITE_DOMAIN`, `LEGAL_APP_DOMAIN`, `LEGAL_JURISDICTION`,
+`LEGAL_HOSTING_PROVIDER`, `LEGAL_SERVER_LOCATION`, `LEGAL_BACKUP_RETENTION`.
+
+## E. Manuelle Schritte nach Deployment
+1. `LEGAL_*`-Angaben setzen (oder direkt in `src/config/legal.ts`).
+2. `datenschutz@lageplan.ch` als überwachtes Postfach bestätigen.
+3. Migration läuft automatisch; prüfen, dass die 5 Dokumente aktiv sind (`/admin/legal`).
+4. Bestehende Org-Admins sehen beim nächsten Login die Organisationsbestätigung.
+5. Stripe-/SMTP-DPA prüfen; Subprozessoren-Regionen ergänzen.
+6. `/admin/legal` ggf. im Admin-Menü verlinken (aktuell direkte URL).
+
+## F. Offene rechtliche Entscheidungen
+Betreiberform/-adresse, Datenschutzkontakt, Serverstandorte (inkl. Backups/Logs), Unterauftragnehmer-
+Regionen & DPAs, Aufbewahrungsfristen, Nutzungsrecht FKS/BABS-Symbole, Versicherung, AVV mit Feuerwehren,
+juristische Schlussprüfung.
+
+## G. Tests & Prüfung
+- `npm test` (Vitest): **13 Tests grün** (Consent-Regeln, Re-Consent, 7 Org-Bestätigungen, Platzhalter,
+  keine erfundenen Subprozessoren).
+- `tsc --noEmit`: nur vorbestehender `nodemailer`-Typhinweis (unabhängig).
+- `next build`: erfolgreich (66 Seiten).
+- Manuell zu prüfen (kein E2E-Framework, unverhältnismässig): Registrierung ohne Zustimmung blockiert,
+  Re-Consent-Dialog erscheint, Checkboxen einzeln/nicht vorausgewählt, Admin-Seiten nicht öffentlich.
+
+## H. Nicht umgesetzt / bewusst als Folgeschritt
+- **Plan-Freigabe-Workflow** (Entwurf/geprüft/freigegeben/archiviert, geprüft-von/-am, Prüf-Erinnerungen):
+  grosser neuer DB-+UI-Umbau; stattdessen Export-/Dashboard-/Berechnungs-Hinweise umgesetzt. Empfehlung als
+  eigenes Projekt.
+- **MFA für Admins**, CSP verschärfen, Socket.io-CORS einschränken, geteilter Rate-Limit-Store: in
+  `technical-organizational-measures.md` als empfohlene Massnahmen dokumentiert.
+- Cookie-Banner: unverändert (nur technisch notwendige Cookies; in Datenschutz dokumentiert).

docs/legal/backup-and-restore.md

@@ -0,0 +1,37 @@
+# Backup & Restore — Übersicht
+
+Stand: 2026-07-24. Die ausführliche Betriebsanleitung steht in [`docs/BACKUP.md`](../BACKUP.md).
+Dieses Dokument fasst den datenschutz-/compliance-relevanten Stand zusammen.
+
+## Was wird gesichert
+- **Datenbank** (PostgreSQL): Konten, Organisationen, Pläne, Journale, Zustimmungen usw.
+- **Hochgeladene Dateien** (MinIO): Pläne, Logos, Symbole.
+- **Nicht** im Backup: Zahlungsdaten (bei Stripe), E-Mails (beim SMTP-Anbieter), Secrets.
+
+## Zwei Mechanismen
+1. **Lokaler Container-Backup** (`backup`-Service): täglich, im Volume `backups_data`, 30 Tage.
+   Schützt vor Bedienfehlern/Korruption, **nicht** vor Geräteausfall (gleiches Gerät).
+2. **GUI-Backup, verschlüsselt & extern** (`Administration → Backup`): SFTP oder Nextcloud/WebDAV,
+   AES-256-GCM mit Passphrase, Zeitplan + Aufbewahrung. **Off-site** → deckt Geräteausfall ab.
+
+| Aspekt | Zustand |
+|---|---|
+| Frequenz | täglich (konfigurierbar) |
+| Verschlüsselung (extern) | ✅ AES-256-GCM (Passphrase) |
+| Verschlüsselung (lokal) | ⚠️ nein (nur lokales Sicherheitsnetz) |
+| Aufbewahrung | 30 Tage (konfigurierbar) |
+| Zugriffsschutz | Ziel-Zugangsdaten verschlüsselt in DB; Passphrase separat aufbewahren |
+| Off-site | ✅ via GUI-Backup (sofern konfiguriert) |
+
+## Restore-Testplan (verbindlich)
+Ein Backup gilt erst als funktionierend, wenn ein Restore **nachweislich** geklappt hat.
+
+1. Aktuelles verschlüsseltes Backup vom Ziel laden.
+2. Mit `scripts/decrypt-backup.js` + Passphrase entschlüsseln → `tar.gz`.
+3. In einer **Testumgebung** DB + Dateien wiederherstellen (siehe `docs/BACKUP.md`).
+4. Stichprobe: Login, ein Projekt, ein Journal, ein hochgeladenes Symbol prüfen.
+5. Ergebnis in der Tabelle in `docs/BACKUP.md` protokollieren.
+6. **Häufigkeit:** mindestens halbjährlich.
+
+> Es wird **nicht** behauptet, dass eine Wiederherstellung funktioniert, solange kein Restore-Test
+> durchgeführt und protokolliert wurde.

docs/legal/current-state-audit.md

@@ -0,0 +1,44 @@
+# Bestandsaufnahme & Audit — Lageplan
+
+Stand: 2026-07-24 · Prüfung des tatsächlichen Repository-Stands vor gezielten Korrekturen.
+Legende Status: ✅ umgesetzt · 🟡 teilweise · ⚠️ widersprüchlich/prüfen · ❌ fehlend · 🔒 manuell (Fachperson).
+
+Dieser Audit dokumentiert, was aus früheren Runden (v1.7.0–v1.9.0) bereits vorhanden ist, damit
+**keine Doppelstrukturen** entstehen. Ergänzungen dieser Runde sind in der letzten Spalte markiert.
+
+| Bereich | Fundstelle | Aktueller Zustand | Risiko | Empfohlene/umgesetzte Änderung | Umgesetzt |
+|---|---|---|---|---|---|
+| Zentrale Legal-Config | `src/config/legal.ts` | Betreiber (Perparim Ziberi, Privatperson, Villmergen), Kontakt, Recht, Subprozessoren, Dok-Versionen | — | operatorType + fksAttribution ergänzt | ✅ (erweitert) |
+| Impressum | `src/app/impressum` | Privatperson, echte Adresse; verweist auf Datenschutz | niedrig | Haftungsverweis auf NB prüfen | ✅ vorhanden |
+| Datenschutz | `src/app/datenschutz` | Neuaufbau, Subprozessoren-Tabelle (#dienstleister), IP/UA-Nachweis, Auslandbekanntgabe | niedrig | Quellen-/Lizenz-Link ergänzt | ✅ vorhanden |
+| Nutzungsbedingungen | `src/app/nutzungsbedingungen` | Abschnitte 1–14 vorhanden | 🟡 | FKS-Abschnitt ergänzt | ✅ (FKS ergänzt) |
+| Verantwortungsvolle Nutzung | `src/app/verantwortungsvolle-nutzung` | vorhanden | niedrig | — | ✅ |
+| Sicherheit (öffentlich) | `src/app/sicherheit` | TOM-Kurzfassung, 2FA | niedrig | — | ✅ |
+| Unterstützen | `src/app/unterstuetzen` + `/spenden` | „Freiwilliger Unterstützungsbeitrag", Gebührenhinweis, keine Steuerabzug-Behauptung | niedrig | „Feature"-Tiers geprüft | ✅ |
+| Org-Datenschutzvereinbarung (AVV) | `src/app/organisationen/datenschutzvereinbarung` | Entwurf, als Vereinbarung formuliert | 🟡 | Entwurfscharakter klar | ✅ |
+| Konto & Datenschutz | `src/app/konto/datenschutz` | Zustimmungen, Export-/Löschanfrage, Kontakt | niedrig | — | ✅ |
+| Admin Rechtsdokumente | `src/app/admin/legal` | Versionen, Zustimmungszähler, Suche, CSV, IP/UA/Hash | niedrig | — | ✅ |
+| Consent-Datenmodell | `LegalDocument`, `LegalAcceptance` | versioniert, contentHash, IP/UA, unique, revisionssicher | niedrig | FKS_ATTRIBUTION-Typ ergänzt | ✅ (erweitert) |
+| Registrierung | `src/app/register` + API | 2 getrennte Zustimmungen (NB akzeptieren / Datenschutz Kenntnis), keine Vorauswahl, Version+Hash+IP/UA | niedrig | — | ✅ |
+| Re-Consent | `LegalConsentGate` | blockierend, Org-Bestätigung 7 Checks, Abmelden/Docs erreichbar | niedrig | — | ✅ |
+| In-App-Hinweise | Dashboard/Messpanel/Datenschutz | Dashboard-Banner, Berechnungs-Hinweis, Geodaten-Hinweis | 🟡 | Journal-Freitext-Warnung ergänzt | ✅ (ergänzt) |
+| Export-Disclaimer | `src/hooks/use-map-export.ts` | Prüf-Hinweis PDF+PNG | 🟡 | FKS-Quellenangabe ergänzt | ✅ (ergänzt) |
+| **FKS-/FEUKOS-Quellenangabe** | Footer, `licenses-and-attributions.md` | nur Footer + interne Doku | ⚠️ unvollständig | Quellen-Seite, Symbol-Panel, NB, Export, Dok-Typ | ✅ (diese Runde) |
+| Quellen-und-Lizenzen-Seite | — | ❌ fehlte | mittel | `/quellen-und-lizenzen` erstellt | ✅ (neu) |
+| **Planstatus/Freigabe** | `prisma/schema.prisma` | ❌ keine Status-/Freigabefelder | mittel | Entwurf/Geprüft/Freigegeben + Prüfdatum | 🟡 siehe Bericht |
+| Sicherheitsheader | `next.config.js` | CSP, HSTS, nosniff, Referrer/Permissions-Policy, frame-ancestors | niedrig | CSP unsafe-inline (MapLibre) dokumentiert | ✅ |
+| MFA/WebAuthn | `src/lib/mfa.ts`, `webauthn.ts` | TOTP + Passkeys/YubiKey + Backup-Codes + Admin-Reset | niedrig | — | ✅ |
+| Rate Limiting | `src/lib/rate-limit.ts` | Login/Register/Reset/Kontakt/Share/… | 🟡 (In-Memory) | — | ✅ |
+| Mandantentrennung | `getProjectWithTenantCheck` | serverseitig erzwungen | mittel | automatisierte Tests ergänzt | 🟡 Tests (diese Runde) |
+| Backup | Container + GUI (`/admin/backup`) | lokal + verschlüsselt SFTP/WebDAV, 30 Tage | niedrig | backup-and-restore.md ergänzt | ✅ |
+| Docs (Compliance) | `docs/legal/` | inventory, subprocessors, TOM, retention, incident, licenses, claims-audit | 🟡 | +international-transfers, +privacy-risk, +manual-checklist, +this audit | ✅ (ergänzt) |
+
+## Verbotene/absolute Aussagen — Nachkontrolle
+Frühere Runde entfernte 24/7, 100 %, DSG/DSGVO-konform, „keine Weitergabe", „nur Schweizer Server",
+„100 % der Spende", „Kein Unternehmen". Diese Runde prüft zusätzlich FKS-Terminologie
+(„offiziell/zertifiziert/Partner/empfohlen") → keine solchen Behauptungen zulässig.
+
+## Offen / manuell (siehe manual-action-checklist.md)
+Juristische Schlussprüfung, spätere Vereinsgründung (nur als Option), Versicherungen, endgültige
+Server-/Backupstandorte externer Dienste, Aufbewahrungsfristen-Entscheide, ergänzende FKS-Bestätigung
+für Rohdatei-/API-Weitergabe, periodischer externer Sicherheitstest.

docs/legal/data-processing-inventory.md

@@ -0,0 +1,23 @@
+# Dateninventar / Verzeichnis der Bearbeitungstätigkeiten — Lageplan
+
+Stand: 2026-07-23 · sorgfältiger Entwurf, ersetzt keine juristische Prüfung.
+Abgeleitet aus dem tatsächlichen Code-Stand. Offene Fristen/Standorte als Platzhalter `[…]`.
+
+| Datenkategorie | Zweck | Betroffene | Herkunft | Speicherort | Empfänger/Drittanbieter | Auslandbekanntgabe | Aufbewahrung | Löschprozess | Schutzmassnahmen |
+|---|---|---|---|---|---|---|---|---|---|
+| Kontodaten (Name, E-Mail, Rolle) | Authentifizierung, Verwaltung | Benutzer | Eingabe bei Registrierung | PostgreSQL | — | `[SERVERSTANDORT]` | bis Kontolöschung | Selfservice/Antrag; Backups bis Zyklusende | Rollen/Mandanten, TLS, Zugriffskontrolle |
+| Passwort (bcrypt-Hash) | Authentifizierung | Benutzer | Eingabe | PostgreSQL | — | `[SERVERSTANDORT]` | bis Kontolöschung | mit Konto | Einweg-Hash (bcrypt cost 12) |
+| Einsatz-/Inhaltsdaten (Pläne, Journale, Zeichnungen, Koordinaten) | Kernfunktion | Org-Mitglieder, ggf. Dritte | Eingabe | PostgreSQL | — | `[SERVERSTANDORT]` | bis Löschung durch Org | Projekt-/Orglöschung; Backups | Mandantentrennung, Zugriffskontrolle |
+| Hochgeladene Dateien (Logos, Planbilder, Symbole) | Darstellung | Org | Upload | MinIO | — | `[SERVERSTANDORT]` | bis Löschung | mit Projekt/Org | Zugriffsschutz, Validierung |
+| Zustimmungsnachweise (Doc-Typ/Version/Zeitpunkt/Kontext, IP, User-Agent, Hash) | Nachweis Einwilligung/Vertrag (Beweiszweck) | Benutzer | System | PostgreSQL (Schweiz, Eigenbetrieb) | — | nein | Aufbewahrung zu Nachweiszwecken `[FRIST]` | revisionssicher, nicht überschrieben | Zugriffskontrolle; IP/User-Agent bewusst zu Beweiszwecken erfasst |
+| Protokoll-/Sicherheitsdaten | Betrieb, Sicherheit | Benutzer | System | Server-Logs | — | `[SERVERSTANDORT]` | `[FRIST]` | rotierend | Minimierung sensibler Inhalte |
+| Session-Cookie `auth-token` | Anmeldung | Benutzer | System | Client-Cookie | — | — | 24 h / 14 Tage | Ablauf/Logout | httpOnly, secure (prod), sameSite=lax |
+| E-Mail-Versand (Verifizierung, Reset, Kontakt, Einladung) | Kommunikation | Benutzer/Empfänger | System/Eingabe | SMTP-Anbieter | E-Mail-Anbieter | `[ABHÄNGIG]` | beim Anbieter | — | TLS, nur bei Bedarf |
+| Unterstützungsbeiträge (Betrag, Name/Nachricht, payment_intent) | Zahlungsabwicklung | Spender | Eingabe/Stripe | Stripe + `SystemSetting` | Stripe | ja (möglich) | `[FRIST]` | `[PROZESS]` | Zahlungsdaten nur bei Stripe |
+| Karten-/Geo-Anfragen | Karten/Adresse/Wetter | Benutzer | Client | (extern) | OSM/Esri/swisstopo/Nominatim/Open-Meteo | möglich | keine Speicherung durch App | — | nur Kachel/Koordinaten |
+| localStorage (Zeichnungen, Sync-Queue, Theme, Onboarding, letztes Projekt, Cookie-Hinweis) | Funktion/Offline | Benutzer | Client | Gerät des Nutzers | — | — | bis lokal gelöscht | Browser | verbleibt lokal |
+
+## Offene Entscheidungen
+
+- Konkrete Aufbewahrungsfristen (Logs, Zustimmungen, Zahlungsdaten) → siehe `retention-and-deletion.md`.
+- Serverstandorte bestätigen.

docs/legal/incident-response.md

@@ -0,0 +1,44 @@
+# Incident-Response — Lageplan
+
+Stand: 2026-07-23 · sorgfältiger Entwurf. **Manueller Entscheidungsprozess** — es erfolgt KEINE
+automatische Meldung an Behörden. Meldepflichten werden im Einzelfall geprüft.
+
+## Kontakte (auszufüllen)
+- Verantwortlich (Betreiber): `[NAME]` · `[KONTAKT]`
+- Datenschutzkontakt: siehe `src/config/legal.ts` (`privacyContactEmail`)
+- Technischer Notfallkontakt: `[NAME/TELEFON]`
+- Zuständige Aufsichtsbehörde (CH): EDÖB — `[LINK/KONTAKT]`
+
+## Ablauf
+
+1. **Erkennung** — Quelle (Monitoring, Meldung, Nutzerhinweis), Zeitpunkt und Symptome festhalten.
+2. **Interne Eskalation** — Verantwortliche informieren; Vorfall im Vorfallprotokoll eröffnen.
+3. **Eindämmung** — betroffene Systeme/Zugänge isolieren, ggf. Dienste temporär sperren.
+4. **Beweissicherung** — Logs/Artefakte sichern, bevor Änderungen erfolgen.
+5. **Bewertung betroffener Daten** — welche Datenkategorien/Personen sind betroffen?
+6. **Risikobewertung** — Eintritts-/Schadenswahrscheinlichkeit für Betroffene.
+7. **Information betroffener Organisationen** — ohne unangemessene Verzögerung, sachlich.
+8. **Prüfung Behördenmeldung** — Meldepflicht (z.B. EDÖB) im Einzelfall prüfen und **manuell** entscheiden/dokumentieren.
+9. **Passwort-/Schlüsselrotation** — Secrets, Tokens, ggf. Nutzer-Passwörter rotieren.
+10. **Wiederherstellung** — aus sauberem Stand/Backup; Integrität prüfen.
+11. **Nachbearbeitung** — Ursachenanalyse, Massnahmen, Lessons Learned.
+
+## Vorfallprotokoll (Vorlage)
+| Feld | Inhalt |
+|---|---|
+| Vorfall-ID / Datum | |
+| Entdeckt durch / wann | |
+| Beschreibung | |
+| Betroffene Daten/Personen | |
+| Sofortmassnahmen | |
+| Risikobewertung | |
+| Information an Organisationen (wann/wie) | |
+| Behördenmeldung (ja/nein, Begründung) | |
+| Rotation durchgeführt | |
+| Wiederherstellung | |
+| Abschluss / Massnahmen | |
+
+## Vom Betreiber zu treffende Entscheidungen
+- Verbindliche Kontaktliste und Erreichbarkeit.
+- Melde-Schwellen und interne Fristen.
+- Aufbewahrung des Vorfallprotokolls.

docs/legal/international-data-transfers.md

@@ -0,0 +1,27 @@
+# Auslandbearbeitungen — Lageplan
+
+Stand: 2026-07-24 · sorgfältiger Entwurf. Unterscheidet **Unternehmenssitz** und **Serverregion**.
+Klassifizierung: 🇨🇭 Schweiz · 🇪🇺 EU/EWR · ✅ anerkanntes Datenschutzniveau · ⚠️ zusätzliche
+vertragliche/technische Massnahmen prüfen · ❓ nicht abschliessend geklärt.
+
+| Dienst | Funktion | Datenkategorien | Unternehmenssitz | Serverregion | Klassifizierung | Bemerkung |
+|---|---|---|---|---|---|---|
+| PostgreSQL (Eigenbetrieb) | Primäre Datenhaltung | Konto/Org/Plan/Journal | Schweiz (Betreiber) | Schweiz | 🇨🇭 | selbst gehostet |
+| MinIO (Eigenbetrieb) | Datei-Uploads | Pläne/Logos/Symbole | Schweiz (Betreiber) | Schweiz | 🇨🇭 | selbst gehostet |
+| OpenStreetMap Foundation | Tiles/Nominatim | Kachel/Adresse/IP | UK | UK/EU | ✅/⚠️ | clientseitig, IP-Übermittlung |
+| swisstopo | Landeskarte | Kachel/IP | Schweiz | Schweiz | 🇨🇭 | clientseitig |
+| Esri (ArcGIS) | Satellitenbilder | Kachel/IP | USA | USA/global | ⚠️ | clientseitig; Bedingungen prüfen |
+| Open-Meteo | Wind/Höhe | Koordinaten/IP | Deutschland | EU | 🇪🇺 | clientseitig |
+| Open-Elevation | Höhe (Fallback) | Koordinaten/IP | ❓ | ❓ | ❓ | Community-Dienst; Region unklar |
+| Stripe (optional) | Zahlungen | Betrag/Name/Zahlungsdaten | USA (EU-Töchter) | USA/EU | ⚠️ | nur wenn konfiguriert; DPA prüfen |
+| SMTP-Anbieter (optional) | E-Mails | Empfänger/Inhalt | abhängig | abhängig | ⚠️/❓ | vom Betreiber gewählt |
+
+## Grundsätze
+- Die öffentliche Datenschutzerklärung macht **keine** pauschale „nur Schweiz"-Garantie; Auslandbearbeitung
+  (v.a. Stripe, E-Mail, globale Kartendienste) wird transparent benannt.
+- Client-seitige Karten-/Geodienste erhalten die IP-Adresse des Nutzers direkt.
+
+## Offen / manuell (Betreiber)
+- DPA/Standardvertragsklauseln mit Stripe und dem gewählten E-Mail-Anbieter prüfen/abschliessen.
+- Serverregion von Esri/Open-Elevation konkretisieren oder Dienst ggf. ersetzen.
+- Entscheidung, ob der Open-Elevation-Fallback (unklare Region) deaktiviert werden soll.

docs/legal/licenses-and-attributions.md

@@ -0,0 +1,60 @@
+# Lizenzen und Attributionen — Lageplan
+
+Stand: 2026-07-24 · sorgfältiger Entwurf. Eine Quellenangabe ersetzt NICHT automatisch eine
+erforderliche Nutzungslizenz. Offene Freigabefragen sind markiert.
+
+## Feuerwehr Koordination Schweiz FKS — schriftliche Genehmigung
+- **Organisation:** Feuerwehr Koordination Schweiz FKS
+- **Inhalte:** FEUKOS-Markierungen, -Symbole und bewilligtes Bildmaterial
+- **Datum der Freigabe:** 17. Februar 2026
+- **Quellenangabe (exakt):** „Feuerwehr Koordination Schweiz FKS"
+- **Projektbezug:** Verwendung innerhalb des beschriebenen Webprojekts lageplan.ch
+- **Archivierung:** Das Original (E-Mail) ist **ausserhalb des öffentlichen Repositorys** abgelegt
+  (siehe `private-legal-evidence/`, in `.gitignore`). Es wird **nicht** committet; keine Namen/
+  E-Mail-Adressen einzelner FKS-Mitarbeitender werden veröffentlicht.
+- **Kein** Anspruch auf offizielle Partnerschaft, Zertifizierung, Prüfung, behördliche Anerkennung
+  oder Empfehlung von lageplan.ch durch die FKS.
+- **Offene Frage (manuell):** Falls Rohdatei-Downloads, API-Nutzung oder Weitergabe der Symbol-
+  bibliothek an Dritte **nicht** Teil der ursprünglichen Projektbeschreibung waren, ist eine
+  ergänzende FKS-Bestätigung einzuholen (siehe `manual-action-checklist.md`).
+
+## Karten & Geodaten
+| Quelle | Nutzung | Lizenz/Bedingungen | Attribution | Offene Frage |
+|---|---|---|---|---|
+| OpenStreetMap | Basiskarte, Nominatim | ODbL (Daten) | "© OpenStreetMap-Mitwirkende" (vorhanden im Impressum/Karte) | Tile-Usage-Policy einhalten (Fair Use) |
+| Esri World Imagery | Satellitenlayer | Esri-Nutzungsbedingungen | "Esri World Imagery" | ⚠️ kommerzielle/Nutzungsbedingungen prüfen |
+| swisstopo (geo.admin.ch) | Landeskarte | swisstopo-Bedingungen | "© swisstopo" empfohlen | ⚠️ Attribution/Bedingungen bestätigen |
+| Open-Meteo | Wind/Höhe | Open-Meteo Terms (frei, Attribution empfohlen) | "Open-Meteo" | Attribution ergänzen? |
+| Open-Elevation | Höhe (Fallback) | offen/community | — | ⚠️ Bedingungen prüfen |
+
+## Symbole / Icons
+| Quelle | Nutzung | Lizenz | Attribution | Offene Frage |
+|---|---|---|---|---|
+| FEUKOS-/FKS-Symbole | Einsatzsymbole | Schriftliche Genehmigung FKS (17.02.2026) | "Bildquelle: Feuerwehr Koordination Schweiz FKS" | Rohdatei-/API-Weitergabe ggf. nicht abgedeckt (siehe unten) |
+| lucide-react | UI-Icons | ISC | — (im Code) | ok |
+
+## Schriftarten
+| Quelle | Lizenz | Hinweis |
+|---|---|---|
+| Barlow (Google Fonts, via next/font) | SIL Open Font License 1.1 | build-time self-hosted, kein Laufzeit-Request zu Google |
+
+## Wesentliche Bibliotheken (Auszug)
+| Paket | Lizenz |
+|---|---|
+| next / react | MIT |
+| maplibre-gl | BSD-3-Clause |
+| jspdf | MIT (+ Teile Apache-2.0) |
+| qrcode | MIT |
+| stripe (SDK) | MIT |
+| bcryptjs, jose, zod, socket.io | MIT |
+| @prisma/client, prisma | Apache-2.0 |
+
+## Bereits umgesetzte sichtbare Attributionen
+- Karten-Attribution "© OpenStreetMap contributors | MapLibre" auf der Karte.
+- "Taktische Symbole: Bildquelle Feuerwehr Koordination Schweiz FKS" im Footer.
+- Kartendaten-Hinweis im Impressum (OpenStreetMap, Nominatim).
+
+## Offene Freigabefragen (Betreiber)
+1. **FKS/BABS-Symbole**: Nutzungsrecht/Freigabe für die konkrete Verwendung schriftlich bestätigen.
+2. Esri/swisstopo-Nutzungsbedingungen für den vorgesehenen (auch nicht-kommerziellen) Einsatz prüfen.
+3. Vollständige Lizenzliste (z.B. `license-checker`) generieren und Drittlizenzen bündeln, falls verteilt.

docs/legal/manual-action-checklist.md

@@ -0,0 +1,39 @@
+# Manuelle Restpunkte — was Code nicht lösen kann
+
+Stand: 2026-07-24. Diese Punkte sind **nicht** durch die Software erledigt und dürfen **nicht** als
+erledigt dargestellt werden. Sie erfordern Entscheidungen, Verträge oder externe Prüfungen.
+
+## Rechtlich
+- [ ] **Juristische Schlussprüfung** aller Rechtsseiten (Nutzungsbedingungen, Datenschutz, AVV, FKS-
+      Abschnitt) durch eine qualifizierte Schweizer Fachperson.
+- [ ] Entscheidung über eine **spätere Vereinsgründung** (aktuell nur offene Option — Betreiber bleibt
+      Privatperson Perparim Ziberi). Kein Verein behaupten, solange nicht gegründet.
+- [ ] Tatsächliche **Übertragung auf einen Verein** erst nach dessen Gründung (dann Betreiberangaben,
+      Impressum, AVV, Config anpassen).
+- [ ] **Steuerliche Behandlung** freiwilliger Unterstützungsbeiträge klären.
+
+## FKS / Bildmaterial
+- [ ] Original der FKS-Freigabe (17.02.2026) **ausserhalb** des Repos archivieren (`private-legal-evidence/`).
+- [ ] Prüfen, ob **Rohdatei-Download, API-Nutzung oder Weitergabe** der Symbolbibliothek an Dritte von der
+      ursprünglichen Projektbeschreibung gedeckt ist; falls nicht → **ergänzende FKS-Bestätigung** einholen.
+
+## Versicherung
+- [ ] IT-/Vermögensschaden-Haftpflicht prüfen (Offerten einholen).
+- [ ] Cyberversicherung prüfen.
+- [ ] Bei späterem Verein: Vereins-/Rechtsschutz prüfen.
+
+## Verträge & Standorte
+- [ ] Formelle Vereinbarungen mit Gemeinden/Organisationen (falls gewünscht) — die elektronische
+      Organisationsbestätigung ist **kein** beidseitig unterzeichneter AVV.
+- [ ] Endgültige **Server- und Backupstandorte** der externen Dienste bestätigen (Esri, Stripe, SMTP,
+      Open-Elevation) — siehe `international-data-transfers.md`.
+- [ ] **DPA/Standardvertragsklauseln** mit Stripe und dem gewählten E-Mail-Anbieter abschliessen.
+
+## Aufbewahrung & Betrieb
+- [ ] Konkrete **Aufbewahrungsfristen** je Datenkategorie festlegen (siehe `retention-and-deletion.md`).
+- [ ] **Restore-Test** durchführen und in `docs/BACKUP.md` protokollieren.
+- [ ] Periodischen **externen Sicherheitstest / Pentest** beauftragen.
+
+## Datenschutz
+- [ ] Prüfen lassen, ob eine **vertiefte DSFA** erforderlich ist (siehe `privacy-risk-assessment.md`).
+- [ ] `datenschutz@lageplan.ch` als **aktiv überwachtes** Postfach bestätigen.

docs/legal/privacy-risk-assessment.md

@@ -0,0 +1,24 @@
+# Datenschutz-Risikovorprüfung — Lageplan
+
+Stand: 2026-07-24 · sorgfältiger Entwurf. Vorprüfung, **keine** abschliessende Datenschutz-
+Folgenabschätzung (DSFA). Ob eine vertiefte DSFA nötig ist, muss eine Fachperson beurteilen —
+dies wird hier **nicht** pauschal verneint.
+
+Skala: Wahrscheinlichkeit/Auswirkung = niedrig / mittel / hoch.
+
+| # | Risiko | Wahrsch. | Auswirkung | Bestehende Massnahmen | Restrisiko | Weitere Massnahme | Rolle |
+|---|---|---|---|---|---|---|---|
+| 1 | Offenlegung von Gebäude-/Zufahrts-/Gefahren-/Hydranten-/Schlüsselstellen-Infos | mittel | hoch | Mandantentrennung, Rollen, Zugriffskontrolle, Verbot sensibler Daten (NB) | mittel | Org-Sensibilisierung, ggf. Feldklassifizierung | Betreiber/Org |
+| 2 | Organisationsübergreifender Zugriff (IDOR) | niedrig | hoch | `getProjectWithTenantCheck`, serverseitige Prüfung, autom. Tests | niedrig | periodische Tests/Pentest | Betreiber |
+| 3 | Datenleck über Dateizugriffe | niedrig | hoch | serve-Routen mit Tenant-Check, MinIO nicht öffentlich für private Objekte | niedrig | Pentest, Bucket-Policy-Review | Betreiber |
+| 4 | Kompromittierung Adminkonto | niedrig | hoch | MFA (TOTP/WebAuthn), Rate-Limiting, bcrypt | niedrig | MFA für alle Admins erzwingen (Option) | Betreiber |
+| 5 | Auslandbearbeitung (Stripe/E-Mail/Karten) | mittel | mittel | Transparente Doku, optionale Dienste, IP nur clientseitig | mittel | DPA/SCC prüfen | Betreiber |
+| 6 | Standortdaten (GPS) der Nutzer | niedrig | mittel | nur zur Kartenfunktion, keine dauerhafte Speicherung durch App | niedrig | Doku bestätigen | Betreiber |
+| 7 | Besonders schützenswerte Daten in Freitext/Journal | mittel | hoch | NB-Verbot, In-App-Warnungen (Journal, Dashboard), Org-Bestätigung | mittel | ggf. Muster-Erkennung/Hinweis | Betreiber/Org |
+| 8 | Verlust/Nichtverfügbarkeit von Daten | niedrig | mittel | Backups (lokal + verschlüsselt off-site) | niedrig | Restore-Test durchführen | Betreiber |
+| 9 | Datenleck durch Drittanbieter-Subprozessor | niedrig | mittel | minimale Datenweitergabe, Subprozessorenliste | mittel | Anbieterprüfung dokumentieren | Betreiber |
+| 10 | Fehlende/veraltete fachliche Prüfung eines Plans | mittel | hoch | Hinweise in App/Export; Planstatus (in Umsetzung) | mittel | Freigabe-Workflow finalisieren | Org |
+
+## Empfehlung
+Eine **vertiefte DSFA** sollte durch eine qualifizierte Fachperson geprüft werden — insbesondere wegen
+sicherheitsrelevanter Objekt-/Infrastrukturdaten (Risiko 1, 3, 7). Diese Vorprüfung ersetzt sie nicht.

docs/legal/retention-and-deletion.md

@@ -0,0 +1,37 @@
+# Aufbewahrungs- und Löschkonzept — Lageplan
+
+Stand: 2026-07-23 · sorgfältiger Entwurf. **Keine Fristen erfunden** — offene Fristen als `[FRIST — zu
+entscheiden]`. Der Betreiber muss die markierten Entscheidungen treffen.
+
+| Datenkategorie | Aufbewahrung | Löschung / Prozess |
+|---|---|---|
+| Aktive Benutzerkonten | solange Konto besteht | Selfservice/Antrag; kaskadierende Löschung zugehöriger Daten |
+| Deaktivierte Konten (`isActive=false`) | `[FRIST]` | `[PROZESS — automatische Löschung nach X?]` |
+| Organisationen (Tenant) | solange aktiv | Löschung durch Org-Admin (Einstellungen) nach Berechtigungsprüfung |
+| Pläne / Projekte | bis Löschung durch Org | mit Projekt-/Orglöschung (Cascade) |
+| Dateiuploads (MinIO) | bis Löschung des Bezugsobjekts | mit Projekt/Org/Icon |
+| Audit-/Aktionslogs (falls geführt) | `[FRIST]` | `[PROZESS]` |
+| Sicherheits-/Server-Logs | `[FRIST]` | Rotation `[KONFIG]` |
+| Einladungen | `[FRIST]` | nach Annahme/Ablauf |
+| Passwort-Reset-Tokens | Ablauf (`resetTokenExpiry`) | mit Verwendung/Ablauf |
+| E-Mail-Verifizierungs-Tokens | bis Verifizierung | mit Verifizierung |
+| E-Mails (beim SMTP-Anbieter) | beim Anbieter | `[ABHÄNGIG]` |
+| Zahlungsinformationen (Stripe + `SystemSetting/donations`) | `[FRIST]` (ggf. gesetzliche Aufbewahrung) | `[PROZESS]`; Zahlungsdaten liegen bei Stripe |
+| Supportanfragen (Kontaktformular) | `[FRIST]` | `[PROZESS]` |
+| Backups | `[BACKUP-AUFBEWAHRUNGSFRIST]` | mit Ablauf des Backup-Zyklus |
+| Zustimmungshistorie (LegalAcceptance) | zu Nachweiszwecken `[FRIST]` | revisionssicher, i.d.R. nicht gelöscht solange Konto besteht |
+
+## Grundsätze
+- Produktivdaten werden nach Abschluss des Löschvorgangs entfernt.
+- Daten in Sicherungskopien können bis zum Ablauf des regulären Backup-Zyklus fortbestehen.
+- Organisationsrelevante Daten werden nicht ohne Berechtigungsprüfung sofort gelöscht.
+- Betroffenenrechte (Auskunft, Berichtigung, Löschung, Export) über `/konto/datenschutz` bzw.
+  Datenschutzkontakt; Eingang wird bestätigt.
+
+## Vom Betreiber zu treffende Entscheidungen
+1. Aufbewahrungsfrist deaktivierter Konten und automatischer Löschlauf?
+2. Log-Aufbewahrung (Server-/Sicherheitslogs) und Rotation?
+3. Aufbewahrung Zahlungs-/Spendendaten (gesetzliche Pflichten?).
+4. Backup-Aufbewahrungsfrist (`LEGAL_BACKUP_RETENTION`).
+5. Aufbewahrung Zustimmungsnachweise nach Kontolöschung.
+6. Support-/Kontaktanfragen-Frist.

docs/legal/subprocessors.md

@@ -0,0 +1,33 @@
+# Unterauftragnehmer / Subprozessoren — Lageplan
+
+Stand: 2026-07-23 · sorgfältiger Entwurf, ersetzt keine juristische Prüfung.
+
+Nur tatsächlich im Code verwendete bzw. optional konfigurierbare Dienste. Nicht verwendete Dienste
+sind NICHT aufgeführt. Regionen/Verträge, die nicht sicher bekannt sind, tragen Platzhalter `[…]`.
+
+| Anbieter | Zweck | Verarbeitete Daten | Sitz / Region | Datenschutzhinweis | Auslandbearbeitung | Vertragsstatus |
+|---|---|---|---|---|---|---|
+| OpenStreetMap Foundation (Tiles) | Basiskarte | Kachel-Koordinaten, IP (Client) | `[REGION — UK/EU]` | osmfoundation.org/wiki/Privacy_Policy | möglich | `[ZU PRÜFEN]` |
+| Esri (ArcGIS World Imagery) | Satellitenbilder | Kachel-Koordinaten, IP (Client) | `[REGION — USA/global]` | esri.com/legal | wahrscheinlich | `[ZU PRÜFEN]` |
+| swisstopo (geo.admin.ch) | Schweizer Landeskarte | Kachel-Koordinaten, IP (Client) | Schweiz | geo.admin.ch | nein | `[ZU PRÜFEN]` |
+| Nominatim (OSM) | Adress-/Reverse-Geocoding | Suchbegriff/GPS, IP (Client) | `[REGION — OSMF]` | osmfoundation.org | möglich | `[ZU PRÜFEN]` |
+| Open-Meteo | Wind-/Höhendaten | Koordinaten, IP (Client) | `[REGION — EU/DE]` | open-meteo.com/en/terms | möglich | `[ZU PRÜFEN]` |
+| Open-Elevation | Höhendaten (Fallback) | Koordinaten, IP (Client) | `[REGION]` | open-elevation.com | möglich | `[ZU PRÜFEN]` |
+| Stripe | Zahlungsabwicklung (freiwillige Beiträge) | Betrag, freiwilliger Name/Nachricht, Zahlungsdaten (direkt bei Stripe) | `[REGION — USA/EU]` | stripe.com/privacy | ja (USA möglich) | `[DPA PRÜFEN]` · nur wenn konfiguriert |
+| SMTP-/E-Mail-Anbieter (konfigurierbar) | System-E-Mails | Empfängeradresse, Mailinhalt | `[ABHÄNGIG VOM ANBIETER]` | `[ANBIETER]` | abhängig | `[ZU PRÜFEN]` · nur wenn konfiguriert |
+| MinIO (Objektspeicher, selbst gehostet) | Datei-/Bild-Uploads | Pläne, Logos, Symbole | `[SERVERSTANDORT]` | — (Eigenbetrieb) | `[ZU BESTÄTIGEN]` | Eigenbetrieb |
+| PostgreSQL (Datenbank, selbst gehostet) | Primäre Datenhaltung | Konto-, Org-, Plan-, Journaldaten | `[SERVERSTANDORT]` | — (Eigenbetrieb) | `[ZU BESTÄTIGEN]` | Eigenbetrieb |
+
+## Hinweise
+
+- **Client-seitige Dienste** (Tiles, Nominatim, Open-Meteo/Elevation): werden direkt aus dem Browser
+  des Nutzers aufgerufen; dabei kann die IP-Adresse an den Anbieter gelangen.
+- **Stripe** und **SMTP** sind nur aktiv, wenn in den Systemeinstellungen (DB `SystemSetting`) konfiguriert.
+- **MapTiler / Mapbox / Google Maps**: NICHT genutzt (MapTiler nur in der CSP-Allowlist vorbereitet).
+- **Analytics / Error-Tracking (Sentry, GA, Plausible, PostHog)**: NICHT vorhanden.
+
+## Offene Entscheidungen des Betreibers
+
+- Serverstandort für PostgreSQL, MinIO, Backups und Logs abschliessend bestätigen.
+- DPA/AVV mit Stripe und dem gewählten E-Mail-Anbieter abschliessen und Status hier eintragen.
+- Verarbeitungsregionen der Kartendienste konkretisieren.

docs/legal/technical-organizational-measures.md

@@ -0,0 +1,62 @@
+# Technische und organisatorische Massnahmen (TOM) — Lageplan
+
+Stand: 2026-07-23 · sorgfältiger Entwurf. Ist-Zustand aus dem Code; offene Punkte klar markiert.
+Legende: ✅ vorhanden · ⚠️ teilweise / zu bestätigen · ❌ offen / nicht umgesetzt.
+
+## Zugriff & Berechtigungen
+- ✅ Mandantentrennung je Organisation (Tenant), `getProjectWithTenantCheck`.
+- ✅ Rollenkonzept: SERVER_ADMIN, TENANT_ADMIN, OPERATOR, VIEWER.
+- ✅ MFA/Zwei-Faktor verfügbar: TOTP (Authenticator-App) + WebAuthn (YubiKey/Passkeys), freiwillig
+  pro Benutzer; Admin kann MFA zurücksetzen. Backup-Codes als Fallback. (SMS bewusst nicht umgesetzt.)
+- ✅ Admin-APIs serverseitig mit `isAdmin`/`isServerAdmin` geschützt.
+
+## Authentifizierung & Sessions
+- ✅ Passwort-Hashing: bcrypt (cost 12), nie Klartext.
+- ✅ JWT-Session (jose, HS256), Cookie `auth-token` httpOnly, secure (prod), sameSite=lax, 24 h/14 Tage.
+- ✅ Passwort-Reset mit kryptographischem Token (32 Bytes), Ablauf.
+- ✅ E-Mail-Verifizierung.
+
+## Transport & Web-Härtung
+- ✅ HTTPS/TLS; HSTS (max-age 2 Jahre, preload).
+- ✅ Sicherheits-Header: CSP (mit `frame-ancestors 'self'`), X-Content-Type-Options nosniff,
+  Referrer-Policy, Permissions-Policy, COOP, X-XSS-Protection.
+- ⚠️ CSP enthält `unsafe-inline`/`unsafe-eval` (für MapLibre gelockert) → langfristig verschärfen.
+- ✅ Private Routen (/app,/admin,/settings,/konto): `X-Robots-Tag: noindex` + `Cache-Control: no-store` (Middleware).
+- ⚠️ Socket.io-Server (`server-custom.js`): CORS `origin:'*'` → **einschränken empfohlen**.
+
+## Eingaben & Uploads
+- ✅ Rate-Limiting: Login, Registrierung, Passwort-Reset, Verifizierung, Kontakt, Konto-Löschung, Share-PIN.
+- ⚠️ Rate-Limiter ist In-Memory (pro Instanz) → bei Mehr-Instanz-Betrieb geteilten Store nutzen.
+- ⚠️ Upload-Validierung (MIME/Grösse): vorhanden für Icons/Logos/Planbilder → **Umfang bestätigen**.
+- ✅ Zugriffsschutz auf Dateien (serve-Routen mit Tenant-Check).
+
+## Speicherung & Verschlüsselung
+- ✅ Übertragung verschlüsselt (TLS).
+- ⚠️ Verschlüsselung ruhender Daten (DB/MinIO/Backups): `[ZU BESTÄTIGEN]`.
+- ⚠️ Secrets-Verwaltung: ENV (`NEXTAUTH_SECRET`, MinIO) + DB (`SystemSetting`: SMTP/Stripe) → **Absicherung der DB-Secrets bestätigen**.
+
+## Backup & Wiederherstellung
+- ✅ Automatisches Backup (eigener `backup`-Container): täglich Postgres-Dump + MinIO-Dateien,
+  30 Tage Aufbewahrung (`docker-compose.yml` / `deploy/portainer-stack.yml`, Anleitung `docs/BACKUP.md`).
+- ⚠️ Off-Site-Kopie: empfohlen (Backups zusätzlich an einen zweiten Ort spiegeln) — siehe `docs/BACKUP.md`.
+- ⚠️ Restore-Test: mindestens 1× durchführen und in `docs/BACKUP.md` protokollieren.
+
+## Logging & Monitoring
+- ✅ Server-Logs (console). ⚠️ Vermeidung sensibler Daten in Logs → **Review empfohlen**.
+- ❌ Zentrales Monitoring/Alerting: `[OFFEN]`.
+
+## Betrieb & Prozesse
+- ✅ Idempotente Migrationen (`prisma/migrate.js`) beim Container-Start.
+- ⚠️ Dependency-/Patch-Management: `[PROZESS DOKUMENTIEREN]`.
+- ⚠️ Trennung Entwicklung/Test/Produktion: `[BESTÄTIGEN]`; Umgang mit Testdaten `[BESTÄTIGEN]`.
+- ✅ Löschkonzept/Datenexport: siehe `retention-and-deletion.md`; Betroffenenrechte via `/konto/datenschutz`.
+- ✅ Berechtigungsentzug: Benutzer sperren (`isActive`), aus Organisation entfernen.
+
+## Direkt umgesetzte risikoarme Verbesserungen (dieses Update)
+- Private Routen auf `noindex`/`no-store` gesetzt.
+- Rechtliche Prüf-Hinweise in Exporten und Berechnungen.
+- Revisionssichere Zustimmungsprotokollierung ohne roh-IP.
+
+## Empfohlene, noch offene Massnahmen
+- MFA für Admins; CSP verschärfen; Socket.io-CORS einschränken; geteilter Rate-Limit-Store;
+  Verschlüsselung ruhender Daten + Backups bestätigen; Restore-Tests; Monitoring.

docs/legal/website-claims-audit.md

@@ -0,0 +1,46 @@
+# Website Claims Audit — Lageplan
+
+Stand: 2026-07-23 · Version 1.0 (sorgfältiger Entwurf, ersetzt keine juristische Prüfung)
+
+Prüfung aller werblichen / absoluten Aussagen im Repository und deren Korrektur zu sachlichen,
+nachweisbaren Formulierungen. Fundstellen beziehen sich auf den Stand vor der Korrektur.
+
+| # | Bisherige Aussage | Fundstelle (vorher) | Risiko / Widerspruch | Neue Formulierung | Geänderte Datei |
+|---|---|---|---|---|---|
+| 1 | „100% · Swiss Hosted · Server in der Schweiz" | `src/app/page.tsx:241` | Serverstandort nicht für alle Subprozessoren (Stripe, SMTP, globale Kartendienste) belegt; absolutes 100% | „CH · Swiss Made · In der Schweiz entwickelt" | `src/app/page.tsx` |
+| 2 | „24/7 · Verfügbar" | `src/app/page.tsx:243` | Verfügbarkeitszusage ohne SLA | „Web · Überall nutzbar · Browser, Tablet, Smartphone" | `src/app/page.tsx` |
+| 3 | „Die Applikation ist DSG- und DSGVO-konform." (FAQ + JSON-LD) | `src/app/page.tsx:87,458` | Unbelegte pauschale Konformitätszusage | „Die eingesetzten Dienstleister und Speicherorte sind in der Datenschutzerklärung transparent aufgeführt. Lageplan orientiert sich am Schweizer Datenschutzgesetz (DSG)." | `src/app/page.tsx` |
+| 4 | „Sicher & Schweiz … DSG/DSGVO-konform." (Feature-Karte) | `src/app/page.tsx:361` | Absolute Sicherheits-/Konformitätszusage | „Sicherheit & Datenschutz … Angemessene technische und organisatorische Schutzmassnahmen — Details in der Datenschutzerklärung." | `src/app/page.tsx` |
+| 5 | „Lückenlose Protokollierung aller Aktionen" | `src/app/page.tsx:360` | „lückenlos" = absolute Zusage | „Protokollierung von Aktionen mit Zeitstempel für bessere Nachvollziehbarkeit." | `src/app/page.tsx` |
+| 6 | „Nichts. Lageplan ist kostenlos …" (FAQ + JSON-LD) | `src/app/page.tsx:55,442` | Impliziert dauerhafte Kostenlosigkeit | „… grundsätzlich kostenlos … Ein Anspruch darauf, dass alle Funktionen dauerhaft kostenlos bleiben, besteht nicht." | `src/app/page.tsx` |
+| 7 | „100% deiner Spende fliesst direkt …" | `src/app/page.tsx:588`, `src/app/spenden/page.tsx:252` | Ignoriert Stripe-Gebühren; absolutes 100% | „Beiträge werden nach Abzug allfälliger Zahlungsgebühren für Hosting, Infrastruktur und Weiterentwicklung eingesetzt." | `src/app/page.tsx`, `src/app/spenden/page.tsx` |
+| 8 | „Kein Unternehmen, keine Investoren …" | `src/app/page.tsx:589`, `src/app/spenden/page.tsx:253` | Betreiberform ist rechtlich noch festzulegen; potenziell irreführend | „Ein Projekt aus der Feuerwehr-Praxis — entwickelt in der Freizeit." | `src/app/page.tsx`, `src/app/spenden/page.tsx` |
+| 9 | „Lageplan ist und bleibt kostenlos." | `src/app/page.tsx:551`, `src/app/spenden/page.tsx:239` | „bleibt" = dauerhafte Zusage | „Lageplan wird grundsätzlich kostenlos angeboten." | `src/app/page.tsx`, `src/app/spenden/page.tsx` |
+| 10 | „Zahlung sicher via Stripe" | `src/app/page.tsx:574`, `src/app/spenden/page.tsx:226` | „sicher" = absolute Zusage | „Zahlung über Stripe" | `src/app/page.tsx`, `src/app/spenden/page.tsx` |
+| 11 | „Server-Hosting in der Schweiz (monatliche Kosten)" | `src/app/spenden/page.tsx:99` | Serverstandort nicht abschliessend belegt | „Server-Hosting und Infrastruktur (monatliche Kosten)" | `src/app/spenden/page.tsx` |
+| 12 | „Jeder Franken fliesst direkt in Serverkosten …" | `src/app/spenden/page.tsx:244` | Ignoriert Gebühren | „Beiträge helfen, Hosting, Infrastruktur und Weiterentwicklung mitzufinanzieren." | `src/app/spenden/page.tsx` |
+| 13 | „weder an Dritte verkauft noch weitergegeben" | `src/app/impressum/page.tsx:108` | Absolute „keine Weitergabe"; widerspricht Einsatz von Dienstleistern | „… nicht an Dritte verkauft. Für den technischen Betrieb können sorgfältig ausgewählte … Dienstleister eingesetzt werden. Einzelheiten enthält die Datenschutzerklärung." | `src/app/impressum/page.tsx` |
+| 14 | „Einsatzdaten … werden verschlüsselt gespeichert" | `src/app/impressum/page.tsx:116` | „verschlüsselt gespeichert" technisch nicht belegt (Ruhedaten) | Zugriffs-/Mandantenkonzept + „Übertragung erfolgt über HTTPS/TLS"; Passwörter „gehasht (bcrypt)" | `src/app/impressum/page.tsx` |
+| 15 | „Passwort (verschlüsselt gespeichert)" | `src/app/datenschutz/page.tsx:47` | Falsch: Passwörter werden gehasht, nicht verschlüsselt | „Passwort wird mit einem geeigneten Einwegverfahren (bcrypt) gehasht" | `src/app/datenschutz/page.tsx` (Neuaufbau) |
+| 16 | „Alle Daten … auf Servern in der Schweiz … keine Übermittlung ins Ausland" | `src/app/datenschutz/page.tsx:105-106` | Widerspricht Stripe/SMTP/Kartendiensten; absolute Auslandsaussage | Ziffer 6 „Bekanntgabe ins Ausland": Auslandbearbeitung je nach Dienstleister möglich | `src/app/datenschutz/page.tsx` (Neuaufbau) |
+| 17 | „Personenbezogene Daten werden nicht an Dritte weitergegeben" | `src/app/datenschutz/page.tsx:91,164` | Absolute „keine Weitergabe" | Dienstleisterliste (Subprozessoren) + „nicht zu Werbezwecken verkauft" | `src/app/datenschutz/page.tsx` (Neuaufbau) |
+| 18 | „Gemäss DSG und DSGVO haben Sie folgende Rechte" | `src/app/datenschutz/page.tsx:144` | Pauschale DSGVO-Anwendbarkeit unbelegt | „Im Rahmen des anwendbaren Rechts …" + Beschwerde bei EDÖB | `src/app/datenschutz/page.tsx` (Neuaufbau) |
+| 19 | „Bei der Löschung werden sämtliche Daten unwiderruflich entfernt" | `src/app/datenschutz/page.tsx:128` | Ignoriert Backups | „Produktivdaten werden nach Abschluss des Löschvorgangs entfernt. Daten in Sicherungskopien können bis zum Ablauf des Backup-Zyklus fortbestehen." | `src/app/datenschutz/page.tsx` (Neuaufbau) |
+| 20 | „Passwörter werden verschlüsselt in der Datenbank gespeichert." | `src/components/admin/settings-tab.tsx:242` | Falsch: gehasht, nicht verschlüsselt | „… mit einem Einwegverfahren (bcrypt) gehasht …" | `src/components/admin/settings-tab.tsx` |
+
+## Nicht beanstandet (Kontext geprüft)
+
+- Zahlreiche `100%` in `rapport-pdf.tsx`, `measure-panel.tsx`, `map-view.tsx`, E-Mail-Templates → CSS-Breitenangaben, keine Werbeaussage.
+- „sicher" in `README.md`, `docs/*`, `jwt-secret.ts`, `modules.ts` → technische Kommentare, nicht öffentlich.
+- „SSL-Zertifikate" (Substantiv) → keine „zertifiziert"-Behauptung.
+
+## Nicht gefunden (im gesamten Repo)
+
+`garantiert`, `fehlerfrei`, `gemeinnützig`, `steuerlich`, `rechtssicher`, `zertifiziert`,
+„immer verfügbar", „kostenlos für immer" — keine Treffer.
+
+## Noch offen (Betreiber-Entscheid)
+
+- Formulierung „In der Schweiz entwickelt": Sobald der Serverstandort für alle Subprozessoren/Backups
+  bestätigt ist, kann ggf. eine präzisere Hosting-Aussage getroffen werden.
+- „Purepixel / Kingstickers Ziberi" (Impressum-Copyright): rechtsverbindliche Betreiberbezeichnung bestätigen.

next.config.js

@@ -6,6 +6,9 @@ const nextConfig = {
     APP_VERSION: packageJson.version,
   },
   output: 'standalone',
+  // Node-Libs für das Backup nicht bundeln, sondern zur Laufzeit aus node_modules laden
+  // (ssh2 hat optionale native Module; webdav/archiver sind reine Server-Abhängigkeiten).
+  serverExternalPackages: ['ssh2', 'ssh2-sftp-client', 'archiver', 'webdav'],
   async headers() {
     return [
       {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lageplan",
-  "version": "1.4.13",
+  "version": "1.9.1",
   "description": "Feuerwehr Lageplan - Krokier-App für Einsatzdokumentation",
   "private": true,
   "scripts": {
@@ -8,6 +8,8 @@
     "build": "next build",
     "start": "next start",
     "lint": "next lint",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "db:generate": "prisma generate",
     "db:push": "prisma db push",
     "db:migrate": "prisma migrate dev",
@@ -41,6 +43,9 @@
     "@radix-ui/react-toast": "^1.2.0",
     "@radix-ui/react-tooltip": "^1.1.0",
     "@react-pdf/renderer": "^4.3.2",
+    "@simplewebauthn/browser": "^13.3.0",
+    "@simplewebauthn/server": "^13.3.2",
+    "archiver": "^8.0.0",
     "bcryptjs": "^2.4.3",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.1.0",
@@ -52,6 +57,7 @@
     "minio": "^7.1.3",
     "next": "^15.1.0",
     "nodemailer": "^6.9.8",
+    "otplib": "^12.0.1",
     "qrcode": "^1.5.4",
     "rdndmb-html5-to-touch": "^9.0.0",
     "react": "^19.0.0",
@@ -63,10 +69,12 @@
     "react-moveable": "^0.56.0",
     "socket.io": "^4.7.4",
     "socket.io-client": "^4.7.4",
+    "ssh2-sftp-client": "^12.1.1",
     "stripe": "^20.3.1",
     "tailwind-merge": "^2.2.1",
     "tailwindcss-animate": "^1.0.7",
     "uuid": "^9.0.1",
+    "webdav": "^5.10.0",
     "zod": "^3.22.4",
     "zustand": "^5.0.11"
   },
@@ -74,11 +82,13 @@
     "seed": "node prisma/seed.js"
   },
   "devDependencies": {
+    "@types/archiver": "^8.0.0",
     "@types/bcryptjs": "^2.4.6",
     "@types/node": "^20.11.0",
     "@types/qrcode": "^1.5.6",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "@types/ssh2-sftp-client": "^9.0.6",
     "@types/uuid": "^9.0.7",
     "autoprefixer": "^10.4.17",
     "eslint": "^8.56.0",
@@ -88,7 +98,8 @@
     "sharp": "^0.34.5",
     "tailwindcss": "^3.4.1",
     "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^4.1.10"
   },
   "browserslist": [
     "last 2 Chrome versions",

prisma/migrate.js

@@ -82,6 +82,15 @@ async function migrate() {
     // Journal
     `ALTER TABLE journal_entries ADD COLUMN IF NOT EXISTS "isCorrected" BOOLEAN DEFAULT false`,
     `ALTER TABLE journal_entries ADD COLUMN IF NOT EXISTS "correctionOfId" TEXT`,
+    // Modul-Baukasten (Cockpit-Konfiguration pro Mandant)
+    `ALTER TABLE tenants ADD COLUMN IF NOT EXISTS "modulesConfig" JSONB`,
+    // Windrichtung fürs Lagebild
+    `ALTER TABLE projects ADD COLUMN IF NOT EXISTS "windDirection" INTEGER`,
+    // Öffentlicher Nur-Ansicht-Teilen-Link (live, optional PIN)
+    `ALTER TABLE projects ADD COLUMN IF NOT EXISTS "shareToken" TEXT`,
+    `ALTER TABLE projects ADD COLUMN IF NOT EXISTS "sharePin" TEXT`,
+    `ALTER TABLE projects ADD COLUMN IF NOT EXISTS "shareEnabled" BOOLEAN NOT NULL DEFAULT false`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS "projects_shareToken_key" ON projects ("shareToken")`,
   ]
   let added = 0
   for (const sql of columnMigrations) {
@@ -131,11 +140,103 @@ async function migrate() {
       "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
       "projectId" TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE
     )`,
+    // Modul-Baukasten: generische Zeilen für Tabellen-Module
+    `CREATE TABLE IF NOT EXISTS module_items (
+      id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
+      "moduleId" TEXT NOT NULL,
+      data JSONB NOT NULL DEFAULT '{}',
+      "sortOrder" INTEGER NOT NULL DEFAULT 0,
+      "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "projectId" TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE
+    )`,
+    `CREATE INDEX IF NOT EXISTS module_items_project_module_idx ON module_items("projectId", "moduleId")`,
+    // Rechtsdokumente (versioniert, bewusst gesetzte Version)
+    `CREATE TABLE IF NOT EXISTS legal_documents (
+      id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
+      type TEXT NOT NULL,
+      version TEXT NOT NULL,
+      title TEXT NOT NULL,
+      "publishedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "effectiveAt" TIMESTAMP(3),
+      "contentHash" TEXT NOT NULL,
+      url TEXT,
+      "isActive" BOOLEAN NOT NULL DEFAULT false,
+      "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(type, version)
+    )`,
+    `CREATE INDEX IF NOT EXISTS legal_documents_type_active_idx ON legal_documents(type, "isActive")`,
+    // Revisionssichere Zustimmungen — nie überschreiben, neue Version = neuer Datensatz
+    `CREATE TABLE IF NOT EXISTS legal_acceptances (
+      id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
+      "userId" TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      "organizationId" TEXT,
+      "documentType" TEXT NOT NULL,
+      "documentVersion" TEXT NOT NULL,
+      "contentHash" TEXT NOT NULL,
+      "acceptedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      locale TEXT,
+      context TEXT NOT NULL,
+      "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE("userId", "organizationId", "documentType", "documentVersion", context)
+    )`,
+    `CREATE INDEX IF NOT EXISTS legal_acceptances_user_idx ON legal_acceptances("userId")`,
+    `CREATE INDEX IF NOT EXISTS legal_acceptances_doc_idx ON legal_acceptances("documentType", "documentVersion")`,
+    `ALTER TABLE legal_acceptances ADD COLUMN IF NOT EXISTS "ipAddress" TEXT`,
+    `ALTER TABLE legal_acceptances ADD COLUMN IF NOT EXISTS "userAgent" TEXT`,
+    // MFA / Zwei-Faktor
+    `ALTER TABLE users ADD COLUMN IF NOT EXISTS "totpSecret" TEXT`,
+    `ALTER TABLE users ADD COLUMN IF NOT EXISTS "totpConfirmedAt" TIMESTAMP(3)`,
+    `ALTER TABLE users ADD COLUMN IF NOT EXISTS "mfaBackupCodes" TEXT[] NOT NULL DEFAULT '{}'`,
+    `CREATE TABLE IF NOT EXISTS webauthn_credentials (
+      id TEXT PRIMARY KEY DEFAULT gen_random_uuid(),
+      "userId" TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      "credentialId" TEXT NOT NULL UNIQUE,
+      "publicKey" TEXT NOT NULL,
+      counter INTEGER NOT NULL DEFAULT 0,
+      transports TEXT,
+      "deviceName" TEXT,
+      "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      "lastUsedAt" TIMESTAMP(3)
+    )`,
+    `CREATE INDEX IF NOT EXISTS webauthn_credentials_user_idx ON webauthn_credentials("userId")`,
   ]
   for (const sql of tableMigrations) {
     try { await prisma.$executeRawUnsafe(sql) } catch (e) { /* table might already exist */ }
   }
 
+  // ─── Step 4b: Rechtsdokumente seeden/aktivieren (idempotent) ───
+  // WICHTIG: Diese Metadaten müssen mit src/config/legal.ts übereinstimmen. Version bewusst
+  // erhöhen, wenn sich der Inhalt WESENTLICH ändert (löst Re-Consent aus).
+  console.log('  [4b] Seeding legal documents...')
+  const crypto = require('crypto')
+  const LEGAL_DOCS = [
+    { type: 'TERMS', version: '1.0.0', title: 'Nutzungsbedingungen', url: '/nutzungsbedingungen', publishedAt: '2026-07-23' },
+    { type: 'PRIVACY', version: '1.0.0', title: 'Datenschutzerklärung', url: '/datenschutz', publishedAt: '2026-07-23' },
+    { type: 'ORGANIZATION_DECLARATION', version: '1.0.0', title: 'Organisationsbestätigung', url: '/verantwortungsvolle-nutzung', publishedAt: '2026-07-23' },
+    { type: 'RESPONSIBLE_USE', version: '1.0.0', title: 'Verantwortungsvolle Nutzung', url: '/verantwortungsvolle-nutzung', publishedAt: '2026-07-23' },
+    { type: 'DATA_PROCESSING_AGREEMENT', version: '1.0.0', title: 'Datenschutzvereinbarung für Organisationen', url: '/organisationen/datenschutzvereinbarung', publishedAt: '2026-07-23' },
+    { type: 'FKS_ATTRIBUTION', version: '1.0.0', title: 'FKS-Quellenangabe & Nutzungshinweis', url: '/quellen-und-lizenzen', publishedAt: '2026-07-24' },
+  ]
+  for (const doc of LEGAL_DOCS) {
+    const contentHash = crypto.createHash('sha256').update(`${doc.type}@${doc.version}`).digest('hex')
+    try {
+      // Neue Version anlegen (falls noch nicht vorhanden), als aktiv markieren
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO legal_documents (type, version, title, url, "contentHash", "publishedAt", "effectiveAt", "isActive")
+         VALUES ($1,$2,$3,$4,$5,$6,$6,true)
+         ON CONFLICT (type, version) DO UPDATE SET title = EXCLUDED.title, url = EXCLUDED.url, "isActive" = true`,
+        doc.type, doc.version, doc.title, doc.url, contentHash, new Date(doc.publishedAt)
+      )
+      // Andere Versionen desselben Typs deaktivieren (nur eine aktive je Typ)
+      await prisma.$executeRawUnsafe(
+        `UPDATE legal_documents SET "isActive" = false WHERE type = $1 AND version <> $2`,
+        doc.type, doc.version
+      )
+    } catch (e) { /* table might not exist yet on very first run */ }
+  }
+
   // ─── Step 5: Set safe defaults ───
   console.log('  [5/7] Setting defaults...')
   try {

prisma/schema.prisma

@@ -74,6 +74,8 @@ model Tenant {
   notes           String?
   hiddenIconIds       String[] @default([])
   journalSuggestions  String[] @default([])
+  // Modul-Baukasten: Cockpit-Konfiguration (siehe src/lib/modules.ts). NULL = Standard.
+  modulesConfig       Json?
 
   // Privacy consent
   privacyAccepted      Boolean  @default(false)
@@ -124,6 +126,12 @@ model User {
   resetToken      String?  @unique
   resetTokenExpiry DateTime?
   lastLoginAt     DateTime?
+  // ─── Zwei-Faktor-Authentisierung (MFA) ───
+  // TOTP (Authenticator-App): Secret gesetzt = Einrichtung begonnen; confirmedAt gesetzt = aktiv.
+  totpSecret      String?
+  totpConfirmedAt DateTime?
+  // Einmalige Backup-Codes (bcrypt-gehasht), Fallback wenn kein Faktor verfügbar.
+  mfaBackupCodes  String[] @default([])
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
@@ -132,10 +140,78 @@ model User {
   iconAssets        IconAsset[]
   upgradeRequests   UpgradeRequest[]
   rapports          Rapport[]
+  legalAcceptances  LegalAcceptance[]
+  webauthnCredentials WebAuthnCredential[]
 
   @@map("users")
 }
 
+// WebAuthn/FIDO2 (YubiKey, Passkeys, Touch-ID) — registrierte Sicherheitsschlüssel je Benutzer.
+model WebAuthnCredential {
+  id           String    @id @default(uuid())
+  userId       String
+  credentialId String    @unique
+  publicKey    String
+  counter      Int       @default(0)
+  transports   String?
+  deviceName   String?
+  createdAt    DateTime  @default(now())
+  lastUsedAt   DateTime?
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("webauthn_credentials")
+}
+
+// ─── Rechtsdokumente & revisionssichere Zustimmungen ──────────
+// Dokumenttypen (als String gehalten, damit die idempotente Raw-SQL-Migration einfach bleibt):
+//   TERMS | PRIVACY | ORGANIZATION_DECLARATION | RESPONSIBLE_USE | DATA_PROCESSING_AGREEMENT
+
+model LegalDocument {
+  id          String    @id @default(uuid())
+  type        String
+  version     String
+  title       String
+  publishedAt DateTime  @default(now())
+  effectiveAt DateTime?
+  contentHash String
+  url         String?
+  isActive    Boolean   @default(false)
+  createdAt   DateTime  @default(now())
+  updatedAt   DateTime  @updatedAt
+
+  @@unique([type, version])
+  @@index([type, isActive])
+  @@map("legal_documents")
+}
+
+model LegalAcceptance {
+  id              String   @id @default(uuid())
+  userId          String
+  // NULL = persönliche Zustimmung (nicht organisationsbezogen)
+  organizationId  String?
+  documentType    String
+  documentVersion String
+  contentHash     String
+  acceptedAt      DateTime @default(now())
+  locale          String?
+  // REGISTRATION | LOGIN_RECONSENT | ORGANIZATION_CREATION | ADMIN_ROLE_ACCEPTANCE | DONATION
+  context         String
+  // Nachweisdaten (zu Beweiszwecken der Einwilligung): IP + Gerät/Browser zum Zeitpunkt der Zustimmung.
+  ipAddress       String?
+  userAgent       String?
+  createdAt       DateTime @default(now())
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  // Verhindert doppelte identische Zustimmungen; neue Version erzeugt neuen Datensatz.
+  @@unique([userId, organizationId, documentType, documentVersion, context])
+  @@index([userId])
+  @@index([documentType, documentVersion])
+  @@map("legal_acceptances")
+}
+
 model TenantMembership {
   id        String   @id @default(uuid())
   role      Role     @default(OPERATOR)
@@ -165,12 +241,20 @@ model Project {
   journalfuehrer String?
   mapCenter      Json     @default("{\"lng\": 8.5417, \"lat\": 47.3769}")
   mapZoom        Float    @default(15)
+  // Windrichtung in Grad (meteorologisch „Wind aus"), fürs Lagebild. NULL = nicht gesetzt.
+  windDirection  Int?
   isLocked    Boolean  @default(false)
   // Optimistische Nebenläufigkeit: wird bei jedem Features-Speichern hochgezählt.
   // Verhindert, dass ein veralteter (z.B. offline zwischengespeicherter) Stand
   // neuere Änderungen stillschweigend überschreibt.
   featuresVersion Int   @default(0)
 
+  // Öffentlicher Nur-Ansicht-Teilen-Link (live). shareToken = zufälliger Slug im Link,
+  // sharePin = bcrypt-Hash einer optionalen PIN (NULL = keine PIN), shareEnabled = aktiv/aus.
+  shareToken   String?  @unique
+  sharePin     String?
+  shareEnabled Boolean  @default(false)
+
   // Live editing lock (session-based for same-account multi-device)
   editingById       String?
   editingUserName   String?
@@ -193,6 +277,7 @@ model Project {
   journalPendenzen  JournalPendenz[]
   exerciseGoals     ExerciseGoal[]
   rapports          Rapport[]
+  moduleItems       ModuleItem[]
 
   @@map("projects")
 }
@@ -349,6 +434,24 @@ model JournalPendenz {
   @@map("journal_pendenzen")
 }
 
+// Generischer Datenspeicher für Tabellen-Module (Modul-Baukasten).
+// data enthält die Zellwerte gemäss Spaltendefinition des Moduls,
+// z.B. { "trupp": "Trupp 1", "druck": "280", "out": true, "outAt": "..." }
+model ModuleItem {
+  id        String   @id @default(uuid())
+  moduleId  String
+  data      Json     @default("{}")
+  sortOrder Int      @default(0)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  projectId String
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
+
+  @@index([projectId, moduleId])
+  @@map("module_items")
+}
+
 model JournalCheckTemplate {
   id        String   @id @default(uuid())
   label     String

scripts/decrypt-backup.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Entschlüsselt ein Lageplan-Backup (.tar.gz.enc) → .tar.gz
+ *
+ * Verwendung:
+ *   node scripts/decrypt-backup.js <input.tar.gz.enc> <output.tar.gz> [passphrase]
+ *   (ohne Passphrase-Argument wird sie interaktiv abgefragt bzw. aus BACKUP_PASSPHRASE gelesen)
+ *
+ * Danach:
+ *   tar xzf output.tar.gz          → enthält database.dump + files/<uploads>
+ *   pg_restore --clean --if-exists -d <DB> database.dump
+ *   files/ zurück in MinIO spielen (siehe docs/BACKUP.md)
+ *
+ * Format der .enc-Datei: [salt(16)][iv(12)][ciphertext][tag(16)], AES-256-GCM, Key = scrypt(passphrase, salt).
+ */
+const fs = require('fs')
+const crypto = require('crypto')
+
+const [inPath, outPath] = process.argv.slice(2)
+let passphrase = process.argv[4] || process.env.BACKUP_PASSPHRASE
+
+if (!inPath || !outPath) {
+  console.error('Verwendung: node decrypt-backup.js <input.tar.gz.enc> <output.tar.gz> [passphrase]')
+  process.exit(1)
+}
+if (!passphrase) {
+  console.error('Passphrase fehlt. Als 3. Argument oder via BACKUP_PASSPHRASE übergeben.')
+  process.exit(1)
+}
+
+const size = fs.statSync(inPath).size
+if (size < 44) { console.error('Datei zu klein / kein gültiges Backup.'); process.exit(1) }
+
+const fd = fs.openSync(inPath, 'r')
+const head = Buffer.alloc(28)
+fs.readSync(fd, head, 0, 28, 0)
+const tag = Buffer.alloc(16)
+fs.readSync(fd, tag, 0, 16, size - 16)
+fs.closeSync(fd)
+
+const salt = head.subarray(0, 16)
+const iv = head.subarray(16, 28)
+const key = crypto.scryptSync(passphrase, salt, 32)
+const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv)
+decipher.setAuthTag(tag)
+
+const input = fs.createReadStream(inPath, { start: 28, end: size - 17 })
+const output = fs.createWriteStream(outPath)
+input.pipe(decipher).pipe(output)
+output.on('finish', () => console.log('OK →', outPath))
+decipher.on('error', (e) => { console.error('Entschlüsselung fehlgeschlagen (falsche Passphrase?):', e.message); process.exit(1) })

scripts/restore.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+# =============================================================
+# Lageplan – Restore-Helfer
+# =============================================================
+# Stellt einen Datenbank-Dump (und optional die Dateien) wieder her.
+# ACHTUNG: Der DB-Restore ist DESTRUKTIV – bestehende Daten werden ersetzt.
+# Vorher die Web-App stoppen und sicherstellen, dass niemand arbeitet.
+#
+# Verwendung (auf dem Server, im Verzeichnis mit der docker-compose.yml):
+#
+#   1) Verfügbare Backups anzeigen:
+#        docker compose exec backup ls -lh /backups
+#
+#   2) Datenbank wiederherstellen (Dateiname aus Schritt 1):
+#        docker compose exec backup sh /scripts/restore.sh db_2026-07-23_030000.dump
+#      (funktioniert nur, wenn dieses Verzeichnis in den backup-Container gemountet ist;
+#       sonst den Befehl aus dem Abschnitt "Ohne Skript" in docs/BACKUP.md nutzen.)
+#
+#   3) Dateien (Uploads) wiederherstellen: siehe docs/BACKUP.md
+# =============================================================
+set -eu
+
+DUMP="${1:-}"
+BACKUP_DIR="${BACKUP_DIR:-/backups}"
+PGHOST="${PGHOST:-db}"
+PGUSER="${PGUSER:-lageplan}"
+PGDATABASE="${PGDATABASE:-lageplan}"
+
+if [ -z "$DUMP" ]; then
+  echo "Verwendung: restore.sh <db_dumpfile>"
+  echo "Verfuegbare Dumps in $BACKUP_DIR:"
+  ls -1 "$BACKUP_DIR"/db_*.dump 2>/dev/null || echo "  (keine gefunden)"
+  exit 1
+fi
+
+FILE="$BACKUP_DIR/$DUMP"
+[ -f "$FILE" ] || { echo "Nicht gefunden: $FILE"; exit 1; }
+
+echo "!! DESTRUKTIV: Stelle '$DUMP' in Datenbank '$PGDATABASE' auf Host '$PGHOST' wieder her."
+echo "   Bestehende Daten werden ersetzt. Abbruch mit Ctrl+C, weiter mit Enter."
+read -r _
+
+pg_restore --clean --if-exists --no-owner -h "$PGHOST" -U "$PGUSER" -d "$PGDATABASE" "$FILE"
+echo "[restore] Datenbank wiederhergestellt aus $DUMP"

server-custom.js

@@ -71,4 +71,21 @@ app.prepare().then(() => {
   httpServer.listen(port, hostname, () => {
     console.log(`> Ready on http://${hostname}:${port}`)
   })
+
+  // Backup-Scheduler: stündlich prüfen, ob laut Zeitplan ein Backup fällig ist.
+  // Die Route /api/cron/backup entscheidet anhand der Konfiguration; hier wird nur getriggert.
+  if (process.env.CRON_SECRET) {
+    const checkBackup = () => {
+      fetch(`http://127.0.0.1:${port}/api/cron/backup`, {
+        method: 'POST',
+        headers: { 'x-cron-secret': process.env.CRON_SECRET },
+      })
+        .then((r) => r.json())
+        .then((d) => { if (d && d.skipped !== true) console.log('[backup-scheduler]', JSON.stringify(d)) })
+        .catch((e) => console.warn('[backup-scheduler]', e.message))
+    }
+    setInterval(checkBackup, 60 * 60 * 1000) // stündlich
+    setTimeout(checkBackup, 90 * 1000)       // ~1.5 Min nach Start einmal
+    console.log('> Backup-Scheduler aktiv (stündliche Fälligkeitsprüfung)')
+  }
 })

src/app/admin/legal/page.tsx

@@ -0,0 +1,164 @@
+'use client'
+
+import { useEffect, useState, useCallback } from 'react'
+import { useRouter } from 'next/navigation'
+import Link from 'next/link'
+import { ArrowLeft, Download, Search, Loader2, FileText, AlertTriangle } from 'lucide-react'
+import { useAuth } from '@/components/providers/auth-provider'
+
+interface Doc { id: string; type: string; version: string; title: string; url: string | null; isActive: boolean; publishedAt: string; contentHash: string; acceptanceCount: number }
+interface Miss { type: string; version: string; missing: number }
+interface Acc { id: string; email: string; name: string; documentType: string; documentVersion: string; context: string; acceptedAt: string; organizationId: string | null; ipAddress: string | null; userAgent: string | null; contentHash: string | null }
+
+export default function AdminLegalPage() {
+  const { user, loading, isServerAdmin } = useAuth()
+  const router = useRouter()
+  const [data, setData] = useState<{ documents: Doc[]; totalActiveUsers: number; missing: Miss[] } | null>(null)
+  const [q, setQ] = useState('')
+  const [results, setResults] = useState<Acc[] | null>(null)
+  const [searching, setSearching] = useState(false)
+
+  useEffect(() => {
+    if (loading) return
+    if (!user || !isServerAdmin()) { router.replace('/app'); return }
+    fetch('/api/admin/legal').then(r => r.json()).then(setData).catch(() => setData(null))
+  }, [loading, user, isServerAdmin, router])
+
+  const search = useCallback(async () => {
+    setSearching(true)
+    try {
+      const res = await fetch(`/api/admin/legal/acceptances?q=${encodeURIComponent(q)}`)
+      const d = await res.json()
+      setResults(d.acceptances || [])
+    } catch { setResults([]) } finally { setSearching(false) }
+  }, [q])
+
+  if (loading || !data) {
+    return <div className="min-h-screen flex items-center justify-center"><Loader2 className="w-6 h-6 animate-spin text-muted-foreground" /></div>
+  }
+
+  return (
+    <div className="min-h-screen bg-background px-4 py-8">
+      <div className="max-w-4xl mx-auto">
+        <Link href="/admin" className="text-sm text-muted-foreground hover:text-foreground inline-flex items-center gap-1 mb-6">
+          <ArrowLeft className="w-3.5 h-3.5" /> Zur Administration
+        </Link>
+
+        <h1 className="text-2xl font-bold text-foreground flex items-center gap-2">
+          <FileText className="w-6 h-6 text-red-600" /> Rechtsdokumente &amp; Zustimmungen
+        </h1>
+        <p className="text-sm text-muted-foreground mt-1">
+          Aktive Benutzer: {data.totalActiveUsers}. Neue Versionen werden bewusst über <code>src/config/legal.ts</code>{' '}
+          und die Migration veröffentlicht (löst Re-Consent aus).
+        </p>
+
+        {/* Fehlende Zustimmungen */}
+        {data.missing.some(m => m.missing > 0) && (
+          <div className="mt-4 rounded-lg border border-amber-300 bg-amber-50 dark:bg-amber-950/30 dark:border-amber-800 p-3 text-sm text-amber-800 dark:text-amber-300 flex items-start gap-2">
+            <AlertTriangle className="w-4 h-4 mt-0.5 shrink-0" />
+            <div>
+              <strong>Offene Pflicht-Zustimmungen:</strong>
+              <ul className="mt-1">
+                {data.missing.filter(m => m.missing > 0).map(m => (
+                  <li key={`${m.type}@${m.version}`}>{m.type} v{m.version}: {m.missing} Benutzer offen</li>
+                ))}
+              </ul>
+            </div>
+          </div>
+        )}
+
+        {/* Dokumente */}
+        <section className="mt-6">
+          <h2 className="font-semibold text-foreground mb-2">Dokumentversionen</h2>
+          <div className="overflow-x-auto rounded-lg border border-border">
+            <table className="w-full text-sm">
+              <thead className="bg-muted/40 text-left text-xs text-muted-foreground">
+                <tr>
+                  <th className="px-3 py-2">Typ</th>
+                  <th className="px-3 py-2">Version</th>
+                  <th className="px-3 py-2">Veröffentlicht</th>
+                  <th className="px-3 py-2">Status</th>
+                  <th className="px-3 py-2">Zustimmungen</th>
+                  <th className="px-3 py-2">Hash</th>
+                </tr>
+              </thead>
+              <tbody>
+                {data.documents.map(d => (
+                  <tr key={d.id} className="border-t border-border">
+                    <td className="px-3 py-2 font-medium text-foreground">{d.type}</td>
+                    <td className="px-3 py-2">{d.version}</td>
+                    <td className="px-3 py-2 text-muted-foreground">{new Date(d.publishedAt).toLocaleDateString('de-CH')}</td>
+                    <td className="px-3 py-2">
+                      {d.isActive
+                        ? <span className="rounded-full bg-green-100 text-green-700 dark:bg-green-950/40 dark:text-green-400 px-2 py-0.5 text-xs">aktiv</span>
+                        : <span className="rounded-full bg-muted text-muted-foreground px-2 py-0.5 text-xs">inaktiv</span>}
+                    </td>
+                    <td className="px-3 py-2 tabular-nums">{d.acceptanceCount}</td>
+                    <td className="px-3 py-2 font-mono text-[10px] text-muted-foreground">{d.contentHash.slice(0, 12)}…</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </section>
+
+        {/* Suche + Export */}
+        <section className="mt-8">
+          <div className="flex items-center justify-between gap-2 mb-2">
+            <h2 className="font-semibold text-foreground">Zustimmungshistorie</h2>
+            <a
+              href={`/api/admin/legal/acceptances?format=csv&q=${encodeURIComponent(q)}`}
+              className="inline-flex items-center gap-1.5 text-sm text-red-600 hover:underline"
+            >
+              <Download className="w-4 h-4" /> CSV exportieren
+            </a>
+          </div>
+          <form onSubmit={e => { e.preventDefault(); search() }} className="flex gap-2 mb-3">
+            <input
+              value={q}
+              onChange={e => setQ(e.target.value)}
+              placeholder="Nach Benutzer (E-Mail/Name) suchen…"
+              className="flex-1 rounded-lg border border-border bg-background px-3 py-2 text-sm"
+            />
+            <button type="submit" disabled={searching} className="inline-flex items-center gap-1.5 rounded-lg bg-red-600 hover:bg-red-700 text-white px-4 py-2 text-sm font-medium disabled:opacity-50">
+              {searching ? <Loader2 className="w-4 h-4 animate-spin" /> : <Search className="w-4 h-4" />} Suchen
+            </button>
+          </form>
+
+          {results && (
+            results.length === 0
+              ? <p className="text-sm text-muted-foreground">Keine Zustimmungen gefunden.</p>
+              : (
+                <div className="overflow-x-auto rounded-lg border border-border">
+                  <table className="w-full text-sm">
+                    <thead className="bg-muted/40 text-left text-xs text-muted-foreground">
+                      <tr>
+                        <th className="px-3 py-2">Zeitpunkt</th>
+                        <th className="px-3 py-2">Benutzer</th>
+                        <th className="px-3 py-2">Dokument</th>
+                        <th className="px-3 py-2">Kontext</th>
+                        <th className="px-3 py-2">IP</th>
+                        <th className="px-3 py-2">Gerät / Browser</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {results.map(a => (
+                        <tr key={a.id} className="border-t border-border">
+                          <td className="px-3 py-2 text-muted-foreground whitespace-nowrap">{new Date(a.acceptedAt).toLocaleString('de-CH', { dateStyle: 'short', timeStyle: 'short' })}</td>
+                          <td className="px-3 py-2"><span className="text-foreground">{a.name}</span><br /><span className="text-xs text-muted-foreground">{a.email}</span></td>
+                          <td className="px-3 py-2">{a.documentType} <span className="text-muted-foreground">v{a.documentVersion}</span>{a.contentHash && <><br /><span className="font-mono text-[10px] text-muted-foreground">{a.contentHash.slice(0, 12)}…</span></>}</td>
+                          <td className="px-3 py-2 text-xs text-muted-foreground">{a.context}</td>
+                          <td className="px-3 py-2 text-xs text-muted-foreground font-mono whitespace-nowrap">{a.ipAddress || '—'}</td>
+                          <td className="px-3 py-2 text-[10px] text-muted-foreground max-w-[200px] truncate" title={a.userAgent || ''}>{a.userAgent || '—'}</td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                </div>
+              )
+          )}
+        </section>
+      </div>
+    </div>
+  )
+}

src/app/admin/page.tsx

@@ -9,6 +9,7 @@ import { useAuth } from '@/components/providers/auth-provider'
 import {
   ArrowLeft, MapPin, Shield, Map, Image as ImageIcon, Layers, BookOpen,
   Users, Settings, Building2, AlertTriangle, ClipboardList, Heart, ShieldCheck, Loader2,
+  HardDriveDownload,
 } from 'lucide-react'
 import { TenantsTab } from '@/components/admin/tenants-tab'
 import { UsersTab } from '@/components/admin/users-tab'
@@ -21,6 +22,7 @@ import { SuggestionsTab } from '@/components/admin/suggestions-tab'
 import { DictionaryTab } from '@/components/admin/dictionary-tab'
 import { SymbolManager } from '@/components/admin/symbol-manager'
 import { OrgTab } from '@/components/admin/org-tab'
+import { BackupTab } from '@/components/admin/backup-tab'
 import { HoseSettingsDialog } from '@/components/dialogs/hose-settings-dialog'
 
 export default function AdminPage() {
@@ -57,33 +59,31 @@ export default function AdminPage() {
   return (
     <div className="min-h-screen bg-background">
       {/* Header */}
-      <header className="h-14 border-b border-border bg-card flex items-center justify-between px-6">
+      <header className="h-14 border-b border-border bg-card flex items-center justify-between px-3 md:px-6 gap-2">
-        <div className="flex items-center gap-4">
+        <div className="flex items-center gap-2 md:gap-4 min-w-0">
           <Link href="/app">
-            <Button variant="ghost" size="sm">
+            <Button variant="ghost" size="sm" className="px-2 shrink-0">
-              <ArrowLeft className="w-4 h-4 mr-2" />
+              <ArrowLeft className="w-4 h-4 md:mr-2" />
-              Zurück zur App
+              <span className="hidden sm:inline">Zurück zur App</span>
             </Button>
           </Link>
-          <div className="h-6 w-px bg-border" />
+          <div className="hidden sm:block h-6 w-px bg-border" />
-          <div className="flex items-center gap-2">
+          <div className="flex items-center gap-2 min-w-0">
-            <MapPin className="w-5 h-5 text-primary" />
+            <MapPin className="w-5 h-5 text-primary shrink-0" />
-            <h1 className="font-semibold text-lg">Administration</h1>
+            <h1 className="font-semibold text-base md:text-lg truncate">Administration</h1>
           </div>
         </div>
-        <div className="flex items-center gap-3">
+        <div className="flex items-center gap-2 text-sm min-w-0 shrink-0">
-          <div className="flex items-center gap-2 text-sm">
+          <Shield className="w-4 h-4 text-primary shrink-0 hidden sm:block" />
-            <Shield className="w-4 h-4 text-primary" />
+          <span className="font-medium truncate max-w-[100px] md:max-w-none">{user.name}</span>
-            <span className="font-medium">{user.name}</span>
+          <span className="hidden sm:inline text-xs bg-primary/10 text-primary px-2 py-0.5 rounded-full">{user.role}</span>
-            <span className="text-xs bg-primary/10 text-primary px-2 py-0.5 rounded-full">{user.role}</span>
-          </div>
         </div>
       </header>
 
       <div className="container mx-auto py-6 px-4 max-w-7xl">
         <Tabs value={activeTab} onValueChange={setActiveTab} className="space-y-6">
           {isServerAdmin ? (
-            <TabsList className="grid w-full grid-cols-7 max-w-4xl">
+            <TabsList className="w-full max-w-5xl h-auto flex flex-nowrap overflow-x-auto justify-start md:grid md:grid-cols-8 [&>button]:shrink-0 [&>button]:whitespace-nowrap">
               <TabsTrigger value="tenants" className="gap-2"><Shield className="w-4 h-4" />Mandanten</TabsTrigger>
               <TabsTrigger value="projects" className="gap-2"><Map className="w-4 h-4" />Einsätze</TabsTrigger>
               <TabsTrigger value="icons" className="gap-2"><ImageIcon className="w-4 h-4" />Symbole</TabsTrigger>
@@ -91,16 +91,17 @@ export default function AdminPage() {
               <TabsTrigger value="dictionary" className="gap-2"><BookOpen className="w-4 h-4" />Wörterbuch</TabsTrigger>
               <TabsTrigger value="users" className="gap-2"><Users className="w-4 h-4" />Benutzer</TabsTrigger>
               <TabsTrigger value="settings" className="gap-2"><Settings className="w-4 h-4" />System</TabsTrigger>
+              <TabsTrigger value="backup" className="gap-2"><HardDriveDownload className="w-4 h-4" />Backup</TabsTrigger>
             </TabsList>
           ) : (
-            <TabsList className="grid w-full grid-cols-7 max-w-4xl">
+            <TabsList className="w-full max-w-4xl h-auto flex flex-nowrap overflow-x-auto justify-start md:grid md:grid-cols-7 [&>button]:shrink-0 [&>button]:whitespace-nowrap">
               <TabsTrigger value="org" className="gap-2"><Building2 className="w-4 h-4" />Organisation</TabsTrigger>
               <TabsTrigger value="users" className="gap-2"><Users className="w-4 h-4" />Benutzer</TabsTrigger>
               <TabsTrigger value="icons" className="gap-2"><ImageIcon className="w-4 h-4" />Symbole</TabsTrigger>
               <TabsTrigger value="soma" className="gap-2"><AlertTriangle className="w-4 h-4" />SOMA</TabsTrigger>
               <TabsTrigger value="suggestions" className="gap-2"><ClipboardList className="w-4 h-4" />Wörterliste</TabsTrigger>
               <TabsTrigger value="hose-types" className="gap-2"><Settings className="w-4 h-4" />Schläuche</TabsTrigger>
-              <TabsTrigger value="donate" className="gap-2"><Heart className="w-4 h-4" />Spenden</TabsTrigger>
+              <TabsTrigger value="donate" className="gap-2"><Heart className="w-4 h-4" />Unterstützung</TabsTrigger>
             </TabsList>
           )}
 
@@ -123,6 +124,10 @@ export default function AdminPage() {
             </TabsContent>
           )}
 
+          {isServerAdmin && (
+            <TabsContent value="backup"><BackupTab /></TabsContent>
+          )}
+
           {/* ===== Geteilt: Benutzer ===== */}
           <TabsContent value="users"><UsersTab /></TabsContent>
 
@@ -169,14 +174,14 @@ export default function AdminPage() {
                     <h3 className="font-semibold text-lg">Lageplan unterstützen</h3>
                     <p className="text-sm text-muted-foreground mt-1">
                       Lageplan ist ein kostenloses Projekt — entwickelt von einem aktiven Feuerwehrmann
-                      in seiner Freizeit. Ohne Firma, ohne Investoren. Deine Spende hilft, den Betrieb und die
+                      in seiner Freizeit. Ein freiwilliger Beitrag hilft, den Betrieb und die
                       Weiterentwicklung zu finanzieren.
                     </p>
                   </div>
                 </div>
 
                 <div className="bg-muted/50 rounded-lg p-4 mb-6">
-                  <p className="text-sm font-medium mb-2">Wohin fliesst deine Spende?</p>
+                  <p className="text-sm font-medium mb-2">Wohin fliesst dein Beitrag?</p>
                   <ul className="text-sm text-muted-foreground space-y-1">
                     <li className="flex items-center gap-2"><Shield className="w-3.5 h-3.5 text-primary shrink-0" /> Server-Hosting in der Schweiz (monatliche Kosten)</li>
                     <li className="flex items-center gap-2"><Settings className="w-3.5 h-3.5 text-primary shrink-0" /> Entwicklung neuer Features und Bugfixes</li>
@@ -188,7 +193,7 @@ export default function AdminPage() {
                   <Button asChild>
                     <a href="/spenden" target="_blank" rel="noopener noreferrer">
                       <Heart className="w-4 h-4 mr-2" />
-                      Jetzt spenden
+                      Jetzt unterstützen
                     </a>
                   </Button>
                   <Button variant="outline" asChild>

src/app/api/admin/backup/config/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { encryptSecret } from '@/lib/crypto-secret'
+import { loadBackupConfig, saveBackupConfig, maskBackupConfig, DEFAULT_BACKUP_CONFIG, type BackupConfig } from '@/lib/backup/config'
+
+// Backup ist plattformweit → nur SERVER_ADMIN.
+async function guard() {
+  const user = await getSession()
+  if (!user || user.role !== 'SERVER_ADMIN') return null
+  return user
+}
+
+export async function GET() {
+  if (!(await guard())) return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+  const cfg = (await loadBackupConfig()) || DEFAULT_BACKUP_CONFIG
+  return NextResponse.json(maskBackupConfig(cfg))
+}
+
+export async function PUT(req: NextRequest) {
+  if (!(await guard())) return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+  const body = await req.json().catch(() => ({}))
+  const existing = (await loadBackupConfig()) || DEFAULT_BACKUP_CONFIG
+
+  const next: BackupConfig = { ...existing }
+  next.enabled = !!body.enabled
+  next.schedule = ['off', 'daily', 'weekly'].includes(body.schedule) ? body.schedule : 'off'
+  next.retentionDays = Math.max(1, Math.min(3650, Number(body.retentionDays) || 30))
+  next.destinationType = body.destinationType === 'webdav' ? 'webdav' : 'sftp'
+
+  // Passphrase nur ersetzen, wenn neu eingegeben
+  if (typeof body.passphrase === 'string' && body.passphrase.length > 0) {
+    next.encryptPassphrase = encryptSecret(body.passphrase)
+  }
+
+  if (body.sftp) {
+    next.sftp = {
+      host: String(body.sftp.host || ''),
+      port: Number(body.sftp.port) || 22,
+      username: String(body.sftp.username || ''),
+      remotePath: String(body.sftp.remotePath || '/lageplan-backups'),
+      password: body.sftp.password ? encryptSecret(String(body.sftp.password)) : (existing.sftp?.password || ''),
+    }
+  }
+  if (body.webdav) {
+    next.webdav = {
+      url: String(body.webdav.url || ''),
+      username: String(body.webdav.username || ''),
+      remotePath: String(body.webdav.remotePath || '/Lageplan-Backups'),
+      password: body.webdav.password ? encryptSecret(String(body.webdav.password)) : (existing.webdav?.password || ''),
+    }
+  }
+
+  await saveBackupConfig(next)
+  return NextResponse.json(maskBackupConfig(next))
+}

src/app/api/admin/backup/run/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { runBackup } from '@/lib/backup/engine'
+
+// POST: löst sofort ein Backup aus (manuell „Jetzt sichern"). Nur SERVER_ADMIN.
+export async function POST() {
+  try {
+    const user = await getSession()
+    if (!user || user.role !== 'SERVER_ADMIN') {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+    const res = await runBackup()
+    return NextResponse.json(res)
+  } catch (e: any) {
+    return NextResponse.json({ ok: false, message: e?.message || 'Backup fehlgeschlagen' }, { status: 500 })
+  }
+}

src/app/api/admin/backup/test/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { loadBackupConfig } from '@/lib/backup/config'
+import { plainDestFromConfig } from '@/lib/backup/secrets'
+import { testDestination } from '@/lib/backup/destinations'
+
+// POST: testet die gespeicherte Zielverbindung (Verbindung + Schreibzugriff). Nur SERVER_ADMIN.
+export async function POST() {
+  try {
+    const user = await getSession()
+    if (!user || user.role !== 'SERVER_ADMIN') {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+    const cfg = await loadBackupConfig()
+    if (!cfg) return NextResponse.json({ ok: false, message: 'Bitte zuerst konfigurieren und speichern.' }, { status: 400 })
+
+    const dest = plainDestFromConfig(cfg)
+    const res = await testDestination(cfg.destinationType, dest)
+    return NextResponse.json(res, { status: res.ok ? 200 : 400 })
+  } catch (e: any) {
+    return NextResponse.json({ ok: false, message: e?.message || 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/admin/legal/acceptances/route.ts

@@ -0,0 +1,65 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// GET: Zustimmungshistorie suchen (nach Benutzer-E-Mail/Name oder Organisation).
+// Query: ?q=<suchbegriff>&format=json|csv  (nur SERVER_ADMIN)
+export async function GET(req: NextRequest) {
+  try {
+    const user = await getSession()
+    if (!user || user.role !== 'SERVER_ADMIN') {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+
+    const q = (req.nextUrl.searchParams.get('q') || '').trim()
+    const format = req.nextUrl.searchParams.get('format') || 'json'
+
+    // Passende Benutzer ermitteln (falls Suchbegriff gesetzt)
+    let userFilter: any = {}
+    if (q) {
+      const users = await (prisma as any).user.findMany({
+        where: { OR: [{ email: { contains: q, mode: 'insensitive' } }, { name: { contains: q, mode: 'insensitive' } }] },
+        select: { id: true },
+        take: 500,
+      })
+      userFilter = { userId: { in: users.map((u: any) => u.id) } }
+    }
+
+    const acceptances = await (prisma as any).legalAcceptance.findMany({
+      where: userFilter,
+      orderBy: { acceptedAt: 'desc' },
+      take: 2000,
+      select: { id: true, userId: true, organizationId: true, documentType: true, documentVersion: true, context: true, acceptedAt: true, contentHash: true, ipAddress: true, userAgent: true },
+    })
+
+    // Nur die notwendigen Nachweisdaten anreichern (E-Mail/Name) — keine überflüssigen Personendaten.
+    const userIds = Array.from(new Set(acceptances.map((a: any) => a.userId)))
+    const users = await (prisma as any).user.findMany({ where: { id: { in: userIds } }, select: { id: true, email: true, name: true } })
+    const uMap = new Map<string, any>(users.map((u: any) => [u.id, u]))
+    const rows = acceptances.map((a: any) => ({
+      ...a,
+      email: uMap.get(a.userId)?.email || '',
+      name: uMap.get(a.userId)?.name || '',
+    }))
+
+    if (format === 'csv') {
+      const header = ['acceptedAt', 'email', 'name', 'documentType', 'documentVersion', 'context', 'ipAddress', 'userAgent', 'contentHash', 'organizationId']
+      const esc = (v: any) => `"${String(v ?? '').replace(/"/g, '""')}"`
+      const lines = [header.join(',')]
+      for (const r of rows) {
+        lines.push([new Date(r.acceptedAt).toISOString(), r.email, r.name, r.documentType, r.documentVersion, r.context, r.ipAddress || '', r.userAgent || '', r.contentHash || '', r.organizationId || ''].map(esc).join(','))
+      }
+      return new NextResponse(lines.join('\r\n'), {
+        headers: {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': `attachment; filename="zustimmungen-${new Date().toISOString().slice(0, 10)}.csv"`,
+        },
+      })
+    }
+
+    return NextResponse.json({ acceptances: rows })
+  } catch (error) {
+    console.error('Error searching acceptances:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/admin/legal/route.ts

@@ -0,0 +1,45 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// GET: Übersicht für Systemadministratoren — aktive Dokumente, Zustimmungszahlen je Version,
+// fehlende Zustimmungen (aktive Benutzer ohne aktuelle TERMS/PRIVACY-Zustimmung).
+export async function GET() {
+  try {
+    const user = await getSession()
+    if (!user || user.role !== 'SERVER_ADMIN') {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+
+    const documents = await (prisma as any).legalDocument.findMany({
+      orderBy: [{ type: 'asc' }, { publishedAt: 'desc' }],
+    })
+
+    // Zustimmungszahlen je (Typ, Version)
+    const grouped = await (prisma as any).legalAcceptance.groupBy({
+      by: ['documentType', 'documentVersion'],
+      _count: { _all: true },
+    })
+    const countMap = new Map<string, number>()
+    for (const g of grouped) countMap.set(`${g.documentType}@${g.documentVersion}`, g._count._all)
+
+    const withCounts = documents.map((d: any) => ({
+      ...d,
+      acceptanceCount: countMap.get(`${d.type}@${d.version}`) || 0,
+    }))
+
+    // Fehlende Pflicht-Zustimmungen: aktive Benutzer, die aktive TERMS/PRIVACY nicht akzeptiert haben
+    const activeRequired = documents.filter((d: any) => d.isActive && (d.type === 'TERMS' || d.type === 'PRIVACY'))
+    const totalUsers = await (prisma as any).user.count({ where: { isActive: true } })
+    const missing: { type: string; version: string; missing: number }[] = []
+    for (const doc of activeRequired) {
+      const accepted = countMap.get(`${doc.type}@${doc.version}`) || 0
+      missing.push({ type: doc.type, version: doc.version, missing: Math.max(0, totalUsers - accepted) })
+    }
+
+    return NextResponse.json({ documents: withCounts, totalActiveUsers: totalUsers, missing })
+  } catch (error) {
+    console.error('Error fetching admin legal overview:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/admin/users/[id]/mfa-reset/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession, isAdmin } from '@/lib/auth'
+
+// POST: setzt die MFA eines Benutzers zurück (TOTP + Backup-Codes + WebAuthn entfernen).
+// SERVER_ADMIN: jeden Benutzer. TENANT_ADMIN: nur Benutzer der eigenen Organisation.
+export async function POST(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params
+    const session = await getSession()
+    if (!session || !isAdmin(session.role)) {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+
+    // TENANT_ADMIN darf nur eigene Organisationsmitglieder zurücksetzen.
+    if (session.role !== 'SERVER_ADMIN') {
+      if (!session.tenantId) return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+      const membership = await (prisma as any).tenantMembership.findFirst({
+        where: { userId: id, tenantId: session.tenantId },
+        select: { id: true },
+      })
+      if (!membership) return NextResponse.json({ error: 'Benutzer nicht in Ihrer Organisation' }, { status: 403 })
+    }
+
+    await (prisma as any).$transaction([
+      (prisma as any).webAuthnCredential.deleteMany({ where: { userId: id } }),
+      (prisma as any).user.update({
+        where: { id },
+        data: { totpSecret: null, totpConfirmedAt: null, mfaBackupCodes: [] },
+      }),
+    ])
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error('Error resetting MFA:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/admin/users/route.ts

@@ -69,7 +69,11 @@ export async function POST(req: NextRequest) {
     }
 
     const hashedPassword = await hashPassword(data.password)
-    const tenantId = data.tenantId || session.tenantId
+    // Rechte-Ausweitung verhindern: Nicht-SERVER_ADMIN darf NUR im eigenen Tenant
+    // anlegen — der mitgeschickte tenantId aus dem Body wird ignoriert.
+    const tenantId = session.role === 'SERVER_ADMIN'
+      ? (data.tenantId || session.tenantId)
+      : session.tenantId
 
     const user = await (prisma as any).user.create({
       data: {

src/app/api/auth/login/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { cookies } from 'next/headers'
-import { login, createToken, SESSION_MAX_AGE_SECONDS, SESSION_MAX_AGE_REMEMBER_SECONDS } from '@/lib/auth'
+import { login, createToken, createMfaToken, userHasMfa, SESSION_MAX_AGE_SECONDS, SESSION_MAX_AGE_REMEMBER_SECONDS } from '@/lib/auth'
 import { loginSchema } from '@/lib/validations'
 import { prisma } from '@/lib/db'
 import { loginLimiter, getClientIp, rateLimitResponse } from '@/lib/rate-limit'
@@ -36,6 +36,23 @@ export async function POST(request: NextRequest) {
       )
     }
 
+    // Zweiter Faktor erforderlich? Dann noch KEINE Session setzen, sondern MFA-Zwischentoken liefern.
+    if (await userHasMfa(result.user.id)) {
+      const totpEnabled = await (prisma as any).user.findUnique({
+        where: { id: result.user.id },
+        select: { totpConfirmedAt: true, _count: { select: { webauthnCredentials: true } } },
+      })
+      const mfaToken = await createMfaToken(result.user.id, rememberMe)
+      return NextResponse.json({
+        mfaRequired: true,
+        mfaToken,
+        methods: {
+          totp: !!totpEnabled?.totpConfirmedAt,
+          webauthn: (totpEnabled?._count?.webauthnCredentials ?? 0) > 0,
+        },
+      })
+    }
+
     // Update lastLoginAt
     try {
       await (prisma as any).user.update({

src/app/api/auth/mfa-login/verify/route.ts

@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { cookies } from 'next/headers'
+import { prisma } from '@/lib/db'
+import { verifyMfaToken, buildSessionForUser, createToken, SESSION_MAX_AGE_SECONDS, SESSION_MAX_AGE_REMEMBER_SECONDS } from '@/lib/auth'
+import { verifyTotp, verifyBackupCode } from '@/lib/mfa'
+import { loginLimiter, getClientIp, rateLimitResponse } from '@/lib/rate-limit'
+
+// POST (öffentlich): zweiter Faktor per TOTP-Code ODER Backup-Code. Setzt bei Erfolg die Session.
+// body: { mfaToken, code }
+export async function POST(req: NextRequest) {
+  try {
+    const rl = loginLimiter.check(getClientIp(req))
+    if (!rl.success) return rateLimitResponse(rl.resetAt)
+
+    const body = await req.json().catch(() => ({}))
+    const mfa = await verifyMfaToken(String(body.mfaToken || ''))
+    if (!mfa) return NextResponse.json({ error: 'Sitzung abgelaufen. Bitte erneut anmelden.' }, { status: 401 })
+
+    const code = String(body.code || '')
+    const user = await (prisma as any).user.findUnique({
+      where: { id: mfa.userId },
+      select: { id: true, totpSecret: true, totpConfirmedAt: true, mfaBackupCodes: true },
+    })
+    if (!user) return NextResponse.json({ error: 'Benutzer nicht gefunden' }, { status: 401 })
+
+    let ok = false
+    // 1) TOTP
+    if (user.totpConfirmedAt && user.totpSecret && verifyTotp(user.totpSecret, code)) {
+      ok = true
+    } else {
+      // 2) Backup-Code — bei Treffer entwerten
+      const idx = await verifyBackupCode(user.mfaBackupCodes || [], code)
+      if (idx >= 0) {
+        ok = true
+        const remaining = [...(user.mfaBackupCodes as string[])]
+        remaining.splice(idx, 1)
+        await (prisma as any).user.update({ where: { id: user.id }, data: { mfaBackupCodes: remaining } })
+      }
+    }
+
+    if (!ok) return NextResponse.json({ error: 'Code ungültig.' }, { status: 401 })
+
+    const session = await buildSessionForUser(user.id)
+    if (!session.success || !session.user) {
+      return NextResponse.json({ error: session.error || 'Anmeldung fehlgeschlagen' }, { status: 401 })
+    }
+
+    try { await (prisma as any).user.update({ where: { id: user.id }, data: { lastLoginAt: new Date() } }) } catch {}
+
+    const token = await createToken(session.user, mfa.rememberMe)
+    ;(await cookies()).set('auth-token', token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === 'production',
+      sameSite: 'lax',
+      maxAge: mfa.rememberMe ? SESSION_MAX_AGE_REMEMBER_SECONDS : SESSION_MAX_AGE_SECONDS,
+      path: '/',
+    })
+
+    return NextResponse.json({ user: session.user })
+  } catch (error) {
+    console.error('MFA verify error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa-login/webauthn/options/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { generateAuthenticationOptions } from '@simplewebauthn/server'
+import { prisma } from '@/lib/db'
+import { verifyMfaToken } from '@/lib/auth'
+import { rpFromRequest, signChallenge } from '@/lib/webauthn'
+
+// POST (öffentlich): Authentisierungs-Optionen für den zweiten Faktor per WebAuthn.
+// body: { mfaToken }
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json().catch(() => ({}))
+    const mfa = await verifyMfaToken(String(body.mfaToken || ''))
+    if (!mfa) return NextResponse.json({ error: 'Sitzung abgelaufen.' }, { status: 401 })
+
+    const { rpID } = rpFromRequest(req)
+    const creds = await (prisma as any).webAuthnCredential.findMany({
+      where: { userId: mfa.userId },
+      select: { credentialId: true, transports: true },
+    })
+    if (creds.length === 0) return NextResponse.json({ error: 'Kein Sicherheitsschlüssel registriert.' }, { status: 400 })
+
+    const options = await generateAuthenticationOptions({
+      rpID,
+      allowCredentials: creds.map((c: any) => ({
+        id: c.credentialId,
+        transports: c.transports ? JSON.parse(c.transports) : undefined,
+      })),
+      userVerification: 'preferred',
+    })
+
+    const challengeToken = await signChallenge(options.challenge, mfa.userId, 'wa-auth')
+    return NextResponse.json({ options, challengeToken })
+  } catch (error) {
+    console.error('WebAuthn auth options error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa-login/webauthn/verify/route.ts

@@ -0,0 +1,72 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { cookies } from 'next/headers'
+import { verifyAuthenticationResponse } from '@simplewebauthn/server'
+import { prisma } from '@/lib/db'
+import { verifyMfaToken, buildSessionForUser, createToken, SESSION_MAX_AGE_SECONDS, SESSION_MAX_AGE_REMEMBER_SECONDS } from '@/lib/auth'
+import { rpFromRequest, verifyChallenge, b64urlToBytes } from '@/lib/webauthn'
+import { loginLimiter, getClientIp, rateLimitResponse } from '@/lib/rate-limit'
+
+// POST (öffentlich): schliesst den zweiten Faktor per WebAuthn ab und setzt die Session.
+// body: { mfaToken, challengeToken, response }
+export async function POST(req: NextRequest) {
+  try {
+    const rl = loginLimiter.check(getClientIp(req))
+    if (!rl.success) return rateLimitResponse(rl.resetAt)
+
+    const body = await req.json().catch(() => ({}))
+    const mfa = await verifyMfaToken(String(body.mfaToken || ''))
+    if (!mfa) return NextResponse.json({ error: 'Sitzung abgelaufen.' }, { status: 401 })
+    const ch = await verifyChallenge(String(body.challengeToken || ''), 'wa-auth')
+    if (!ch || ch.userId !== mfa.userId) return NextResponse.json({ error: 'Sitzung abgelaufen.' }, { status: 401 })
+
+    const response = body.response
+    const credId = String(response?.id || '')
+    const cred = await (prisma as any).webAuthnCredential.findFirst({
+      where: { credentialId: credId, userId: mfa.userId },
+    })
+    if (!cred) return NextResponse.json({ error: 'Unbekannter Sicherheitsschlüssel.' }, { status: 401 })
+
+    const { rpID, origin } = rpFromRequest(req)
+    const verification = await verifyAuthenticationResponse({
+      response,
+      expectedChallenge: ch.challenge,
+      expectedOrigin: origin,
+      expectedRPID: rpID,
+      credential: {
+        id: cred.credentialId,
+        publicKey: b64urlToBytes(cred.publicKey),
+        counter: cred.counter,
+        transports: cred.transports ? JSON.parse(cred.transports) : undefined,
+      },
+    })
+
+    if (!verification.verified) return NextResponse.json({ error: 'Verifikation fehlgeschlagen.' }, { status: 401 })
+
+    // Zähler aktualisieren (Klon-Schutz)
+    await (prisma as any).webAuthnCredential.update({
+      where: { id: cred.id },
+      data: { counter: verification.authenticationInfo.newCounter, lastUsedAt: new Date() },
+    })
+
+    const session = await buildSessionForUser(mfa.userId)
+    if (!session.success || !session.user) {
+      return NextResponse.json({ error: session.error || 'Anmeldung fehlgeschlagen' }, { status: 401 })
+    }
+
+    try { await (prisma as any).user.update({ where: { id: mfa.userId }, data: { lastLoginAt: new Date() } }) } catch {}
+
+    const token = await createToken(session.user, mfa.rememberMe)
+    ;(await cookies()).set('auth-token', token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === 'production',
+      sameSite: 'lax',
+      maxAge: mfa.rememberMe ? SESSION_MAX_AGE_REMEMBER_SECONDS : SESSION_MAX_AGE_SECONDS,
+      path: '/',
+    })
+
+    return NextResponse.json({ user: session.user })
+  } catch (error) {
+    console.error('WebAuthn auth verify error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/status/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// GET: MFA-Status des angemeldeten Benutzers für die Einstellungen.
+export async function GET() {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const user = await (prisma as any).user.findUnique({
+      where: { id: session.id },
+      select: { totpConfirmedAt: true, mfaBackupCodes: true, webauthnCredentials: { select: { id: true, deviceName: true, createdAt: true, lastUsedAt: true } } },
+    })
+
+    const totpEnabled = !!user?.totpConfirmedAt
+    const credentials = user?.webauthnCredentials || []
+    return NextResponse.json({
+      totpEnabled,
+      backupCodesRemaining: (user?.mfaBackupCodes || []).length,
+      webauthn: credentials,
+      hasMfa: totpEnabled || credentials.length > 0,
+    })
+  } catch (error) {
+    console.error('Error fetching MFA status:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/totp/confirm/route.ts

@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { verifyTotp, generateBackupCodes } from '@/lib/mfa'
+
+// POST: bestätigt die TOTP-Einrichtung mit einem Code aus der App. Bei Erfolg wird TOTP aktiviert
+// und einmalige Backup-Codes werden erzeugt (Klartext nur hier einmalig zurückgegeben).
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const body = await req.json().catch(() => ({}))
+    const code = String(body.code || '')
+
+    const user = await (prisma as any).user.findUnique({
+      where: { id: session.id },
+      select: { totpSecret: true, totpConfirmedAt: true, mfaBackupCodes: true },
+    })
+    if (!user?.totpSecret) {
+      return NextResponse.json({ error: 'Keine Einrichtung offen. Bitte erneut starten.' }, { status: 400 })
+    }
+    if (!verifyTotp(user.totpSecret, code)) {
+      return NextResponse.json({ error: 'Code ungültig. Bitte erneut versuchen.' }, { status: 400 })
+    }
+
+    // Backup-Codes nur erzeugen, wenn noch keine existieren (Neuaktivierung).
+    let plainCodes: string[] | null = null
+    let hashed = user.mfaBackupCodes as string[]
+    if (!user.totpConfirmedAt || !hashed || hashed.length === 0) {
+      const gen = await generateBackupCodes(10)
+      plainCodes = gen.plain
+      hashed = gen.hashed
+    }
+
+    await (prisma as any).user.update({
+      where: { id: session.id },
+      data: { totpConfirmedAt: new Date(), mfaBackupCodes: hashed },
+    })
+
+    return NextResponse.json({ success: true, backupCodes: plainCodes })
+  } catch (error) {
+    console.error('Error confirming TOTP:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/totp/disable/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// POST: deaktiviert TOTP für den angemeldeten Benutzer. Backup-Codes werden nur entfernt,
+// wenn auch kein WebAuthn mehr aktiv ist (sonst bleiben sie als Fallback bestehen).
+export async function POST() {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const cnt = await (prisma as any).webAuthnCredential.count({ where: { userId: session.id } })
+    const data: any = { totpSecret: null, totpConfirmedAt: null }
+    if (cnt === 0) data.mfaBackupCodes = []
+
+    await (prisma as any).user.update({ where: { id: session.id }, data })
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error('Error disabling TOTP:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/totp/setup/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server'
+import QRCode from 'qrcode'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { generateTotpSecret, totpKeyUri } from '@/lib/mfa'
+
+// POST: startet die TOTP-Einrichtung — erzeugt ein Secret (noch nicht bestätigt) und liefert
+// otpauth-URI + QR-Code zum Scannen. Aktiv wird TOTP erst nach /confirm.
+export async function POST() {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const secret = generateTotpSecret()
+    const uri = totpKeyUri(session.email, secret)
+
+    // Secret vormerken (unbestätigt). totpConfirmedAt bleibt NULL bis zur Bestätigung.
+    await (prisma as any).user.update({
+      where: { id: session.id },
+      data: { totpSecret: secret, totpConfirmedAt: null },
+    })
+
+    let qr = ''
+    try { qr = await QRCode.toDataURL(uri, { width: 220, margin: 1 }) } catch { /* QR optional */ }
+
+    return NextResponse.json({ secret, uri, qr })
+  } catch (error) {
+    console.error('Error setting up TOTP:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/webauthn/[id]/route.ts

@@ -0,0 +1,32 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// DELETE (Session): entfernt einen registrierten Sicherheitsschlüssel/Passkey des Benutzers.
+export async function DELETE(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    // Nur eigene Credentials löschen
+    const cred = await (prisma as any).webAuthnCredential.findFirst({ where: { id, userId: session.id }, select: { id: true } })
+    if (!cred) return NextResponse.json({ error: 'Nicht gefunden' }, { status: 404 })
+
+    await (prisma as any).webAuthnCredential.delete({ where: { id } })
+
+    // Backup-Codes aufräumen, wenn kein Faktor mehr aktiv ist.
+    const user = await (prisma as any).user.findUnique({
+      where: { id: session.id },
+      select: { totpConfirmedAt: true, _count: { select: { webauthnCredentials: true } } },
+    })
+    if (!user?.totpConfirmedAt && (user?._count?.webauthnCredentials ?? 0) === 0) {
+      await (prisma as any).user.update({ where: { id: session.id }, data: { mfaBackupCodes: [] } })
+    }
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error('WebAuthn delete error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/webauthn/register/options/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { generateRegistrationOptions } from '@simplewebauthn/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { rpFromRequest, signChallenge, b64urlToBytes } from '@/lib/webauthn'
+
+// POST (Session): Optionen zum Registrieren eines Sicherheitsschlüssels/Passkeys.
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const { rpID, rpName } = rpFromRequest(req)
+    const existing = await (prisma as any).webAuthnCredential.findMany({
+      where: { userId: session.id },
+      select: { credentialId: true, transports: true },
+    })
+
+    const options = await generateRegistrationOptions({
+      rpName,
+      rpID,
+      userName: session.email,
+      userDisplayName: session.name,
+      userID: new TextEncoder().encode(session.id),
+      attestationType: 'none',
+      excludeCredentials: existing.map((c: any) => ({
+        id: c.credentialId,
+        transports: c.transports ? JSON.parse(c.transports) : undefined,
+      })),
+      authenticatorSelection: { residentKey: 'preferred', userVerification: 'preferred' },
+    })
+
+    const challengeToken = await signChallenge(options.challenge, session.id, 'wa-reg')
+    return NextResponse.json({ options, challengeToken })
+  } catch (error) {
+    console.error('WebAuthn register options error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/mfa/webauthn/register/verify/route.ts

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { verifyRegistrationResponse } from '@simplewebauthn/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { rpFromRequest, verifyChallenge, bytesToB64url } from '@/lib/webauthn'
+
+// POST (Session): schliesst die Registrierung eines Sicherheitsschlüssels/Passkeys ab.
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const body = await req.json().catch(() => ({}))
+    const ch = await verifyChallenge(String(body.challengeToken || ''), 'wa-reg')
+    if (!ch || ch.userId !== session.id) {
+      return NextResponse.json({ error: 'Sitzung abgelaufen. Bitte erneut versuchen.' }, { status: 400 })
+    }
+
+    const { rpID, origin } = rpFromRequest(req)
+    const verification = await verifyRegistrationResponse({
+      response: body.response,
+      expectedChallenge: ch.challenge,
+      expectedOrigin: origin,
+      expectedRPID: rpID,
+    })
+
+    if (!verification.verified || !verification.registrationInfo) {
+      return NextResponse.json({ error: 'Registrierung fehlgeschlagen.' }, { status: 400 })
+    }
+
+    const cred = verification.registrationInfo.credential
+    await (prisma as any).webAuthnCredential.create({
+      data: {
+        userId: session.id,
+        credentialId: cred.id,
+        publicKey: bytesToB64url(cred.publicKey),
+        counter: cred.counter,
+        transports: cred.transports ? JSON.stringify(cred.transports) : null,
+        deviceName: (typeof body.deviceName === 'string' && body.deviceName.trim()) ? body.deviceName.trim().slice(0, 60) : 'Sicherheitsschlüssel',
+      },
+    })
+
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    console.error('WebAuthn register verify error:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/auth/register/route.ts

@@ -5,12 +5,16 @@ import { sendEmail } from '@/lib/email'
 import { randomBytes } from 'crypto'
 import { z } from 'zod'
 import { registerLimiter, getClientIp, rateLimitResponse } from '@/lib/rate-limit'
+import { recordAcceptances } from '@/lib/legal'
 
 const registerSchema = z.object({
   organizationName: z.string().min(2, 'Organisationsname zu kurz').max(200),
   name: z.string().min(2, 'Name zu kurz').max(200),
   email: z.string().email('Ungültige E-Mail-Adresse'),
   password: z.string().min(8, 'Passwort muss mindestens 8 Zeichen haben'),
+  // Aktive Zustimmung erforderlich (keine vorausgewählte Checkbox im UI).
+  acceptTerms: z.literal(true, { errorMap: () => ({ message: 'Bitte die Nutzungsbedingungen akzeptieren.' }) }),
+  acceptPrivacy: z.literal(true, { errorMap: () => ({ message: 'Bitte die Kenntnisnahme der Datenschutzerklärung bestätigen.' }) }),
 })
 
 export async function POST(req: NextRequest) {
@@ -79,8 +83,8 @@ export async function POST(req: NextRequest) {
         maxUsers: 5,
         maxProjects: 10,
         contactEmail: data.email,
-        privacyAccepted: body.privacyAccepted === true,
+        privacyAccepted: true,
-        privacyAcceptedAt: body.privacyAccepted ? new Date() : null,
+        privacyAcceptedAt: new Date(),
         adminAccessAccepted: body.adminAccessAccepted === true,
       },
     })
@@ -106,6 +110,22 @@ export async function POST(req: NextRequest) {
       },
     })
 
+    // Zustimmungen revisionssicher protokollieren (aktive Dokumentversion).
+    // Die Organisationsbestätigung wird separat nach dem ersten Login abgefragt (Re-Consent).
+    try {
+      await recordAcceptances({
+        userId: user.id,
+        organizationId: tenant.id,
+        context: 'REGISTRATION',
+        types: ['TERMS', 'PRIVACY'],
+        locale: 'de-CH',
+        ipAddress: getClientIp(req),
+        userAgent: req.headers.get('user-agent'),
+      })
+    } catch (e) {
+      console.warn('[register] Zustimmungsprotokollierung fehlgeschlagen (nicht blockierend):', e)
+    }
+
     // Send verification email
     let baseUrl = process.env.NEXTAUTH_URL || req.headers.get('origin') || `${req.headers.get('x-forwarded-proto') || 'https'}://${req.headers.get('host')}` || 'http://localhost:3000'
     if (baseUrl && !baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {

src/app/api/cron/backup/route.ts

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { loadBackupConfig } from '@/lib/backup/config'
+import { isBackupDue, runBackup } from '@/lib/backup/engine'
+
+// POST (öffentlich, aber per CRON_SECRET geschützt): vom internen Scheduler aufgerufen.
+// Führt ein Backup NUR aus, wenn es laut Zeitplan fällig ist.
+export async function POST(req: NextRequest) {
+  try {
+    const secret = process.env.CRON_SECRET
+    if (!secret) return NextResponse.json({ error: 'CRON_SECRET nicht gesetzt' }, { status: 503 })
+    if (req.headers.get('x-cron-secret') !== secret) {
+      return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    }
+
+    const cfg = await loadBackupConfig()
+    if (!cfg) return NextResponse.json({ skipped: true, reason: 'nicht konfiguriert' })
+    if (!isBackupDue(cfg)) return NextResponse.json({ skipped: true, reason: 'nicht fällig' })
+
+    const res = await runBackup()
+    return NextResponse.json(res)
+  } catch (e: any) {
+    return NextResponse.json({ ok: false, message: e?.message || 'Fehler' }, { status: 500 })
+  }
+}

src/app/api/donate/checkout/route.ts

@@ -27,8 +27,8 @@ export async function POST(req: NextRequest) {
           price_data: {
             currency: 'chf',
             product_data: {
-              name: 'Spende für Lageplan',
+              name: 'Freiwilliger Unterstützungsbeitrag für Lageplan',
-              description: `Freiwillige Spende von CHF ${amount} für die Weiterentwicklung`,
+              description: `Freiwilliger Unterstützungsbeitrag von CHF ${amount} für die Weiterentwicklung`,
             },
             unit_amount: amountInCents,
           },

src/app/api/legal/accept/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { getClientIp } from '@/lib/rate-limit'
+import { recordAcceptances, getPendingAcceptances, type LegalAcceptanceContext, type LegalDocumentType } from '@/lib/legal'
+
+const VALID_TYPES: LegalDocumentType[] = ['TERMS', 'PRIVACY', 'ORGANIZATION_DECLARATION', 'RESPONSIBLE_USE', 'DATA_PROCESSING_AGREEMENT', 'FKS_ATTRIBUTION']
+const VALID_CONTEXTS: LegalAcceptanceContext[] = ['REGISTRATION', 'LOGIN_RECONSENT', 'ORGANIZATION_CREATION', 'ADMIN_ROLE_ACCEPTANCE', 'EXISTING_USER_RECONSENT', 'SUPPORT_CONTRIBUTION', 'DONATION']
+
+// POST: erfasst Zustimmungen des angemeldeten Benutzers revisionssicher.
+// body: { types: LegalDocumentType[], context: LegalAcceptanceContext }
+export async function POST(req: NextRequest) {
+  try {
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    // CSRF-Schutz: nur same-origin JSON-Requests (Cookie ist sameSite=lax).
+    const contentType = req.headers.get('content-type') || ''
+    if (!contentType.includes('application/json')) {
+      return NextResponse.json({ error: 'Ungültiger Request' }, { status: 400 })
+    }
+
+    const body = await req.json().catch(() => ({}))
+    const types: LegalDocumentType[] = Array.isArray(body.types)
+      ? body.types.filter((t: any) => VALID_TYPES.includes(t))
+      : []
+    const context: LegalAcceptanceContext = VALID_CONTEXTS.includes(body.context) ? body.context : 'LOGIN_RECONSENT'
+
+    if (types.length === 0) {
+      return NextResponse.json({ error: 'Keine gültigen Dokumenttypen' }, { status: 400 })
+    }
+
+    // Organisationsbezogene Zustimmung (Org-Bestätigung) an den Tenant binden.
+    const orgBound = context === 'ORGANIZATION_CREATION' || context === 'ADMIN_ROLE_ACCEPTANCE' || types.includes('ORGANIZATION_DECLARATION')
+    const organizationId = orgBound ? (user.tenantId ?? null) : null
+
+    const count = await recordAcceptances({
+      userId: user.id,
+      organizationId,
+      context,
+      types,
+      locale: 'de-CH',
+      ipAddress: getClientIp(req),
+      userAgent: req.headers.get('user-agent'),
+    })
+
+    const isOrgAdmin = user.role === 'TENANT_ADMIN'
+    const pending = await getPendingAcceptances(user.id, isOrgAdmin)
+
+    return NextResponse.json({ success: true, recorded: count, needsAcceptance: pending.length > 0, pending })
+  } catch (error) {
+    console.error('Error recording legal acceptance:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/legal/my-acceptances/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+
+// GET: die eigenen protokollierten Zustimmungen des angemeldeten Benutzers (revisionssicher, read-only).
+export async function GET() {
+  try {
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const acceptances = await (prisma as any).legalAcceptance.findMany({
+      where: { userId: user.id },
+      orderBy: { acceptedAt: 'desc' },
+      select: { documentType: true, documentVersion: true, context: true, acceptedAt: true, organizationId: true },
+    })
+
+    return NextResponse.json({ acceptances })
+  } catch (error) {
+    console.error('Error fetching own acceptances:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/legal/status/route.ts

@@ -0,0 +1,29 @@
+import { NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { getActiveDocuments, getPendingAcceptances } from '@/lib/legal'
+
+// GET: aktive Rechtsdokumente + offene Pflicht-Zustimmungen des aktuellen Benutzers.
+// Grundlage für den blockierenden Re-Consent-Dialog.
+export async function GET() {
+  try {
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const isOrgAdmin = user.role === 'TENANT_ADMIN'
+    const [active, pending] = await Promise.all([
+      getActiveDocuments(),
+      getPendingAcceptances(user.id, isOrgAdmin),
+    ])
+
+    return NextResponse.json({
+      isOrgAdmin,
+      organizationId: user.tenantId ?? null,
+      documents: active,
+      pending, // leer = alles akzeptiert
+      needsAcceptance: pending.length > 0,
+    })
+  } catch (error) {
+    console.error('Error fetching legal status:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/projects/[id]/journal/check-items/route.ts

@@ -16,36 +16,33 @@ export async function POST(req: NextRequest, { params }: { params: Promise<{ id:
 
     const body = await req.json()
 
-    // If 'initFromTemplates' is true, create check items from templates (only if none exist)
+    // If 'initFromTemplates' is true, create check items from templates (only if none exist).
+    // ATOMAR: Advisory-Lock pro Projekt verhindert doppelte SOMA-Listen, wenn zwei Geräte
+    // denselben frischen Einsatz gleichzeitig öffnen (Client-Guard schützt nur pro Client).
     if (body.initFromTemplates) {
-      const existing = await (prisma as any).journalCheckItem.findMany({
+      const items = await (prisma as any).$transaction(async (tx: any) => {
-        where: { projectId: id },
+        // Serialisiert Init-Aufrufe desselben Projekts (bis Transaktionsende)
-      })
+        await tx.$executeRawUnsafe(`SELECT pg_advisory_xact_lock(hashtext($1))`, `checkitems:${id}`)
-      if (existing.length > 0) {
+
-        return NextResponse.json(existing)
+        const existing = await tx.journalCheckItem.findMany({ where: { projectId: id } })
-      }
+        if (existing.length > 0) return existing
-      // Prefer tenant-specific templates; fall back to global (tenantId=null) if none exist
+
-      let templates = await (prisma as any).journalCheckTemplate.findMany({
+        let templates = await tx.journalCheckTemplate.findMany({
-        where: { isActive: true, tenantId: user.tenantId || null },
+          where: { isActive: true, tenantId: user.tenantId || null },
-        orderBy: { sortOrder: 'asc' },
-      })
-      if (templates.length === 0 && user.tenantId) {
-        templates = await (prisma as any).journalCheckTemplate.findMany({
-          where: { isActive: true, tenantId: null },
           orderBy: { sortOrder: 'asc' },
         })
-      }
+        if (templates.length === 0 && user.tenantId) {
-      const items = await Promise.all(
+          templates = await tx.journalCheckTemplate.findMany({
-        templates.map((tpl: any, i: number) =>
+            where: { isActive: true, tenantId: null },
-          (prisma as any).journalCheckItem.create({
+            orderBy: { sortOrder: 'asc' },
-            data: {
-              projectId: id,
-              label: tpl.label,
-              sortOrder: i,
-            },
           })
-        )
+        }
-      )
+        if (templates.length === 0) return []
+        await tx.journalCheckItem.createMany({
+          data: templates.map((tpl: any, i: number) => ({ projectId: id, label: tpl.label, sortOrder: i })),
+        })
+        return tx.journalCheckItem.findMany({ where: { projectId: id }, orderBy: { sortOrder: 'asc' } })
+      })
       return NextResponse.json(items)
     }
 

src/app/api/projects/[id]/modules/[moduleId]/items/[itemId]/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { prisma } from '@/lib/db'
+import { getProjectWithTenantCheck } from '@/lib/tenant'
+
+/** Zeile eines Tabellen-Moduls aktualisieren (data wird gemerged) */
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; moduleId: string; itemId: string }> }
+) {
+  try {
+    const { id, moduleId, itemId } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    if (user.role === 'VIEWER') return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    const existing = await (prisma as any).moduleItem.findFirst({
+      where: { id: itemId, projectId: id, moduleId },
+    })
+    if (!existing) return NextResponse.json({ error: 'Eintrag nicht gefunden' }, { status: 404 })
+
+    const body = await request.json()
+    const patch = body && typeof body.data === 'object' && body.data !== null ? body.data : {}
+
+    const merged = { ...(existing.data || {}), ...patch }
+    // Payload-Härtung: Zeilengrösse begrenzen (DB-Bloat/DoS vermeiden)
+    if (JSON.stringify(merged).length > 20000) {
+      return NextResponse.json({ error: 'Eintrag zu gross' }, { status: 413 })
+    }
+
+    const item = await (prisma as any).moduleItem.update({
+      where: { id: itemId },
+      data: { data: merged },
+    })
+    return NextResponse.json(item)
+  } catch (error) {
+    console.error('Error updating module item:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}
+
+/** Zeile eines Tabellen-Moduls löschen */
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; moduleId: string; itemId: string }> }
+) {
+  try {
+    const { id, moduleId, itemId } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    if (user.role === 'VIEWER') return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    await (prisma as any).moduleItem.deleteMany({
+      where: { id: itemId, projectId: id, moduleId },
+    })
+    return NextResponse.json({ ok: true })
+  } catch (error) {
+    console.error('Error deleting module item:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/projects/[id]/modules/[moduleId]/items/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { prisma } from '@/lib/db'
+import { getProjectWithTenantCheck } from '@/lib/tenant'
+
+/** Zeilen eines Tabellen-Moduls laden */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; moduleId: string }> }
+) {
+  try {
+    const { id, moduleId } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    const items = await (prisma as any).moduleItem.findMany({
+      where: { projectId: id, moduleId },
+      orderBy: [{ sortOrder: 'asc' }, { createdAt: 'asc' }],
+    })
+    return NextResponse.json({ items })
+  } catch (error) {
+    console.error('Error fetching module items:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}
+
+/** Neue Zeile in einem Tabellen-Modul anlegen */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string; moduleId: string }> }
+) {
+  try {
+    const { id, moduleId } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    if (user.role === 'VIEWER') return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+
+    if (moduleId.length > 64) return NextResponse.json({ error: 'Ungültige Modul-ID' }, { status: 400 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    const body = await request.json()
+    const data = body && typeof body.data === 'object' && body.data !== null ? body.data : {}
+    // Payload-Härtung: eine Tabellenzeile bleibt klein — verhindert DB-Bloat/DoS
+    if (JSON.stringify(data).length > 20000) {
+      return NextResponse.json({ error: 'Eintrag zu gross' }, { status: 413 })
+    }
+
+    const count = await (prisma as any).moduleItem.count({ where: { projectId: id, moduleId } })
+    const item = await (prisma as any).moduleItem.create({
+      data: { projectId: id, moduleId, data, sortOrder: count },
+    })
+    return NextResponse.json(item, { status: 201 })
+  } catch (error) {
+    console.error('Error creating module item:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/projects/[id]/plan-image/serve/route.ts

@@ -1,20 +1,17 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { prisma } from '@/lib/db'
 import { getSession } from '@/lib/auth'
+import { getProjectWithTenantCheck } from '@/lib/tenant'
 import { getFileStream } from '@/lib/minio'
 
-// Serve plan image (authenticated users only)
+// Serve plan image (only for projects of the user's tenant)
 export async function GET(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
   try {
     const { id } = await params
     const user = await getSession()
     if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
 
-    const project = await (prisma as any).project.findUnique({
+    // Mandanten-Isolation statt globalem Lookup
-      where: { id },
+    const project = await getProjectWithTenantCheck(id, user)
-      select: { planImageKey: true },
-    })
-
     if (!project?.planImageKey) {
       return NextResponse.json({ error: 'Kein Plan vorhanden' }, { status: 404 })
     }

src/app/api/projects/[id]/share/route.ts

@@ -0,0 +1,95 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { randomBytes } from 'crypto'
+import bcrypt from 'bcryptjs'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { getProjectWithTenantCheck } from '@/lib/tenant'
+
+function shareUrl(req: NextRequest, token: string) {
+  const baseUrl = process.env.NEXTAUTH_URL || req.headers.get('origin') ||
+    `${req.headers.get('x-forwarded-proto') || 'https'}://${req.headers.get('host')}` || ''
+  return `${baseUrl}/view/${token}`
+}
+
+// GET: aktuellen Teilen-Status abrufen
+export async function GET(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    return NextResponse.json({
+      enabled: !!project.shareEnabled && !!project.shareToken,
+      url: project.shareToken ? shareUrl(req, project.shareToken) : null,
+      hasPin: !!project.sharePin,
+    })
+  } catch (error) {
+    console.error('Error fetching share status:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}
+
+// POST: Teilen aktivieren/aktualisieren/deaktivieren
+// body: { enabled: boolean, pin?: string | null }
+//   pin === undefined → PIN unverändert lassen
+//   pin === null oder ''  → PIN entfernen
+//   pin === "1234"        → PIN setzen (4–8 Ziffern)
+export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    if (user.role === 'VIEWER') return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+
+    const project = await getProjectWithTenantCheck(id, user)
+    if (!project) return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+
+    const body = await req.json().catch(() => ({}))
+    const enabled = !!body.enabled
+
+    if (!enabled) {
+      // Deaktivieren = Link widerrufen (Token + PIN löschen, alter Link wird ungültig)
+      await (prisma as any).project.update({
+        where: { id },
+        data: { shareEnabled: false, shareToken: null, sharePin: null },
+      })
+      return NextResponse.json({ enabled: false, url: null, hasPin: false })
+    }
+
+    const data: any = { shareEnabled: true }
+
+    // Token erzeugen, falls noch keiner existiert
+    let token = project.shareToken as string | null
+    if (!token) {
+      token = randomBytes(9).toString('base64url') // ~12 Zeichen, URL-sicher
+      data.shareToken = token
+    }
+
+    // PIN-Handling
+    if (body.pin !== undefined) {
+      const pin = body.pin === null ? '' : String(body.pin).trim()
+      if (pin === '') {
+        data.sharePin = null
+      } else {
+        if (!/^\d{4,8}$/.test(pin)) {
+          return NextResponse.json({ error: 'PIN muss 4–8 Ziffern haben' }, { status: 400 })
+        }
+        data.sharePin = await bcrypt.hash(pin, 10)
+      }
+    }
+
+    await (prisma as any).project.update({ where: { id }, data })
+
+    const hasPin = body.pin !== undefined
+      ? (body.pin !== null && String(body.pin).trim() !== '')
+      : !!project.sharePin
+
+    return NextResponse.json({ enabled: true, url: shareUrl(req, token), hasPin })
+  } catch (error) {
+    console.error('Error updating share status:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/rapports/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { prisma } from '@/lib/db'
 import { getSession, isAdmin } from '@/lib/auth'
+import { getProjectWithTenantCheck } from '@/lib/tenant'
 import QRCode from 'qrcode'
 
 // Helper: create a rapport record and return JSON response
@@ -73,6 +74,12 @@ export async function GET(req: NextRequest) {
       return NextResponse.json({ error: 'projectId erforderlich' }, { status: 400 })
     }
 
+    // Mandanten-Isolation: nur Rapporte von Projekten des eigenen Tenants
+    const project = await getProjectWithTenantCheck(projectId, user)
+    if (!project) {
+      return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
+    }
+
     const rapports = await (prisma as any).rapport.findMany({
       where: { projectId },
       orderBy: { createdAt: 'desc' },
@@ -98,6 +105,7 @@ export async function POST(req: NextRequest) {
   try {
     const user = await getSession()
     if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+    if (user.role === 'VIEWER') return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
 
     let body: any
     try {
@@ -113,11 +121,11 @@ export async function POST(req: NextRequest) {
       return NextResponse.json({ error: `Felder fehlen (projectId=${!!projectId}, data=${!!data})` }, { status: 400 })
     }
 
-    // Resolve tenantId: project → user session → membership lookup
+    // Mandanten-Isolation: Rapport nur für ein Projekt des eigenen Tenants anlegen
-    const project = await (prisma as any).project.findUnique({
+    const project = await getProjectWithTenantCheck(projectId, user)
-      where: { id: projectId },
+    if (!project) {
-      select: { tenantId: true },
+      return NextResponse.json({ error: 'Projekt nicht gefunden' }, { status: 404 })
-    })
+    }
 
     let tenantId = project?.tenantId || user.tenantId || null
     if (!tenantId) {

src/app/api/share/[token]/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from 'next/server'
+import bcrypt from 'bcryptjs'
+import { prisma } from '@/lib/db'
+import { sharePinLimiter, getClientIp, rateLimitResponse } from '@/lib/rate-limit'
+
+// Öffentliche Nur-Ansicht-Route für einen geteilten Einsatz.
+// Kein Login nötig. Bei gesetzter PIN werden Kartendaten erst nach korrekter PIN geliefert.
+
+async function loadShared(token: string) {
+  if (!token || token.length > 64) return null
+  const project = await (prisma as any).project.findUnique({
+    where: { shareToken: token },
+    select: {
+      id: true, title: true, location: true, einsatzNr: true, mode: true,
+      mapCenter: true, mapZoom: true, windDirection: true,
+      shareEnabled: true, sharePin: true,
+    },
+  })
+  if (!project || !project.shareEnabled) return null
+  return project
+}
+
+// GET: Meta-Infos (Titel + ob PIN nötig) — ohne Kartendaten
+export async function GET(_req: NextRequest, { params }: { params: Promise<{ token: string }> }) {
+  try {
+    const { token } = await params
+    const project = await loadShared(token)
+    if (!project) return NextResponse.json({ error: 'Link ungültig oder deaktiviert' }, { status: 404 })
+
+    return NextResponse.json({
+      ok: true,
+      requiresPin: !!project.sharePin,
+      title: project.title,
+      einsatzNr: project.einsatzNr,
+      location: project.location,
+    })
+  } catch (error) {
+    console.error('Error resolving share link:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}
+
+// POST: liefert den Live-Snapshot (Projekt-Kern + Features), nach PIN-Prüfung
+// body: { pin?: string }
+export async function POST(req: NextRequest, { params }: { params: Promise<{ token: string }> }) {
+  try {
+    const { token } = await params
+    const project = await loadShared(token)
+    if (!project) return NextResponse.json({ error: 'Link ungültig oder deaktiviert' }, { status: 404 })
+
+    if (project.sharePin) {
+      // Brute-Force-Schutz nur, wenn eine PIN gesetzt ist
+      const rl = sharePinLimiter.check(getClientIp(req))
+      if (!rl.success) return rateLimitResponse(rl.resetAt)
+
+      const body = await req.json().catch(() => ({}))
+      const pin = String(body.pin || '').trim()
+      if (!pin || !(await bcrypt.compare(pin, project.sharePin))) {
+        return NextResponse.json({ error: 'Falsche PIN', requiresPin: true }, { status: 401 })
+      }
+    }
+
+    const features = await (prisma as any).feature.findMany({
+      where: { projectId: project.id },
+      select: { id: true, type: true, geometry: true, properties: true },
+    })
+
+    return NextResponse.json({
+      ok: true,
+      projectId: project.id, // für Live-Updates (Socket-Raum)
+      project: {
+        id: project.id,
+        title: project.title,
+        location: project.location,
+        einsatzNr: project.einsatzNr,
+        mode: project.mode,
+        mapCenter: project.mapCenter,
+        mapZoom: project.mapZoom,
+        windDirection: project.windDirection,
+      },
+      features,
+    })
+  } catch (error) {
+    console.error('Error serving shared snapshot:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/tenant/modules/route.ts

@@ -0,0 +1,77 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { getSession } from '@/lib/auth'
+import { normalizeModules, DEFAULT_MODULES } from '@/lib/modules'
+
+/**
+ * Ermittelt den massgeblichen Mandanten für die Modul-Verwaltung.
+ * SERVER_ADMIN darf einen beliebigen Mandanten (z.B. den des offenen Einsatzes) verwalten;
+ * andere nur ihren eigenen. `canManage` sagt, ob dieser Nutzer speichern darf.
+ */
+function resolveTenant(user: any, requestedTenantId: string | null): { tenantId: string | null; canManage: boolean } {
+  const isServerAdmin = user.role === 'SERVER_ADMIN'
+  const isTenantAdmin = user.role === 'TENANT_ADMIN'
+  if (isServerAdmin) {
+    // SERVER_ADMIN: nimmt den angefragten Mandanten (Einsatz), sonst den eigenen (falls vorhanden)
+    return { tenantId: requestedTenantId || user.tenantId || null, canManage: true }
+  }
+  // Alle anderen: immer nur der eigene Mandant. Admin dieses Mandanten darf verwalten.
+  return { tenantId: user.tenantId || null, canManage: isTenantAdmin && !!user.tenantId }
+}
+
+/** Cockpit-Modul-Konfiguration lesen (Mandant = eigener oder, für SERVER_ADMIN, der des Einsatzes) */
+export async function GET(request: NextRequest) {
+  try {
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const requested = request.nextUrl.searchParams.get('tenantId')
+    const { tenantId, canManage } = resolveTenant(user, requested)
+
+    if (!tenantId) {
+      // Kein Mandant auflösbar: Standard-Cockpit, nicht verwaltbar
+      return NextResponse.json({ modules: DEFAULT_MODULES, canManage: false })
+    }
+
+    const tenant = await (prisma as any).tenant.findUnique({
+      where: { id: tenantId },
+      select: { modulesConfig: true },
+    })
+
+    return NextResponse.json({
+      modules: normalizeModules(tenant?.modulesConfig),
+      canManage,
+      tenantId,
+    })
+  } catch (error) {
+    console.error('Error fetching module config:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}
+
+/** Cockpit-Modul-Konfiguration speichern (nur Admins des betroffenen Mandanten) */
+export async function PUT(request: NextRequest) {
+  try {
+    const user = await getSession()
+    if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
+
+    const body = await request.json()
+    const { tenantId, canManage } = resolveTenant(user, body?.tenantId || null)
+
+    if (!tenantId) return NextResponse.json({ error: 'Kein Mandant zugeordnet' }, { status: 400 })
+    if (!canManage) return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+
+    // normalizeModules verwirft Unbekanntes und stellt eingebaute Module sicher
+    const modules = normalizeModules(body?.modules)
+
+    await (prisma as any).tenant.update({
+      where: { id: tenantId },
+      data: { modulesConfig: modules },
+    })
+
+    return NextResponse.json({ modules })
+  } catch (error) {
+    console.error('Error saving module config:', error)
+    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 })
+  }
+}

src/app/api/tenants/[tenantId]/suggestions/route.ts

@@ -12,6 +12,11 @@ export async function GET(
     const user = await getSession()
     if (!user) return NextResponse.json({ error: 'Nicht autorisiert' }, { status: 401 })
 
+    // Mandanten-Isolation: nur der eigene Tenant (SERVER_ADMIN darf alle)
+    if (user.role !== 'SERVER_ADMIN' && user.tenantId !== tenantId) {
+      return NextResponse.json({ error: 'Keine Berechtigung' }, { status: 403 })
+    }
+
     // Fetch from new Dictionary model (global + tenant)
     const [globalWords, tenantWords, tenant] = await Promise.all([
       (prisma as any).dictionaryEntry.findMany({

src/app/app/page.tsx

@@ -19,13 +19,17 @@ import { useAuth } from '@/components/providers/auth-provider'
 import { Button } from '@/components/ui/button'
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from '@/components/ui/dialog'
 import { JournalView } from '@/components/journal/journal-view'
-import { Lock, Unlock, Eye, AlertTriangle, WifiOff, GraduationCap, Map as MapIcon, ClipboardList, LayoutGrid, X } from 'lucide-react'
+import { Lock, Eye, Pencil, AlertTriangle, WifiOff, GraduationCap, Map as MapIcon, ClipboardList, LayoutGrid } from 'lucide-react'
+import { UsageNoticeBanner } from '@/components/legal/usage-notice-banner'
 import { CustomDragLayer } from '@/components/map/custom-drag-layer'
 import { OnboardingTour, resetOnboardingTour } from '@/components/onboarding/onboarding-tour'
 import { useKeyboardShortcuts } from '@/hooks/use-keyboard-shortcuts'
 import { useMapExport } from '@/hooks/use-map-export'
 import { useAutoSave } from '@/hooks/use-auto-save'
 import { useOfflineSync } from '@/hooks/use-offline-sync'
+import { preloadTilesForArea, shouldPreloadForProject, markPreloadedForProject } from '@/lib/offline-tiles'
+import { fetchLiveWind } from '@/lib/wind'
+import { degToCompass } from '@/components/map/map-compass'
 import { useRealtimeSync } from '@/hooks/use-realtime-sync'
 import type { Project, ProjectMode, DrawFeature, Feature, JournalEntry, DrawMode } from '@/types'
 import { useToolStore } from '@/stores/tool-store'
@@ -50,6 +54,8 @@ export default function AppPage() {
   const [isEndConfirmOpen, setIsEndConfirmOpen] = useState(false)
   // Tap-to-place: angetipptes Symbol wartet auf Platzierung per Karten-Tipp (Mobil)
   const [pendingSymbol, setPendingSymbol] = useState<{ id: string; imageUrl: string } | null>(null)
+  // Feld-Tempo: bleibt scharf, um mehrere gleiche Symbole am Stück zu setzen
+  const [placedCount, setPlacedCount] = useState(0)
   const [isSaving, setIsSaving] = useState(false)
   const [isDeleteAllConfirmOpen, setIsDeleteAllConfirmOpen] = useState(false)
   const [isFullscreen, setIsFullscreen] = useState(false)
@@ -92,6 +98,7 @@ export default function AppPage() {
     featuresRef,
     setFeatures,
     toast: toast as any,
+    featuresVersionRef,
   })
 
   // Capture map screenshot when switching to journal tab (coordinate-based rendering)
@@ -391,11 +398,57 @@ export default function AppPage() {
   const canEdit = canEditMap // Abwärtskompatibel für Karten-bezogene Stellen
   const isReadOnly = !!editingBy && !isEditingByMe
 
+  // Auto-Bearbeitung: sobald ein berechtigter Nutzer zu zeichnen beginnt und die Karte
+  // frei ist, wird der Editier-Lock still übernommen — kein manuelles „Bearbeitung starten".
+  const ensureEditing = useCallback(() => {
+    if (!currentProject || presentationLocked || !roleCanEdit) return
+    if (isEditingByMe || editingBy) return // ich zeichne schon / jemand anderes hält den Lock
+    if (editingLoading) return // Lock-Anfrage läuft bereits — nicht doppelt feuern
+    handleStartEditing({ silent: true })
+  }, [currentProject, presentationLocked, roleCanEdit, isEditingByMe, editingBy, editingLoading, handleStartEditing])
+
+  // Werkzeugwechsel auf ein Zeichen-Tool übernimmt vorab den Lock (rechtzeitig vor dem Zeichnen)
+  const handleDrawModeChange = useCallback((mode: DrawMode) => {
+    if (mode !== 'select') {
+      ensureEditing()
+      setPendingSymbol(null) // ein Zeichen-Werkzeug beendet das Symbol-Platzieren
+      setPlacedCount(0)
+    }
+    setDrawMode(mode)
+  }, [ensureEditing, setDrawMode])
+
   // Features-Version bei Projektwechsel initialisieren
   useEffect(() => {
     featuresVersionRef.current = (currentProject as any)?.featuresVersion ?? 0
   }, [currentProject?.id])
 
+  // Offline-Karten: Kacheln des Einsatzgebiets im Hintergrund vorladen,
+  // damit die Karte auch ohne Empfang (Keller, Funkloch) vollständig da ist.
+  useEffect(() => {
+    const proj = currentProject
+    if (!proj?.id || typeof navigator === 'undefined' || !navigator.onLine) return
+    const center = (proj as any).mapCenter
+    if (!center?.lng || !center?.lat) return
+    if (!shouldPreloadForProject(proj.id)) return
+
+    let cancelled = false
+    // Karte zuerst rendern lassen, dann im Hintergrund vorladen
+    const timer = setTimeout(async () => {
+      try {
+        const result = await preloadTilesForArea(center.lng, center.lat)
+        if (cancelled || result.skipped) return
+        markPreloadedForProject(proj.id)
+        if (result.cached > 0) {
+          toast({
+            title: 'Karte offline verfügbar',
+            description: `${result.cached} Kartenkacheln für das Einsatzgebiet gespeichert.`,
+          })
+        }
+      } catch { /* Vorladen ist Komfort — Fehler still ignorieren */ }
+    }, 4000)
+    return () => { cancelled = true; clearTimeout(timer) }
+  }, [currentProject?.id, toast])
+
   // Speicher-Konflikt: Server-Stand übernehmen und den Nutzer warnen
   const handleSaveConflict = useCallback((serverFeatures: DrawFeature[], serverVersion: number) => {
     setFeatures(serverFeatures)
@@ -422,6 +475,73 @@ export default function AppPage() {
     onConflict: handleSaveConflict,
   })
 
+  // Wind-Modus: live (aus Open-Meteo, aktualisiert sich) vs. manuell gesetzt
+  const [windLive, setWindLive] = useState(true)
+  const windLiveRef = useRef(true)
+  useEffect(() => { windLiveRef.current = windLive }, [windLive])
+
+  // Windrichtung fürs Lagebild setzen (lokal + am Projekt speichern).
+  // opts.live=true markiert einen Live-Wert (periodische Aktualisierung bleibt an).
+  const handleWindChange = useCallback(async (dir: number | null, opts?: { live?: boolean }) => {
+    if (!currentProject) return
+    setWindLive(opts?.live === true)
+    setCurrentProject((prev) => (prev ? { ...prev, windDirection: dir } : prev))
+    try {
+      await fetch(`/api/projects/${currentProject.id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ windDirection: dir }),
+      })
+    } catch { /* Komfort — Fehler still ignorieren */ }
+  }, [currentProject])
+
+  // Live-Wind von Open-Meteo für den aktuellen Kartenausschnitt (Einsatzort) holen
+  const handleFetchLiveWind = useCallback(async () => {
+    if (!currentProject) return
+    const c = mapRef.current?.getCenter?.() || currentProject.mapCenter
+    if (!c) return
+    const wind = await fetchLiveWind(c.lat, c.lng)
+    if (!wind) {
+      toast({ title: 'Wind nicht verfügbar', description: 'Keine Live-Daten für diesen Standort.', variant: 'destructive' })
+      return
+    }
+    await handleWindChange(wind.direction, { live: true })
+    toast({
+      title: 'Live-Wind übernommen',
+      description: `aus ${degToCompass(wind.direction)} (${wind.direction}°) · ${Math.round(wind.speed)} km/h${wind.gusts ? `, Böen ${Math.round(wind.gusts)} km/h` : ''}`,
+    })
+  }, [currentProject, handleWindChange, toast])
+
+  // Beim Öffnen eines Einsatzes ohne gesetzten Wind automatisch die aktuelle
+  // Windrichtung vorschlagen (nur einmal pro Projekt, online).
+  const autoWindRef = useRef<string | null>(null)
+  useEffect(() => {
+    const proj = currentProject
+    if (!proj?.id || typeof navigator === 'undefined' || !navigator.onLine) return
+    if (typeof proj.windDirection === 'number') return
+    if (autoWindRef.current === proj.id) return
+    autoWindRef.current = proj.id
+    const c = proj.mapCenter
+    if (!c?.lat || !c?.lng) return
+    fetchLiveWind(c.lat, c.lng).then((wind) => {
+      if (wind) handleWindChange(wind.direction, { live: true })
+    })
+  }, [currentProject?.id, currentProject?.windDirection, handleWindChange])
+
+  // Echtzeit: solange der Wind im Live-Modus ist, alle 10 Min. aktualisieren
+  useEffect(() => {
+    if (!currentProject?.id) return
+    const id = setInterval(() => {
+      if (!windLiveRef.current || typeof navigator === 'undefined' || !navigator.onLine) return
+      const c = mapRef.current?.getCenter?.() || currentProject.mapCenter
+      if (!c) return
+      fetchLiveWind(c.lat, c.lng).then((wind) => {
+        if (wind) handleWindChange(wind.direction, { live: true })
+      })
+    }, 10 * 60 * 1000)
+    return () => clearInterval(id)
+  }, [currentProject?.id, handleWindChange])
+
   // Fullscreen toggle
   const toggleFullscreen = useCallback(() => {
     if (!document.fullscreenElement) {
@@ -647,6 +767,7 @@ export default function AppPage() {
   }
 
   const handleFeaturesChange = useCallback((newFeatures: DrawFeature[]) => {
+    ensureEditing() // Auto-Bearbeitung: Lock übernehmen, falls noch nicht geschehen
     undoStackRef.current.push(featuresRef.current)
     redoStackRef.current = []
 
@@ -666,7 +787,7 @@ export default function AppPage() {
 
     setFeatures(newFeatures)
     broadcastFeatures(newFeatures)
-  }, [addAudit, broadcastFeatures])
+  }, [addAudit, broadcastFeatures, ensureEditing])
 
   // Wendet den gewählten Linientyp an: setzt properties.lineType und – bei Leitung/
   // Rettungsachse – die konventionelle Farbe/Stärke (Normal behält die Zeichenfarbe).
@@ -723,12 +844,14 @@ export default function AppPage() {
 
   // Tap-to-place: Symbol antippen → Sidebar schliessen, Karte zeigen, nächster Tipp platziert
   const handleSymbolSelect = useCallback((symbol: { id: string; imageUrl: string }) => {
+    ensureEditing() // Lock schon beim Auswählen übernehmen, damit das Platzieren sofort greift
     setPendingSymbol(symbol)
+    setPlacedCount(0)
     setIsSidebarOpen(false)
     setActiveTab('map')
     setDrawMode('select')
-    toast({ title: 'Symbol platzieren', description: 'Tippe auf die Karte, um das Symbol zu setzen.' })
+    toast({ title: 'Symbol platzieren', description: 'Auf die Karte tippen — mehrere möglich, dann „Fertig".' })
-  }, [setIsSidebarOpen, setActiveTab, toast])
+  }, [setIsSidebarOpen, setActiveTab, toast, ensureEditing, setDrawMode])
 
   const handleTextPlace = useCallback((coordinates: [number, number]) => {
     setTextPlaceCoords(coordinates)
@@ -783,7 +906,7 @@ export default function AppPage() {
     onRedo: handleRedo,
     onSave: handleSaveProject,
     onDelete: handleFeaturesChange,
-    onToolChange: setDrawMode,
+    onToolChange: handleDrawModeChange, // Auto-Bearbeitung greift auch bei Tastenkürzeln
     onHelpOpen: useCallback(() => setIsShortcutHelpOpen(true), []),
   })
 
@@ -907,93 +1030,84 @@ export default function AppPage() {
               handleStopEditing()
             }
           }}
+          windLive={windLive}
+          onWindChange={canEditMap ? (d) => handleWindChange(d) : undefined}
+          onFetchLiveWind={canEditMap ? handleFetchLiveWind : undefined}
+          isEditingByMe={isEditingByMe}
+          onStopEditing={handleStopEditing}
+          editingLoading={editingLoading}
         />
 
-        {/* Übungs-Banner — verhindert Verwechslung mit echtem Einsatz */}
+        <UsageNoticeBanner />
-        {currentProject?.mode === 'UEBUNG' && (
-          <div className="flex items-center justify-center gap-2 px-4 py-1 md:py-1.5 bg-blue-600 text-white text-xs md:text-sm font-semibold tracking-wide">
-            <GraduationCap className="w-4 h-4 shrink-0" />
-            <span>ÜBUNG — kein realer Einsatz</span>
-          </div>
-        )}
 
-        {/* Offline banner */}
+        {/* Kompakte Status-Zeile — eine Zeile mit Chips statt bis zu vier gestapelten Bannern.
-        {isOffline && (
+            Zeigt nur, was gerade zutrifft; im Normalfall (Einsatz, online, verifiziert,
-          <div className="flex items-center justify-center gap-2 md:gap-3 px-3 md:px-4 py-1.5 md:py-2 bg-orange-50 dark:bg-orange-950/40 border-b border-orange-200 dark:border-orange-800 text-xs md:text-sm text-orange-800 dark:text-orange-300">
+            niemand fremd am Zeichnen) erscheint sie gar nicht. */}
-            <WifiOff className="w-4 h-4 shrink-0" />
+        {(currentProject?.mode === 'UEBUNG' || isOffline || isReadOnly || isEditingByMe || (currentProject && roleCanEdit && !presentationLocked) || (user && user.emailVerified === false)) && (
-            <span>
+          <div data-tour="edit-toggle" className="flex flex-wrap items-center gap-1.5 px-3 py-1 border-b bg-muted/30 text-xs">
-              <strong>Offline</strong><span className="hidden sm:inline">-Modus — Änderungen werden lokal gespeichert und beim Reconnect synchronisiert.</span>
+            {currentProject?.mode === 'UEBUNG' && (
-              {syncQueueCount > 0 && ` (${syncQueueCount} ausstehend)`}
+              <span className="inline-flex items-center gap-1 rounded-full bg-blue-600 text-white font-semibold px-2 py-0.5">
-            </span>
+                <GraduationCap className="w-3.5 h-3.5" /> ÜBUNG — kein realer Einsatz
-          </div>
+              </span>
-        )}
+            )}
-
+            {isOffline && (
-        {/* Email verification banner */}
+              <span className="inline-flex items-center gap-1 rounded-full bg-orange-100 text-orange-800 dark:bg-orange-950/50 dark:text-orange-300 font-medium px-2 py-0.5">
-        {user && user.emailVerified === false && (
+                <WifiOff className="w-3.5 h-3.5" /> Offline{syncQueueCount > 0 ? ` · ${syncQueueCount} ausstehend` : ''}
-          <div className="flex items-center justify-center gap-2 md:gap-3 px-3 md:px-4 py-1.5 md:py-2 bg-amber-50 dark:bg-amber-950/40 border-b border-amber-200 dark:border-amber-800 text-xs md:text-sm text-amber-800 dark:text-amber-300">
+              </span>
-            <AlertTriangle className="w-4 h-4 shrink-0" />
+            )}
-            <span>E-Mail noch nicht bestätigt.<span className="hidden sm:inline"> Bitte prüfen Sie Ihren Posteingang.</span></span>
+            {isReadOnly && (
-            <button
+              <span className="inline-flex items-center gap-1 rounded-full bg-orange-100 text-orange-800 dark:bg-orange-950/50 dark:text-orange-300 font-medium px-2 py-0.5">
-              onClick={async () => {
+                <Lock className="w-3.5 h-3.5" /> <strong className="font-semibold">{editingBy?.name}</strong> bearbeitet gerade · Sie sehen live zu (nur Ansicht)
-                try {
+              </span>
-                  const res = await fetch('/api/auth/resend-verification', {
+            )}
-                    method: 'POST',
+            {isEditingByMe && (
-                    headers: { 'Content-Type': 'application/json' },
+              <span className="inline-flex items-center gap-1 rounded-full bg-green-100 text-green-800 dark:bg-green-950/50 dark:text-green-300 font-medium px-2 py-0.5">
-                    body: JSON.stringify({ email: user.email }),
+                <Pencil className="w-3.5 h-3.5" /> Sie bearbeiten — andere sehen nur zu
-                  })
+                <button onClick={handleStopEditing} disabled={editingLoading} className="ml-1.5 font-semibold underline hover:no-underline disabled:opacity-50" title="Karte speichern & für andere freigeben">
-                  if (res.ok) toast({ title: 'Bestätigungsmail gesendet', description: 'Bitte prüfen Sie Ihren Posteingang.' })
+                  freigeben
-                  else toast({ title: 'Fehler', description: 'Konnte Bestätigungsmail nicht senden.', variant: 'destructive' })
+                </button>
-                } catch { toast({ title: 'Fehler', description: 'Verbindungsfehler.', variant: 'destructive' }) }
+              </span>
-              }}
+            )}
-              className="shrink-0 text-xs font-semibold underline hover:no-underline text-amber-700 dark:text-amber-400"
+            {/* Karte ist frei und ich dürfte bearbeiten — expliziter Hinweis + Übernehmen,
-            >
+                damit klar ist, dass man gerade nur zuschaut, bis man selbst startet. */}
-              Erneut senden
+            {currentProject && roleCanEdit && !isReadOnly && !isEditingByMe && !presentationLocked && (
-            </button>
+              <span className="inline-flex items-center gap-1 rounded-full bg-muted text-muted-foreground font-medium px-2 py-0.5">
-          </div>
+                <Eye className="w-3.5 h-3.5" /> Ansichtsmodus — frei
-        )}
+                <button onClick={ensureEditing} disabled={editingLoading} className="ml-1.5 font-semibold text-foreground underline hover:no-underline disabled:opacity-50" title="Bearbeitung übernehmen — sperrt die Karte für andere">
-
+                  Bearbeiten übernehmen
-        {/* Live editing banner */}
+                </button>
-        {currentProject && (
+              </span>
-          <div className="flex items-center justify-between gap-2 px-3 md:px-4 py-1.5 bg-muted/50 border-b text-xs md:text-sm">
+            )}
-            {isReadOnly ? (
+            {user && user.emailVerified === false && (
-              <div className="flex items-center gap-2 text-orange-600 min-w-0">
+              <span className="inline-flex items-center gap-1 rounded-full bg-amber-100 text-amber-800 dark:bg-amber-950/50 dark:text-amber-300 font-medium px-2 py-0.5">
-                <Eye className="w-4 h-4 shrink-0" />
+                <AlertTriangle className="w-3.5 h-3.5" /> E-Mail unbestätigt
-                <span className="truncate"><strong>{editingBy?.name}</strong> bearbeitet die Karte<span className="hidden sm:inline"> — Live-Ansicht{roleCanEdit ? ' · Journal bleibt für Sie bearbeitbar' : ''}</span></span>
+                <button
-              </div>
+                  onClick={async () => {
-            ) : isEditingByMe ? (
+                    try {
-              <div className="flex items-center gap-2 text-green-600 min-w-0">
+                      const res = await fetch('/api/auth/resend-verification', {
-                <Lock className="w-4 h-4 shrink-0" />
+                        method: 'POST',
-                <span className="truncate">Sie bearbeiten die Karte<span className="hidden sm:inline"> — andere sehen Ihre Änderungen in Echtzeit</span></span>
+                        headers: { 'Content-Type': 'application/json' },
-              </div>
+                        body: JSON.stringify({ email: user.email }),
-            ) : (
+                      })
-              <div className="flex items-center gap-2 text-muted-foreground min-w-0">
+                      if (res.ok) toast({ title: 'Bestätigungsmail gesendet', description: 'Bitte prüfen Sie Ihren Posteingang.' })
-                <Unlock className="w-4 h-4 shrink-0" />
+                      else toast({ title: 'Fehler', description: 'Konnte Bestätigungsmail nicht senden.', variant: 'destructive' })
-                <span className="truncate">Niemand bearbeitet gerade</span>
+                    } catch { toast({ title: 'Fehler', description: 'Verbindungsfehler.', variant: 'destructive' }) }
-              </div>
+                  }}
+                  className="ml-1 underline hover:no-underline"
+                >
+                  senden
+                </button>
+              </span>
             )}
-            <div data-tour="edit-toggle" className="flex items-center gap-2 shrink-0">
-              {roleCanEdit && !isEditingByMe && !isReadOnly && (
-                <Button size="sm" variant="default" onClick={handleStartEditing} disabled={editingLoading}>
-                  <Lock className="w-3.5 h-3.5 mr-1" />
-                  Bearbeitung starten
-                </Button>
-              )}
-              {isEditingByMe && (
-                <Button size="sm" variant="outline" onClick={handleStopEditing} disabled={editingLoading}>
-                  <Unlock className="w-3.5 h-3.5 mr-1" />
-                  Bearbeitung beenden
-                </Button>
-              )}
-            </div>
           </div>
         )}
 
         <div className="flex-1 flex overflow-hidden">
           {/* Map view — always mounted, hidden via CSS to preserve state */}
-          <div data-tour="toolbar" className={`contents ${activeTab !== 'map' ? 'hidden' : ''}`}>
+          <div className={`contents ${activeTab !== 'map' ? 'hidden' : ''}`}>
             <LeftToolbar
               drawMode={drawMode || 'select'}
-              onDrawModeChange={setDrawMode}
+              onDrawModeChange={handleDrawModeChange}
               selectedColor={selectedColor}
               onColorChange={setSelectedColor}
               selectedWidth={selectedWidth}
@@ -1020,7 +1134,12 @@ export default function AppPage() {
                 onDrawModeChange={setDrawMode}
                 undoDrawPointRef={undoDrawPointRef}
                 pendingSymbol={pendingSymbol ? { iconId: pendingSymbol.id, imageUrl: pendingSymbol.imageUrl } : null}
-                onSymbolPlaced={() => setPendingSymbol(null)}
+                onSymbolPlaced={() => setPlacedCount((n) => n + 1)}
+                isFullscreen={isFullscreen}
+                onToggleFullscreen={toggleFullscreen}
+                windDirection={currentProject?.windDirection}
+                onWindChange={handleWindChange}
+                onFetchLiveWind={handleFetchLiveWind}
               />
             </main>
           </div>
@@ -1048,6 +1167,7 @@ export default function AppPage() {
                 einsatzNr={(currentProject as any)?.einsatzNr || ''}
                 canEdit={canEditJournal}
                 tenantId={tenant?.id || null}
+                projectTenantId={(currentProject as any)?.tenantId ?? null}
                 tenantName={tenant?.name || ''}
                 tenantLogoUrl={tenant?.id ? `/api/admin/tenants/${tenant.id}/logo/serve` : null}
                 mapRef={mapRef}
@@ -1058,7 +1178,6 @@ export default function AppPage() {
 
           {/* Right sidebar — always visible, contains Karte/Journal tabs */}
           <RightSidebar
-            data-tour="sidebar"
             onSymbolDrop={handleSymbolDrop}
             onSymbolSelect={handleSymbolSelect}
             canEdit={canEdit}
@@ -1073,13 +1192,20 @@ export default function AppPage() {
           />
         </div>
 
-        {/* Tap-to-place Hinweis — schwebt über der Bottom-Nav, mit Abbrechen */}
+        {/* Tap-to-place Hinweis — schwebt über der Bottom-Nav; mehrere setzen, dann „Fertig" */}
         {pendingSymbol && (
-          <div className="fixed left-1/2 -translate-x-1/2 z-40 bottom-[76px] md:bottom-6 flex items-center gap-2 px-3 py-2 rounded-full bg-primary text-primary-foreground shadow-lg text-sm">
+          <div className="fixed left-1/2 -translate-x-1/2 z-40 bottom-[76px] md:bottom-6 flex items-center gap-2 pl-3 pr-2 py-2 rounded-full bg-primary text-primary-foreground shadow-lg text-sm">
             <img src={pendingSymbol.imageUrl} alt="" className="w-5 h-5 object-contain bg-white rounded" crossOrigin="anonymous" />
-            <span>Auf die Karte tippen zum Platzieren</span>
+            <span>
-            <button onClick={() => setPendingSymbol(null)} className="ml-1 p-0.5 rounded-full hover:bg-white/20" title="Abbrechen">
+              {placedCount > 0
-              <X className="w-4 h-4" />
+                ? `Auf Karte tippen · ${placedCount} gesetzt`
+                : 'Auf die Karte tippen zum Platzieren'}
+            </span>
+            <button
+              onClick={() => { setPendingSymbol(null); setPlacedCount(0) }}
+              className="ml-1 px-2.5 py-1 rounded-full bg-white/20 hover:bg-white/30 text-xs font-semibold"
+            >
+              Fertig
             </button>
           </div>
         )}

src/app/datenschutz/page.tsx

@@ -1,187 +1,207 @@
 'use client'
 
-import Link from 'next/link'
+import { LegalPage } from '@/components/legal/legal-page'
-import { ArrowLeft, Shield, Server, Trash2, Mail } from 'lucide-react'
+import { legal, isPlaceholder } from '@/config/legal'
+
+function Val({ value }: { value: string }) {
+  if (isPlaceholder(value)) {
+    return <span className="text-amber-600 dark:text-amber-400 font-medium">{value}</span>
+  }
+  return <span className="text-foreground font-medium">{value}</span>
+}
 
 export default function DatenschutzPage() {
+  const d = legal.documents.privacy
   return (
-    <div className="min-h-screen bg-gradient-to-br from-slate-900 via-slate-800 to-slate-900 px-4 py-12">
+    <LegalPage
-      <div className="max-w-3xl mx-auto">
+      title="Datenschutzerklärung"
-        <Link href="/" className="text-sm text-gray-400 hover:text-gray-300 inline-flex items-center gap-1 mb-8">
+      version={d.version}
-          <ArrowLeft className="w-3.5 h-3.5" />
+      publishedAt={d.publishedAt}
-          Zurück zur Startseite
+      intro={`Diese Erklärung informiert transparent darüber, welche Personendaten ${legal.projectName} bearbeitet, zu welchem Zweck und wer daran beteiligt ist. Sie orientiert sich am Schweizer Datenschutzgesetz (DSG).`}
-        </Link>
+    >
+      <section>
+        <h2>1. Verantwortlicher</h2>
+        <p>
+          Verantwortlich für die Datenbearbeitung ist der Betreiber der Plattform{' '}
+          <Val value={legal.operatorName} /> (<Val value={legal.operatorLegalForm} />),{' '}
+          <Val value={legal.postalAddress} />.
+        </p>
+        <p><strong>Datenschutzkontakt:</strong> <Val value={legal.privacyContactEmail} /></p>
+      </section>
 
-        <div className="bg-card rounded-xl shadow-2xl p-8 md:p-12 border border-border">
+      <section>
-          <div className="flex items-center gap-3 mb-6">
+        <h2>2. Welche Daten werden bearbeitet?</h2>
-            <div className="w-10 h-10 bg-red-600 rounded-full flex items-center justify-center">
+        <ul>
-              <Shield className="w-5 h-5 text-white" />
+          <li><strong>Registrierungs-/Kontodaten:</strong> Name, E-Mail-Adresse, Organisationsname, Rolle. Das Passwort wird mit einem geeigneten Einwegverfahren (bcrypt) gehasht und nie im Klartext gespeichert.</li>
-            </div>
+          <li><strong>Einsatz-/Inhaltsdaten:</strong> Lagepläne, Journaleinträge, Zeichnungen, Koordinaten, Symbole, hochgeladene Dateien (Logos, Planbilder, Symbole) sowie zugehörige Projekt- und Organisationsdaten.</li>
-            <h1 className="text-3xl font-bold text-foreground">Datenschutzerklärung</h1>
+          <li><strong>Protokoll-/Sicherheitsdaten:</strong> technische Zugriffs- und Fehlerprotokolle (z.B. Zeitpunkt, ungefähre technische Angaben) zur Gewährleistung von Betrieb und Sicherheit.</li>
-          </div>
+          <li><strong>Zustimmungsnachweise:</strong> welche Version der Nutzungsbedingungen/Datenschutzerklärung/Organisationsbestätigung wann akzeptiert wurde — zu Beweiszwecken zusammen mit IP-Adresse und Gerät/Browser (User-Agent) sowie dem Dokument-Prüfwert (Hash).</li>
+          <li><strong>Unterstützungsbeiträge (optional):</strong> bei freiwilligen Beiträgen der Betrag sowie freiwillig angegebener Name/Nachricht (Zahlungsabwicklung siehe Ziffer 9).</li>
+        </ul>
+      </section>
 
-          <p className="text-muted-foreground mb-8">
+      <section>
-            Gültig ab 1. Januar 2026 — Lageplan.ch, betrieben in der Schweiz.
+        <h2>3. Zwecke</h2>
-          </p>
+        <ul>
+          <li>Bereitstellung und Betrieb der Applikation, Authentifizierung und Benutzer-/Organisationsverwaltung</li>
+          <li>Echtzeit-Synchronisierung von Einsatzdaten zwischen berechtigten Teammitgliedern</li>
+          <li>Erstellung von Rapporten und PDF-/PNG-Exporten</li>
+          <li>Gewährleistung von Sicherheit, Stabilität und Missbrauchsprävention</li>
+          <li>Technischer Support und Fehlerbehebung</li>
+          <li>Erfüllung rechtlicher Pflichten (soweit anwendbar)</li>
+        </ul>
+      </section>
 
-          {/* 1. Verantwortlicher */}
+      <section>
-          <section className="mb-8">
+        <h2>4. Grundlagen der Bearbeitung</h2>
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
+        <p>
-              <span className="text-red-500 font-mono text-sm">01</span>
+          Die Bearbeitung erfolgt insbesondere zur Erfüllung des Nutzungsverhältnisses (Vertrag), aufgrund
-              Verantwortlicher
+          berechtigter Interessen am sicheren und stabilen Betrieb sowie – wo erforderlich – gestützt auf Ihre
-            </h2>
+          Einwilligung. Zwingende gesetzliche Bestimmungen bleiben vorbehalten.
-            <p className="text-muted-foreground text-sm leading-relaxed">
+        </p>
-              Verantwortlich für die Datenverarbeitung auf lageplan.ch ist der Betreiber der Plattform. 
+      </section>
-              Bei Fragen zum Datenschutz wenden Sie sich bitte an die im Impressum angegebene Kontaktadresse 
-              oder per E-Mail an <span className="text-foreground font-medium">datenschutz@lageplan.ch</span>.
-            </p>
-          </section>
 
-          {/* 2. Welche Daten */}
+      <section id="dienstleister" className="scroll-mt-20">
-          <section className="mb-8">
+        <h2>5. Empfänger und Dienstleister (Subprozessoren)</h2>
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
+        <p>
-              <span className="text-red-500 font-mono text-sm">02</span>
+          Für den technischen Betrieb können sorgfältig ausgewählte Dienstleister eingesetzt werden. Nachfolgend
-              Welche Daten werden erhoben?
+          die tatsächlich eingesetzten bzw. optional konfigurierbaren Dienste. Einige Karten-, Geocoding- und
-            </h2>
+          Wetterdienste werden direkt aus Ihrem Browser aufgerufen; dabei kann die aufgerufene Kachel-/Standort-
-            <div className="space-y-3 text-sm text-muted-foreground leading-relaxed">
+          Anfrage (und damit Ihre IP-Adresse) an den jeweiligen Anbieter übermittelt werden.
-              <p><strong className="text-foreground">Registrierungsdaten:</strong> Name, E-Mail-Adresse, Organisationsname, Passwort (verschlüsselt gespeichert).</p>
+        </p>
-              <p><strong className="text-foreground">Einsatzdaten:</strong> Lagepläne, Journal-Einträge, Zeichnungen, Koordinaten, Symbole und zugehörige Projektdaten, die Sie in der Applikation erstellen.</p>
+        <div className="overflow-x-auto">
-              <p><strong className="text-foreground">Technische Daten:</strong> IP-Adresse, Browser-Typ, Zugriffszeitpunkt — ausschliesslich für den Betrieb und die Sicherheit der Plattform.</p>
+          <table className="w-full text-xs border-collapse mt-2">
-              <p><strong className="text-foreground">Hochgeladene Dateien:</strong> Logos, Planbilder und Symbole, die Sie über die Applikation hochladen.</p>
+            <thead>
-            </div>
+              <tr className="text-left text-foreground border-b border-border">
-          </section>
+                <th className="py-1.5 pr-3">Dienst</th>
-
+                <th className="py-1.5 pr-3">Zweck</th>
-          {/* 3. Zweck */}
+                <th className="py-1.5 pr-3">Daten</th>
-          <section className="mb-8">
+                <th className="py-1.5">Region</th>
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
+              </tr>
-              <span className="text-red-500 font-mono text-sm">03</span>
+            </thead>
-              Zweck der Datenverarbeitung
+            <tbody>
-            </h2>
+              {legal.processors.map(p => (
-            <div className="space-y-2 text-sm text-muted-foreground leading-relaxed">
+                <tr key={p.name} className="border-b border-border/50 align-top">
-              <p>Ihre Daten werden ausschliesslich für folgende Zwecke verwendet:</p>
+                  <td className="py-1.5 pr-3 text-foreground font-medium">{p.name}{p.optional ? ' *' : ''}</td>
-              <ul className="list-disc pl-5 space-y-1">
+                  <td className="py-1.5 pr-3">{p.purpose}</td>
-                <li>Bereitstellung und Betrieb der Lageplan-Applikation</li>
+                  <td className="py-1.5 pr-3">{p.data}</td>
-                <li>Authentifizierung und Benutzerverwaltung</li>
+                  <td className="py-1.5">{isPlaceholder(p.region) ? <span className="text-amber-600 dark:text-amber-400">{p.region}</span> : p.region}</td>
-                <li>Echtzeit-Synchronisierung von Einsatzdaten zwischen Teammitgliedern</li>
+                </tr>
-                <li>Erstellung von Einsatzrapports und PDF-Exporten</li>
+              ))}
-                <li>Technischer Support und Fehlerbehebung</li>
+            </tbody>
-              </ul>
+          </table>
-            </div>
-          </section>
-
-          {/* 4. Betrieb und Wartung */}
-          <section className="mb-8">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <span className="text-red-500 font-mono text-sm">04</span>
-              Betrieb, Wartung und Support
-            </h2>
-            <div className="space-y-3 text-sm text-muted-foreground leading-relaxed">
-              <p>
-                Für den sicheren und zuverlässigen Betrieb der Plattform können autorisierte Mitarbeitende 
-                des Betreibers im Rahmen ihrer Aufgaben auf Systemdaten zugreifen. Dies geschieht ausschliesslich zu folgenden Zwecken:
-              </p>
-              <ul className="list-disc pl-5 space-y-1">
-                <li>Sicherstellung der Systemverfügbarkeit und -stabilität</li>
-                <li>Fehlerbehebung und technischer Support auf Anfrage</li>
-                <li>Durchführung von Wartungs- und Aktualisierungsarbeiten</li>
-                <li>Gewährleistung der Datensicherheit und Missbrauchsprävention</li>
-              </ul>
-              <p>
-                Der Zugriff erfolgt unter Einhaltung strikter Vertraulichkeitspflichten und wird auf das 
-                betrieblich notwendige Minimum beschränkt. Personenbezogene Daten werden nicht an Dritte weitergegeben 
-                und ausschliesslich im Rahmen der oben genannten Zwecke verarbeitet.
-              </p>
-            </div>
-          </section>
-
-          {/* 5. Hosting & Speicherung */}
-          <section className="mb-8">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <Server className="w-4 h-4 text-red-500" />
-              <span><span className="text-red-500 font-mono text-sm mr-2">05</span>Hosting und Speicherung</span>
-            </h2>
-            <div className="space-y-2 text-sm text-muted-foreground leading-relaxed">
-              <p>
-                Alle Daten werden auf Servern in der <strong className="text-foreground">Schweiz</strong> gespeichert. 
-                Es findet keine Übermittlung von Daten ins Ausland statt.
-              </p>
-              <p>
-                Die Daten werden in einer PostgreSQL-Datenbank gespeichert. Dateien (Logos, Bilder) werden in einem 
-                S3-kompatiblen Objektspeicher (MinIO) abgelegt. Die Übertragung erfolgt verschlüsselt via HTTPS/TLS.
-              </p>
-            </div>
-          </section>
-
-          {/* 6. Datenlöschung */}
-          <section className="mb-8">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <Trash2 className="w-4 h-4 text-red-500" />
-              <span><span className="text-red-500 font-mono text-sm mr-2">06</span>Datenlöschung und Konto-Auflösung</span>
-            </h2>
-            <div className="space-y-2 text-sm text-muted-foreground leading-relaxed">
-              <p>
-                Sie haben jederzeit das Recht, Ihr Konto und Ihre Organisation inklusive aller zugehörigen Daten 
-                vollständig zu löschen. Dies können Sie selbstständig über die Applikation durchführen 
-                (Einstellungen → Organisation löschen).
-              </p>
-              <p>
-                Bei der Löschung werden sämtliche Daten unwiderruflich entfernt: Benutzerkonten, Projekte, 
-                Lagepläne, Journal-Einträge, Rapports, hochgeladene Dateien und alle zugehörigen Metadaten.
-              </p>
-              <p>
-                Alternativ können Sie die Löschung per E-Mail an <span className="text-foreground font-medium">datenschutz@lageplan.ch</span> beantragen.
-              </p>
-            </div>
-          </section>
-
-          {/* 7. Rechte */}
-          <section className="mb-8">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <span className="text-red-500 font-mono text-sm">07</span>
-              Ihre Rechte
-            </h2>
-            <div className="space-y-2 text-sm text-muted-foreground leading-relaxed">
-              <p>Gemäss dem Schweizer Datenschutzgesetz (DSG) und der DSGVO haben Sie folgende Rechte:</p>
-              <ul className="list-disc pl-5 space-y-1">
-                <li><strong className="text-foreground">Auskunftsrecht:</strong> Sie können Auskunft über Ihre gespeicherten Daten verlangen.</li>
-                <li><strong className="text-foreground">Berichtigungsrecht:</strong> Sie können die Korrektur unrichtiger Daten verlangen.</li>
-                <li><strong className="text-foreground">Löschungsrecht:</strong> Sie können die Löschung Ihrer Daten verlangen.</li>
-                <li><strong className="text-foreground">Datenportabilität:</strong> Sie können Ihre Daten in einem gängigen Format anfordern.</li>
-                <li><strong className="text-foreground">Widerspruchsrecht:</strong> Sie können der Verarbeitung Ihrer Daten widersprechen.</li>
-              </ul>
-            </div>
-          </section>
-
-          {/* 8. Cookies */}
-          <section className="mb-8">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <span className="text-red-500 font-mono text-sm">08</span>
-              Cookies
-            </h2>
-            <p className="text-sm text-muted-foreground leading-relaxed">
-              Die Applikation verwendet ausschliesslich <strong className="text-foreground">technisch notwendige Cookies</strong> für 
-              die Authentifizierung (Session-Token). Es werden keine Tracking-, Analyse- oder Werbe-Cookies eingesetzt. 
-              Es werden keine Daten an Dritte weitergegeben.
-            </p>
-          </section>
-
-          {/* 9. Kontakt */}
-          <section className="mb-4">
-            <h2 className="text-xl font-semibold text-foreground mb-3 flex items-center gap-2">
-              <Mail className="w-4 h-4 text-red-500" />
-              <span><span className="text-red-500 font-mono text-sm mr-2">09</span>Kontakt</span>
-            </h2>
-            <p className="text-sm text-muted-foreground leading-relaxed">
-              Bei Fragen oder Anliegen zum Datenschutz kontaktieren Sie uns unter:{' '}
-              <span className="text-foreground font-medium">datenschutz@lageplan.ch</span>
-            </p>
-          </section>
         </div>
+        <p className="text-xs">* nur aktiv, sofern konfiguriert/genutzt (z.B. Zahlungsabwicklung, E-Mail-Versand).</p>
+        <p>Personendaten werden nicht zu Werbezwecken an Dritte verkauft.</p>
+      </section>
 
-        <div className="text-center mt-6 text-xs text-gray-500">
+      <section>
-          © {new Date().getFullYear()} Lageplan.ch — Alle Rechte vorbehalten.
+        <h2>6. Bekanntgabe ins Ausland</h2>
-        </div>
+        <p>
-      </div>
+          Je nach eingesetztem Dienstleister (z.B. Zahlungsanbieter, konfigurierter E-Mail-Anbieter, globale
-    </div>
+          Kartendienste) kann eine Bearbeitung ausserhalb der Schweiz erfolgen. Der Betreiber wählt Dienstleister
+          sorgfältig aus. Eine ausschliessliche Speicherung in der Schweiz wird nicht pauschal zugesichert; die
+          konkreten Verarbeitungsregionen sind – soweit bekannt – in der Tabelle unter Ziffer 5 bzw. in{' '}
+          <code>docs/legal/subprocessors.md</code> aufgeführt. Offene Punkte sind mit Platzhaltern gekennzeichnet.
+        </p>
+      </section>
+
+      <section>
+        <h2>7. Sicherheit</h2>
+        <p>
+          Es werden angemessene technische und organisatorische Massnahmen eingesetzt (u.a. Rollen- und
+          Mandantentrennung, Passwort-Hashing, verschlüsselte Übertragung via HTTPS/TLS, Zugriffskontrollen,
+          Rate-Limiting). Ein vollständiger Schutz vor allen Risiken kann jedoch nicht garantiert werden.
+        </p>
+      </section>
+
+      <section>
+        <h2>8. Aufbewahrung und Löschung</h2>
+        <p>
+          Personendaten werden so lange aufbewahrt, wie es für die genannten Zwecke oder gesetzliche Pflichten
+          erforderlich ist. Produktivdaten werden nach Abschluss des Löschvorgangs entfernt. Daten in
+          Sicherungskopien (Backups) können bis zum Ablauf des regulären Backup-Zyklus fortbestehen
+          (Aufbewahrungsfrist der Backups: <Val value={legal.backupRetention} />). Die detaillierten Fristen sind in{' '}
+          <code>docs/legal/retention-and-deletion.md</code> dokumentiert.
+        </p>
+      </section>
+
+      <section>
+        <h2>9. Zahlungsabwicklung (freiwillige Beiträge)</h2>
+        <p>
+          Freiwillige Unterstützungsbeiträge werden über <strong>Stripe</strong> abgewickelt. Zahlungsdaten
+          (z.B. Kreditkarte, Twint) werden direkt bei Stripe erfasst und nicht in der Applikation gespeichert.
+          An Stripe werden der Betrag sowie ein freiwillig angegebener Name/Nachricht übermittelt. Es werden keine
+          wiederkehrenden Zahlungen eingerichtet. Details siehe{' '}
+          <a href="/unterstuetzen">Unterstützungsseite</a>.
+        </p>
+      </section>
+
+      <section>
+        <h2>10. Karten- und Geodienste</h2>
+        <p>
+          Für Karten, Adresssuche und Wetter-/Höhendaten werden Dienste von OpenStreetMap (Tiles/Nominatim),
+          Esri (Satellitenbilder), swisstopo (Landeskarte) sowie Open-Meteo/Open-Elevation genutzt. Diese Aufrufe
+          erfolgen aus Ihrem Browser; dabei kann Ihre IP-Adresse an die jeweiligen Anbieter übermittelt werden.
+          Karten-, Adress- und Geodaten können unvollständig, ungenau oder veraltet sein.
+        </p>
+      </section>
+
+      <section>
+        <h2>11. Cookies und lokale Speichertechnologien</h2>
+        <p>
+          Es wird ein einziges, technisch notwendiges Cookie gesetzt: <code>auth-token</code> (Session/Anmeldung,
+          httpOnly). Es werden keine Tracking-, Analyse- oder Werbe-Cookies eingesetzt.
+        </p>
+        <p>
+          Im lokalen Speicher (localStorage) Ihres Geräts werden zur Funktion technisch notwendige Angaben
+          abgelegt, u.a.: zwischengespeicherte Zeichnungen/Offline-Warteschlange, Cache-Zeitstempel für
+          Offline-Karten, Theme-Einstellung, zuletzt geöffnetes Projekt, Onboarding-Status und der Zustand des
+          Cookie-Hinweises. Diese Daten verbleiben auf Ihrem Gerät.
+        </p>
+      </section>
+
+      <section>
+        <h2>12. Protokolldaten</h2>
+        <p>
+          Zum Betrieb und zur Sicherheit können technische Protokolle anfallen. Diese werden auf das notwendige
+          Mass beschränkt; sensible Inhalte werden nach Möglichkeit von Protokollen ferngehalten.
+        </p>
+      </section>
+
+      <section>
+        <h2>13. Ihre Rechte</h2>
+        <p>Im Rahmen des anwendbaren Rechts stehen Ihnen insbesondere folgende Rechte zu:</p>
+        <ul>
+          <li><strong>Auskunft</strong> über die bearbeiteten Daten</li>
+          <li><strong>Berichtigung</strong> unrichtiger Daten</li>
+          <li><strong>Löschung</strong> (im Rahmen gesetzlicher Pflichten)</li>
+          <li><strong>Datenherausgabe/-export</strong> in einem gängigen Format</li>
+          <li><strong>Widerspruch</strong> gegen bestimmte Bearbeitungen</li>
+          <li><strong>Beschwerde</strong> bei der zuständigen Datenschutzbehörde (in der Schweiz: EDÖB)</li>
+        </ul>
+        <p>
+          Angemeldete Nutzer können Zustimmungen, Datenexport und Kontolöschung unter{' '}
+          <a href="/konto/datenschutz">Konto &amp; Datenschutz</a> einsehen bzw. anfordern. Anfragen richten Sie an{' '}
+          <Val value={legal.privacyContactEmail} />; der Eingang wird bestätigt.
+        </p>
+      </section>
+
+      <section>
+        <h2>14. Sicherheitsvorfälle</h2>
+        <p>
+          Bei einem Sicherheitsvorfall mit Risiko für betroffene Personen prüft der Betreiber die erforderlichen
+          Massnahmen und Informationspflichten nach einem definierten internen Prozess.
+        </p>
+      </section>
+
+      <section>
+        <h2>15. Änderungen dieser Datenschutzerklärung</h2>
+        <p>
+          Diese Datenschutzerklärung kann angepasst werden. Massgebend ist die jeweils veröffentlichte Version
+          (siehe Kopf dieser Seite). Bei wesentlichen Änderungen wird angemessen informiert.
+        </p>
+      </section>
+    </LegalPage>
   )
 }

src/app/impressum/page.tsx

@@ -31,21 +31,23 @@ export default function ImpressumPage() {
           <section>
             <h2 className="text-xl font-semibold text-gray-900 mb-3">Betreiber der Webseite</h2>
             <div className="bg-gray-50 rounded-xl p-6 space-y-1">
-              <p className="font-semibold text-gray-900">Purepixel</p>
+              <p className="font-semibold text-gray-900">Perparim Ziberi</p>
-              <p>Ein Angebot der Firma Kingstickers Ziberi</p>
+              <p className="text-gray-500 text-sm">Privatperson</p>
-              <p className="mt-3">Perparim Ziberi</p>
+              <p className="mt-3">Anglikerstrasse 56</p>
-              <p>Anglikerstrasse 56</p>
               <p>5612 Villmergen</p>
               <p>Schweiz</p>
               <p className="mt-3">
-                <span className="text-gray-500">UID:</span> CHE-353.865.879
-              </p>
-              <p>
                 <span className="text-gray-500">E-Mail:</span>{' '}
                 <a href="mailto:app@lageplan.ch" className="text-red-600 hover:text-red-500">
                   app@lageplan.ch
                 </a>
               </p>
+              <p>
+                <span className="text-gray-500">Datenschutz:</span>{' '}
+                <a href="mailto:datenschutz@lageplan.ch" className="text-red-600 hover:text-red-500">
+                  datenschutz@lageplan.ch
+                </a>
+              </p>
             </div>
           </section>
 
@@ -89,9 +91,9 @@ export default function ImpressumPage() {
             <h2 className="text-xl font-semibold text-gray-900 mb-3">Urheberrechte</h2>
             <p>
               Die Urheber- und alle anderen Rechte an Inhalten, Bildern, Fotos oder anderen Dateien auf
-              dieser Website gehören ausschliesslich der Firma Kingstickers Ziberi oder den speziell
+              dieser Website gehören ausschliesslich Perparim Ziberi oder den speziell genannten
-              genannten Rechtsinhabern. Für die Reproduktion jeglicher Elemente ist die schriftliche
+              Rechtsinhabern. Für die Reproduktion jeglicher Elemente ist die schriftliche Zustimmung der
-              Zustimmung der Urheberrechtsträger im Voraus einzuholen.
+              Urheberrechtsträger im Voraus einzuholen.
             </p>
           </section>
 
@@ -104,17 +106,20 @@ export default function ImpressumPage() {
               Privatsphäre sowie auf Schutz vor Missbrauch ihrer persönlichen Daten.
             </p>
             <p className="mt-2">
-              Wir halten diese Bestimmungen ein. Persönliche Daten werden streng vertraulich behandelt und
+              Persönliche Daten werden vertraulich behandelt und nicht an Dritte verkauft. Für den technischen
-              weder an Dritte verkauft noch weitergegeben.
+              Betrieb können sorgfältig ausgewählte Hosting-, Karten-, E-Mail-, Zahlungs- und
+              Infrastruktur-Dienstleister eingesetzt werden. Einzelheiten enthält die{' '}
+              <a href="/datenschutz" className="text-red-600 hover:text-red-500">Datenschutzerklärung</a>.
             </p>
             <p className="mt-2">
-              Die Nutzung der Applikation erfordert eine Registrierung. Dabei werden folgende Daten
+              Die Nutzung der Applikation erfordert eine Registrierung. Dabei werden insbesondere Name,
-              gespeichert: Name, E-Mail-Adresse, Organisationsname. Die Daten werden ausschliesslich für
+              E-Mail-Adresse und Organisationsname gespeichert. Passwörter werden mit einem geeigneten
-              den Betrieb der Applikation verwendet und auf Servern in der Schweiz gehostet.
+              Einwegverfahren (bcrypt) gehasht und nie im Klartext gespeichert.
             </p>
             <p className="mt-2">
-              Einsatzdaten (Lagepläne, Journaleinträge, Zeichnungen) werden verschlüsselt gespeichert und
+              Einsatzdaten (Lagepläne, Journaleinträge, Zeichnungen) sind nach dem Rollen- und
-              sind nur für berechtigte Benutzer der jeweiligen Organisation zugänglich.
+              Mandantenkonzept nur für berechtigte Benutzer der jeweiligen Organisation zugänglich. Die
+              Übertragung erfolgt über HTTPS/TLS.
             </p>
           </section>
 
@@ -139,7 +144,7 @@ export default function ImpressumPage() {
         </div>
 
         <div className="mt-12 pt-8 border-t border-gray-100 text-center">
-          <p className="text-sm text-gray-400">&copy; {new Date().getFullYear()} Lageplan — Purepixel / Kingstickers Ziberi</p>
+          <p className="text-sm text-gray-400">&copy; {new Date().getFullYear()} Lageplan — Perparim Ziberi</p>
         </div>
       </main>
     </div>

src/app/konto/datenschutz/page.tsx

@@ -0,0 +1,113 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import Link from 'next/link'
+import { ArrowLeft, Download, Trash2, Mail, ShieldCheck, Loader2 } from 'lucide-react'
+import { useAuth } from '@/components/providers/auth-provider'
+import { legal } from '@/config/legal'
+
+interface Acceptance { documentType: string; documentVersion: string; context: string; acceptedAt: string; organizationId: string | null }
+
+const DOC_URLS: Record<string, string> = {
+  TERMS: '/nutzungsbedingungen',
+  PRIVACY: '/datenschutz',
+  ORGANIZATION_DECLARATION: '/verantwortungsvolle-nutzung',
+  RESPONSIBLE_USE: '/verantwortungsvolle-nutzung',
+  DATA_PROCESSING_AGREEMENT: '/organisationen/datenschutzvereinbarung',
+}
+const DOC_LABELS: Record<string, string> = {
+  TERMS: 'Nutzungsbedingungen',
+  PRIVACY: 'Datenschutzerklärung',
+  ORGANIZATION_DECLARATION: 'Organisationsbestätigung',
+  RESPONSIBLE_USE: 'Verantwortungsvolle Nutzung',
+  DATA_PROCESSING_AGREEMENT: 'Datenschutzvereinbarung (Org.)',
+}
+
+export default function KontoDatenschutzPage() {
+  const { user, loading } = useAuth()
+  const router = useRouter()
+  const [acceptances, setAcceptances] = useState<Acceptance[] | null>(null)
+
+  useEffect(() => {
+    if (loading) return
+    if (!user) { router.replace('/login?redirect=/konto/datenschutz'); return }
+    fetch('/api/legal/my-acceptances').then(r => r.json()).then(d => setAcceptances(d.acceptances || [])).catch(() => setAcceptances([]))
+  }, [loading, user, router])
+
+  const exportSubject = encodeURIComponent('Datenexport-Anfrage')
+  const deleteSubject = encodeURIComponent('Kontolöschung-Anfrage')
+
+  return (
+    <div className="min-h-screen bg-background px-4 py-10">
+      <div className="max-w-2xl mx-auto">
+        <Link href="/app" className="text-sm text-muted-foreground hover:text-foreground inline-flex items-center gap-1 mb-6">
+          <ArrowLeft className="w-3.5 h-3.5" /> Zur App
+        </Link>
+
+        <h1 className="text-2xl font-bold text-foreground flex items-center gap-2">
+          <ShieldCheck className="w-6 h-6 text-red-600" /> Konto &amp; Datenschutz
+        </h1>
+
+        {/* Zustimmungen */}
+        <section className="mt-6">
+          <h2 className="font-semibold text-foreground mb-2">Meine Zustimmungen</h2>
+          {acceptances === null ? (
+            <div className="py-6 flex justify-center"><Loader2 className="w-5 h-5 animate-spin text-muted-foreground" /></div>
+          ) : acceptances.length === 0 ? (
+            <p className="text-sm text-muted-foreground">Noch keine protokollierten Zustimmungen.</p>
+          ) : (
+            <ul className="divide-y divide-border rounded-lg border border-border">
+              {acceptances.map((a, i) => (
+                <li key={i} className="flex items-center justify-between gap-3 px-4 py-2.5 text-sm">
+                  <div>
+                    <Link href={DOC_URLS[a.documentType] || '#'} target="_blank" className="text-foreground font-medium hover:underline">
+                      {DOC_LABELS[a.documentType] || a.documentType}
+                    </Link>
+                    <span className="text-muted-foreground"> · v{a.documentVersion}</span>
+                    <div className="text-xs text-muted-foreground">{a.context}</div>
+                  </div>
+                  <time className="text-xs text-muted-foreground shrink-0">
+                    {new Date(a.acceptedAt).toLocaleString('de-CH', { dateStyle: 'medium', timeStyle: 'short' })}
+                  </time>
+                </li>
+              ))}
+            </ul>
+          )}
+        </section>
+
+        {/* Rechte ausüben */}
+        <section className="mt-8 space-y-3">
+          <h2 className="font-semibold text-foreground">Ihre Rechte ausüben</h2>
+          <a
+            href={`mailto:${legal.privacyContactEmail}?subject=${exportSubject}`}
+            className="flex items-center gap-3 rounded-lg border border-border px-4 py-3 hover:bg-accent text-sm"
+          >
+            <Download className="w-4 h-4 text-muted-foreground" />
+            <span><strong className="text-foreground">Datenexport anfordern</strong><br /><span className="text-muted-foreground text-xs">Wir bestätigen den Eingang Ihrer Anfrage.</span></span>
+          </a>
+          <Link
+            href="/settings"
+            className="flex items-center gap-3 rounded-lg border border-border px-4 py-3 hover:bg-accent text-sm"
+          >
+            <Trash2 className="w-4 h-4 text-muted-foreground" />
+            <span><strong className="text-foreground">Konto/Organisation löschen</strong><br /><span className="text-muted-foreground text-xs">In den Einstellungen; organisationsrelevante Daten werden nach Berechtigungsprüfung entfernt.</span></span>
+          </Link>
+          <a
+            href={`mailto:${legal.privacyContactEmail}?subject=${deleteSubject}`}
+            className="flex items-center gap-3 rounded-lg border border-border px-4 py-3 hover:bg-accent text-sm"
+          >
+            <Mail className="w-4 h-4 text-muted-foreground" />
+            <span><strong className="text-foreground">Datenschutzkontakt</strong><br /><span className="text-muted-foreground text-xs">{legal.privacyContactEmail}</span></span>
+          </a>
+        </section>
+
+        <p className="mt-6 text-xs text-muted-foreground">
+          Hinweis: Produktivdaten werden nach Abschluss des Löschvorgangs entfernt. Daten in Sicherungskopien
+          können bis zum Ablauf des Backup-Zyklus fortbestehen. Details in der{' '}
+          <Link href="/datenschutz" className="underline">Datenschutzerklärung</Link>.
+        </p>
+      </div>
+    </div>
+  )
+}

src/app/layout.tsx

@@ -5,6 +5,7 @@ import { Toaster } from '@/components/ui/toaster'
 import { AuthProvider } from '@/components/providers/auth-provider'
 import { ServiceWorkerRegister } from '@/components/providers/sw-register'
 import { CookieConsent } from '@/components/ui/cookie-consent'
+import { LegalConsentGate } from '@/components/legal/legal-consent-gate'
 
 const barlow = Barlow({
   subsets: ['latin'],
@@ -109,6 +110,7 @@ export default function RootLayout({
         <AuthProvider>
           <ServiceWorkerRegister />
           {children}
+          <LegalConsentGate />
           <Toaster />
           <CookieConsent />
         </AuthProvider>

src/app/login/page.tsx

@@ -8,7 +8,7 @@ import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Label } from '@/components/ui/label'
 import { useToast } from '@/components/ui/use-toast'
-import { ArrowLeft, Loader2 } from 'lucide-react'
+import { ArrowLeft, Loader2, Eye, EyeOff } from 'lucide-react'
 import { LogoRound } from '@/components/ui/logo'
 
 export default function LoginPage() {
@@ -23,12 +23,17 @@ function LoginForm() {
   const [email, setEmail] = useState('')
   const [password, setPassword] = useState('')
   const [rememberMe, setRememberMe] = useState(true)
+  const [showPassword, setShowPassword] = useState(false)
   const [isLoading, setIsLoading] = useState(false)
   const [resendLoading, setResendLoading] = useState(false)
   const [resendSuccess, setResendSuccess] = useState(false)
   const [tenantLogo, setTenantLogo] = useState<string | null>(null)
   const [tenantName, setTenantName] = useState<string | null>(null)
-  const { login } = useAuth()
+  // MFA-Zwischenschritt
+  const [mfaToken, setMfaToken] = useState<string | null>(null)
+  const [mfaCode, setMfaCode] = useState('')
+  const [mfaMethods, setMfaMethods] = useState<{ totp: boolean; webauthn: boolean }>({ totp: false, webauthn: false })
+  const { login, verifyMfa, verifyMfaWebAuthn } = useAuth()
   const router = useRouter()
   const searchParams = useSearchParams()
   const { toast } = useToast()
@@ -52,6 +57,18 @@ function LoginForm() {
     }
   }, [tenantSlug])
 
+  const doRedirect = async () => {
+    if (redirectTo) { router.push(redirectTo); return }
+    try {
+      const meRes = await fetch('/api/auth/me')
+      if (meRes.ok) {
+        const meData = await meRes.json()
+        if (meData.user?.tenantSlug) { router.push(`/${meData.user.tenantSlug}`); return }
+      }
+    } catch {}
+    router.push('/app')
+  }
+
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault()
     setIsLoading(true)
@@ -59,26 +76,12 @@ function LoginForm() {
     const result = await login(email, password, rememberMe)
 
     if (result.success) {
-      toast({
+      toast({ title: 'Erfolgreich angemeldet', description: 'Willkommen bei Lageplan!' })
-        title: 'Erfolgreich angemeldet',
+      await doRedirect()
-        description: 'Willkommen bei Lageplan!',
+    } else if (result.mfaRequired && result.mfaToken) {
-      })
+      // Zweiter Faktor nötig — Code-Schritt anzeigen.
-      // Redirect: use explicit redirect param, or tenant slug, or /app
+      setMfaToken(result.mfaToken)
-      if (redirectTo) {
+      if (result.methods) setMfaMethods(result.methods)
-        router.push(redirectTo)
-      } else {
-        try {
-          const meRes = await fetch('/api/auth/me')
-          if (meRes.ok) {
-            const meData = await meRes.json()
-            if (meData.user?.tenantSlug) {
-              router.push(`/${meData.user.tenantSlug}`)
-              return
-            }
-          }
-        } catch {}
-        router.push('/app')
-      }
     } else {
       toast({
         title: 'Anmeldung fehlgeschlagen',
@@ -90,6 +93,33 @@ function LoginForm() {
     setIsLoading(false)
   }
 
+  const handleMfaSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    if (!mfaToken) return
+    setIsLoading(true)
+    const result = await verifyMfa(mfaToken, mfaCode)
+    if (result.success) {
+      toast({ title: 'Erfolgreich angemeldet', description: 'Willkommen bei Lageplan!' })
+      await doRedirect()
+    } else {
+      toast({ title: 'Code ungültig', description: result.error || 'Bitte erneut versuchen.', variant: 'destructive' })
+    }
+    setIsLoading(false)
+  }
+
+  const handleWebAuthn = async () => {
+    if (!mfaToken) return
+    setIsLoading(true)
+    const result = await verifyMfaWebAuthn(mfaToken)
+    if (result.success) {
+      toast({ title: 'Erfolgreich angemeldet', description: 'Willkommen bei Lageplan!' })
+      await doRedirect()
+    } else if (result.error !== 'Abgebrochen') {
+      toast({ title: 'Fehlgeschlagen', description: result.error || 'Bitte erneut versuchen.', variant: 'destructive' })
+    }
+    setIsLoading(false)
+  }
+
   return (
     <div className="min-h-screen flex items-center justify-center bg-gradient-to-br from-slate-900 via-slate-800 to-slate-900 px-4">
       <div className="w-full max-w-md">
@@ -142,7 +172,49 @@ function LoginForm() {
             </div>
           )}
 
-          <form onSubmit={handleSubmit} className="space-y-4">
+          {mfaToken && (
+            <div className="space-y-4">
+              <p className="text-sm text-gray-300">Zweiter Faktor erforderlich.</p>
+
+              {mfaMethods.webauthn && (
+                <Button type="button" onClick={handleWebAuthn} disabled={isLoading} className="w-full bg-red-600 hover:bg-red-700">
+                  {isLoading ? (<><Loader2 className="w-4 h-4 mr-2 animate-spin" /> Warten...</>) : 'Mit Sicherheitsschlüssel / Passkey anmelden'}
+                </Button>
+              )}
+
+              {mfaMethods.webauthn && mfaMethods.totp && (
+                <div className="flex items-center gap-2 text-xs text-gray-500"><span className="flex-1 h-px bg-gray-700" />oder Code<span className="flex-1 h-px bg-gray-700" /></div>
+              )}
+
+              {mfaMethods.totp && (
+                <form onSubmit={handleMfaSubmit} className="space-y-3">
+                  <div className="space-y-1.5">
+                    <Label htmlFor="mfa-code">Bestätigungscode</Label>
+                    <Input
+                      id="mfa-code"
+                      inputMode="numeric"
+                      autoFocus
+                      autoComplete="one-time-code"
+                      placeholder="6-stelliger Code oder Backup-Code"
+                      value={mfaCode}
+                      onChange={(e) => setMfaCode(e.target.value)}
+                      disabled={isLoading}
+                    />
+                    <p className="text-xs text-gray-400">Code aus deiner Authenticator-App. Kein Zugriff darauf? Verwende einen deiner Backup-Codes.</p>
+                  </div>
+                  <Button type="submit" className="w-full bg-red-600 hover:bg-red-700" disabled={isLoading || mfaCode.trim().length < 6}>
+                    {isLoading ? (<><Loader2 className="w-4 h-4 mr-2 animate-spin" /> Prüfen...</>) : 'Bestätigen'}
+                  </Button>
+                </form>
+              )}
+
+              <button type="button" onClick={() => { setMfaToken(null); setMfaCode('') }} className="w-full text-sm text-gray-400 hover:text-gray-200">
+                Abbrechen
+              </button>
+            </div>
+          )}
+
+          <form onSubmit={handleSubmit} className={`space-y-4 ${mfaToken ? 'hidden' : ''}`}>
             <div className="space-y-1.5">
               <Label htmlFor="email">E-Mail</Label>
               <Input
@@ -163,15 +235,27 @@ function LoginForm() {
                   Passwort vergessen?
                 </Link>
               </div>
-              <Input
+              <div className="relative">
-                id="password"
+                <Input
-                type="password"
+                  id="password"
-                placeholder="••••••••"
+                  type={showPassword ? 'text' : 'password'}
-                value={password}
+                  placeholder="••••••••"
-                onChange={(e) => setPassword(e.target.value)}
+                  value={password}
-                required
+                  onChange={(e) => setPassword(e.target.value)}
-                disabled={isLoading}
+                  required
-              />
+                  disabled={isLoading}
+                  className={`pr-11 transition-all duration-200 ${showPassword ? '' : 'text-xl tracking-[0.25em]'}`}
+                />
+                <button
+                  type="button"
+                  onClick={() => setShowPassword(v => !v)}
+                  tabIndex={-1}
+                  aria-label={showPassword ? 'Passwort verbergen' : 'Passwort anzeigen'}
+                  className="absolute right-2 top-1/2 -translate-y-1/2 p-1.5 rounded-md text-gray-400 hover:text-gray-200 transition-colors"
+                >
+                  {showPassword ? <EyeOff className="w-4 h-4" /> : <Eye className="w-4 h-4" />}
+                </button>
+              </div>
             </div>
 
             <label className="flex items-center gap-2 cursor-pointer select-none">

src/app/nutzungsbedingungen/page.tsx

@@ -0,0 +1,207 @@
+'use client'
+
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal } from '@/config/legal'
+
+export default function NutzungsbedingungenPage() {
+  const d = legal.documents.terms
+  return (
+    <LegalPage
+      title="Nutzungsbedingungen"
+      version={d.version}
+      publishedAt={d.publishedAt}
+      intro={`Diese Nutzungsbedingungen regeln die Nutzung von ${legal.projectName} (Website, Anwendung, Benutzerkonten, Organisationen, Exporte und unterstützende Funktionen).`}
+    >
+      <section>
+        <h2>1. Geltungsbereich</h2>
+        <p>
+          Diese Bedingungen gelten für die Website, die Anwendung, Benutzerkonten, Organisationen, Exporte und
+          unterstützende Funktionen von {legal.projectName}. <strong>Betreiber</strong> ist der Anbieter der
+          Plattform; <strong>Benutzer</strong> ist jede natürliche Person mit Konto; <strong>Organisation</strong>
+          {' '}ist eine Feuerwehr oder Einheit mit eigenem Mandanten; <strong>Plattform</strong> bezeichnet die
+          Gesamtheit der bereitgestellten Dienste.
+        </p>
+      </section>
+
+      <section>
+        <h2>2. Zweck von {legal.projectName}</h2>
+        <p>{legal.projectName} ist ein unterstützendes Werkzeug für:</p>
+        <ul>
+          <li>Erstellung und Verwaltung von Lage- und Objektplänen</li>
+          <li>Dokumentation und Visualisierung</li>
+          <li>Zusammenarbeit</li>
+          <li>Export von Unterlagen</li>
+          <li>unterstützende Berechnungen</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>3. Kein Einsatzleitsystem</h2>
+        <ul>
+          <li>{legal.projectName} ist <strong>kein Alarmierungssystem</strong>.</li>
+          <li>{legal.projectName} ist <strong>kein Einsatzleitsystem</strong> und ersetzt keine Einsatzleitung.</li>
+          <li>{legal.projectName} ersetzt keine Leitstelle.</li>
+          <li>{legal.projectName} ersetzt keine gesetzlich oder organisatorisch vorgeschriebenen Unterlagen.</li>
+          <li>{legal.projectName} darf <strong>nicht als einzige Informationsquelle</strong> verwendet werden.</li>
+          <li>Die Organisation muss unabhängig aktuelle <strong>Offline- und Notfallunterlagen</strong> bereithalten.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>4. Fachliche Prüfung</h2>
+        <ul>
+          <li>Pläne müssen von fachkundigen Personen geprüft und freigegeben werden.</li>
+          <li>Adressen, Distanzen, Symbole, Massstäbe, Hydranten, Zufahrten und Berechnungen können fehlerhaft oder veraltet sein.</li>
+          <li>Automatisch erzeugte oder berechnete Angaben sind Hilfsmittel.</li>
+          <li>Für operative Entscheidungen bleibt die zuständige Feuerwehr bzw. Organisation verantwortlich.</li>
+          <li>Änderungen an Gebäuden, Zufahrten, Wasserbezugsstellen oder Gefahren müssen durch die Organisation aktualisiert werden.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>5. Benutzerkonten und Organisationen</h2>
+        <ul>
+          <li>Benutzer müssen richtige Angaben machen.</li>
+          <li>Zugangsdaten dürfen nicht weitergegeben werden.</li>
+          <li>Organisationen müssen Berechtigungen regelmässig kontrollieren.</li>
+          <li>Ausgetretene Benutzer müssen entfernt werden.</li>
+          <li>Organisationsadministratoren müssen zur Vertretung ihrer Organisation berechtigt sein.</li>
+          <li>Aktivitäten innerhalb eines Organisationskontos können protokolliert werden.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>6. Verbotene Inhalte</h2>
+        <p>Ohne separate schriftliche Vereinbarung ist insbesondere untersagt, folgende Inhalte zu speichern:</p>
+        <ul>
+          <li>Patientennamen, Gesundheitsdaten, medizinische Befunde</li>
+          <li>Fotos identifizierbarer verletzter oder verstorbener Personen</li>
+          <li>polizeiliche Ermittlungsinformationen</li>
+          <li>Passwörter, Alarmcodes, Schlüsselcodes, Tresorcodes</li>
+          <li>private Telefonnummern ohne rechtliche Grundlage</li>
+          <li>Ausweiskopien und weitere besonders schützenswerte Personendaten</li>
+          <li>rechtswidrige oder urheberrechtlich unzulässige Inhalte</li>
+          <li>Informationen, welche die Sicherheit von Personen oder kritischer Infrastruktur unangemessen gefährden</li>
+        </ul>
+        <p>
+          Auch reine Objektinformationen können vertraulich oder sicherheitsrelevant sein und dürfen nur
+          berechtigten Personen zugänglich gemacht werden.
+        </p>
+      </section>
+
+      <section>
+        <h2>7. Verfügbarkeit</h2>
+        <ul>
+          <li>Es besteht kein Anspruch auf ununterbrochene Verfügbarkeit.</li>
+          <li>Es besteht kein Service-Level-Agreement (SLA).</li>
+          <li>Wartungen und Störungen sind möglich.</li>
+          <li>Funktionen dürfen weiterentwickelt, eingeschränkt oder eingestellt werden.</li>
+          <li>Exporte und Offline-Kopien liegen in der Verantwortung der Organisation.</li>
+          <li>Es besteht keine Garantie auf dauerhafte Speicherung ohne eigene Sicherung.</li>
+        </ul>
+        <p>{legal.projectName} wird ohne garantierte Verfügbarkeit und ohne SLA bereitgestellt.</p>
+      </section>
+
+      <section>
+        <h2>8. Kostenloser Betrieb</h2>
+        <ul>
+          <li>Die Plattform wird grundsätzlich kostenlos angeboten.</li>
+          <li>Es besteht kein Anspruch darauf, dass alle Funktionen dauerhaft kostenlos bleiben.</li>
+          <li>Wesentliche Änderungen werden angemessen kommuniziert.</li>
+          <li>Eine spätere kostenpflichtige Leistung entsteht nur nach ausdrücklicher separater Zustimmung.</li>
+          <li>Es gibt keine automatische kostenpflichtige Verlängerung.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>9. Unterstützungsbeiträge</h2>
+        <ul>
+          <li>Beiträge sind freiwillig und erfolgen ohne Anspruch auf eine Gegenleistung.</li>
+          <li>Beiträge begründen keinen Anspruch auf Funktionen, Support, Verfügbarkeit oder bevorzugte Behandlung.</li>
+          <li>Zahlungsanbieter können Gebühren abziehen.</li>
+          <li>Es wird keine steuerlich abzugsfähige Bescheinigung versprochen.</li>
+          <li>Bei versehentlicher Zahlung besteht eine Kontaktmöglichkeit zur Prüfung einer Rückerstattung ({legal.supportEmail}).</li>
+          <li>Es wird keine Gemeinnützigkeit oder Steuerbefreiung behauptet, solange diese nicht schriftlich bestätigt ist.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>10. Geistiges Eigentum</h2>
+        <ul>
+          <li>Die Rechte an der Software verbleiben beim Betreiber bzw. den jeweiligen Rechteinhabern.</li>
+          <li>Rechte an eigenen Inhalten verbleiben bei den Benutzern bzw. Organisationen.</li>
+          <li>Der Betreiber erhält die für den technischen Betrieb notwendige, einfache Nutzungslizenz an hochgeladenen Inhalten.</li>
+          <li>Benutzer sind für die hochgeladenen Inhalte und deren Rechtmässigkeit verantwortlich.</li>
+          <li>Karten-, Symbol-, Icon- und Drittanbieter-Lizenzen sind zu beachten (siehe <a href="/impressum">Impressum</a> und Lizenzdokumentation).</li>
+          <li>Eine Quellenangabe ersetzt nicht automatisch eine erforderliche Nutzungslizenz.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>10a. FEUKOS-/FKS-Markierungen und -Symbole</h2>
+        <p>
+          Bestimmte in {legal.projectName} verwendete Markierungen und Symbole stammen von der Feuerwehr
+          Koordination Schweiz FKS. Die Verwendung innerhalb von {legal.projectName} erfolgt mit schriftlicher
+          Genehmigung. Bildquelle: Feuerwehr Koordination Schweiz FKS.
+        </p>
+        <p>
+          Die Genehmigung bezieht sich auf die Verwendung innerhalb des beschriebenen Webprojekts. Sie
+          begründet keine offizielle Partnerschaft, Prüfung, Zertifizierung oder Empfehlung von
+          {' '}{legal.projectName} durch die FKS.
+        </p>
+        <p>
+          Nutzer erhalten keine weitergehenden Rechte, die Symbole ausserhalb der von {legal.projectName}
+          {' '}vorgesehenen Funktionen separat zu vervielfältigen, weiterzugeben, zu verkaufen oder in anderen
+          Anwendungen zu verwenden. Zulässig bleibt die Verwendung in ordnungsgemäss mit {legal.projectName}
+          {' '}erstellten Lageplänen und Exporten, soweit dies vom vorgesehenen Funktionsumfang und der
+          erteilten Genehmigung gedeckt ist. Siehe auch <a href="/quellen-und-lizenzen">Quellen und Lizenzen</a>.
+        </p>
+      </section>
+
+      <section>
+        <h2>11. Haftung</h2>
+        <p>Im gesetzlich zulässigen Umfang gilt:</p>
+        <ul>
+          <li>keine Garantie für Vollständigkeit, Aktualität oder Fehlerfreiheit der Inhalte;</li>
+          <li>keine Garantie für Karten- oder Drittanbieterdaten;</li>
+          <li>keine Garantie für Berechnungsergebnisse;</li>
+          <li>die Verantwortung für fachliche Kontrolle und operative Entscheidungen liegt bei der Organisation;</li>
+          <li>indirekte Schäden, Datenverlust und Betriebsunterbruch werden nur im gesetzlich zulässigen Umfang begrenzt.</li>
+        </ul>
+        <p>
+          <strong>Zwingende gesetzliche Haftungsbestimmungen bleiben vorbehalten. Insbesondere wird die Haftung
+          für rechtswidrige Absicht oder grobe Fahrlässigkeit nicht im Voraus ausgeschlossen.</strong>
+        </p>
+      </section>
+
+      <section>
+        <h2>12. Sperrung und Beendigung</h2>
+        <ul>
+          <li>Sperrung bei Missbrauch oder Sicherheitsrisiken ist möglich.</li>
+          <li>Eine Exportmöglichkeit wird bereitgestellt, soweit technisch und rechtlich möglich.</li>
+          <li>Löschung erfolgt nach definierten Fristen; Daten in Backups können bis zum Ablauf des Backup-Zyklus fortbestehen.</li>
+          <li>Bei Einstellung des Projekts erfolgt eine angemessene Vorankündigung, soweit möglich.</li>
+          <li>Bei akuten Sicherheitsproblemen können sofortige Massnahmen ergriffen werden.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>13. Änderungen der Bedingungen</h2>
+        <ul>
+          <li>Die Bedingungen werden versioniert.</li>
+          <li>Über wesentliche Änderungen wird informiert.</li>
+          <li>Bei wesentlichen Änderungen wird eine erneute ausdrückliche Zustimmung verlangt.</li>
+          <li>Frühere Versionen bleiben intern nachvollziehbar.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>14. Anwendbares Recht</h2>
+        <p>
+          Es gilt {legal.governingLaw}. Gerichtsstand, soweit zulässig und sinnvoll: {legal.jurisdiction}.
+          Zwingende Bestimmungen zum Schutz von Konsumentinnen und Konsumenten bleiben vorbehalten.
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/organisationen/datenschutzvereinbarung/page.tsx

@@ -0,0 +1,142 @@
+'use client'
+
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal, isPlaceholder } from '@/config/legal'
+
+function Val({ value }: { value: string }) {
+  return isPlaceholder(value)
+    ? <span className="text-amber-600 dark:text-amber-400 font-medium">{value}</span>
+    : <span className="text-foreground font-medium">{value}</span>
+}
+
+export default function DatenschutzvereinbarungPage() {
+  const d = legal.documents.dataProcessingAgreement
+  return (
+    <LegalPage
+      title="Datenschutzvereinbarung für Organisationen"
+      version={d.version}
+      publishedAt={d.publishedAt}
+      intro="Vereinbarung zur Auftragsbearbeitung zwischen dem Betreiber und der nutzenden Organisation. Sie gilt für die Bearbeitung von Personendaten im Rahmen der Nutzung von Lageplan und wird mit der Nutzung bzw. gesonderter Bestätigung wirksam."
+    >
+      <section>
+        <h2>1. Parteien</h2>
+        <p>
+          <strong>Auftragsbearbeiter (Betreiber):</strong> <Val value={legal.operatorName} /> (<Val value={legal.operatorLegalForm} />),{' '}
+          <Val value={legal.postalAddress} />, Kontakt <Val value={legal.privacyContactEmail} />.
+        </p>
+        <p><strong>Verantwortliche (Organisation):</strong> die jeweilige Feuerwehr/Organisation als Mandant.</p>
+      </section>
+
+      <section>
+        <h2>2. Gegenstand und Dauer</h2>
+        <p>
+          Gegenstand ist die Bearbeitung von Personendaten im Auftrag der Organisation im Rahmen der Nutzung von
+          {' '}{legal.projectName}. Die Vereinbarung gilt für die Dauer des Nutzungsverhältnisses.
+        </p>
+      </section>
+
+      <section>
+        <h2>3. Zweck</h2>
+        <p>Bereitstellung, Betrieb und Support der Plattform gemäss Weisung der Organisation.</p>
+      </section>
+
+      <section>
+        <h2>4. Kategorien betroffener Personen</h2>
+        <ul>
+          <li>Mitglieder und Funktionsträger der Organisation (Benutzer)</li>
+          <li>ggf. weitere Personen, soweit von der Organisation im Rahmen der Nutzung erfasst</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>5. Datenkategorien</h2>
+        <ul>
+          <li>Konto-/Kontaktdaten (Name, E-Mail, Rolle)</li>
+          <li>Inhalts-/Einsatzdaten (Pläne, Journale, Zeichnungen, Uploads)</li>
+          <li>Protokoll-/Nutzungsdaten</li>
+        </ul>
+        <p>
+          Besonders schützenswerte Personendaten dürfen ohne gesonderte schriftliche Vereinbarung nicht bearbeitet
+          werden (siehe <a href="/nutzungsbedingungen">Nutzungsbedingungen</a>).
+        </p>
+      </section>
+
+      <section>
+        <h2>6. Weisungen der Organisation</h2>
+        <p>Der Betreiber bearbeitet Personendaten nur gemäss den dokumentierten Weisungen der Organisation und dieser Vereinbarung.</p>
+      </section>
+
+      <section>
+        <h2>7. Vertraulichkeit</h2>
+        <p>Zum Zugriff berechtigte Personen sind zur Vertraulichkeit verpflichtet.</p>
+      </section>
+
+      <section>
+        <h2>8. Technische und organisatorische Massnahmen (TOM)</h2>
+        <p>
+          Es gelten die unter <a href="/sicherheit">Sicherheit</a> beschriebenen Massnahmen; der detaillierte
+          Stand ist in <code>docs/legal/technical-organizational-measures.md</code> dokumentiert (Anhang A).
+        </p>
+      </section>
+
+      <section>
+        <h2>9. Unterauftragnehmer</h2>
+        <p>
+          Der Betreiber setzt die in der <a href="/datenschutz#dienstleister">Dienstleisterliste</a> genannten
+          Unterauftragnehmer ein (Anhang B). Über Änderungen wird angemessen informiert.
+        </p>
+      </section>
+
+      <section>
+        <h2>10. Datenstandorte</h2>
+        <p>Verarbeitungsregionen gemäss Dienstleisterliste; offene Punkte: <Val value={legal.serverLocation} />.</p>
+      </section>
+
+      <section>
+        <h2>11. Unterstützung bei Betroffenenrechten</h2>
+        <p>Der Betreiber unterstützt die Organisation angemessen bei der Erfüllung von Auskunfts-, Berichtigungs-, Lösch- und Exportbegehren.</p>
+      </section>
+
+      <section>
+        <h2>12. Sicherheitsvorfälle</h2>
+        <p>Der Betreiber informiert die Organisation ohne unangemessene Verzögerung über Sicherheitsvorfälle mit Risiko für betroffene Personen.</p>
+      </section>
+
+      <section>
+        <h2>13. Löschung und Rückgabe</h2>
+        <p>
+          Nach Vertragsende werden Personendaten gelöscht oder zurückgegeben, soweit keine gesetzliche
+          Aufbewahrungspflicht besteht. Daten in Backups können bis zum Ablauf des Backup-Zyklus fortbestehen
+          (<Val value={legal.backupRetention} />).
+        </p>
+      </section>
+
+      <section>
+        <h2>14. Datenexport</h2>
+        <p>Die Organisation kann ihre Daten in einem gängigen Format exportieren, soweit technisch möglich.</p>
+      </section>
+
+      <section>
+        <h2>15. Kontrolle und Nachweis</h2>
+        <p>Der Betreiber stellt der Organisation auf Anfrage angemessene Nachweise zur Einhaltung dieser Vereinbarung zur Verfügung.</p>
+      </section>
+
+      <section>
+        <h2>16. Kontaktstellen</h2>
+        <p>Betreiber: <Val value={legal.privacyContactEmail} />. Organisation: durch die Organisation zu benennen.</p>
+      </section>
+
+      <section>
+        <h2>Anhänge</h2>
+        <ul>
+          <li><strong>Anhang A – TOM:</strong> <a href="/sicherheit">Sicherheit</a> / interne TOM-Dokumentation</li>
+          <li><strong>Anhang B – Unterauftragnehmer:</strong> <a href="/datenschutz#dienstleister">Dienstleisterliste</a></li>
+        </ul>
+        <p className="text-xs">
+          Massgebend sind die konkreten Angaben in dieser Vereinbarung sowie die Anhänge A (TOM) und B
+          (Unterauftragnehmer). Individuelle Zusätze können auf Anfrage vereinbart werden.
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/page.tsx

@@ -52,7 +52,7 @@ export default function LandingPage() {
         name: 'Was kostet Lageplan?',
         acceptedAnswer: {
           '@type': 'Answer',
-          text: 'Nichts. Lageplan ist kostenlos für alle Feuerwehren in der Schweiz. Die Entwicklung wird durch freiwillige Spenden finanziert.',
+          text: 'Lageplan wird Feuerwehren grundsätzlich kostenlos zur Verfügung gestellt. Der Betrieb wird durch freiwillige Unterstützungsbeiträge mitfinanziert. Ein Anspruch darauf, dass alle Funktionen dauerhaft kostenlos bleiben, besteht nicht.',
         },
       },
       {
@@ -84,7 +84,7 @@ export default function LandingPage() {
         name: 'Wo werden meine Daten gespeichert?',
         acceptedAnswer: {
           '@type': 'Answer',
-          text: 'Alle Daten werden auf Servern in der Schweiz gespeichert. Die Applikation ist DSG- und DSGVO-konform.',
+          text: 'Kontodaten werden in einer Datenbank gespeichert. Die eingesetzten Dienstleister und Speicherorte sind in der Datenschutzerklärung transparent aufgeführt. Lageplan orientiert sich am Schweizer Datenschutzgesetz (DSG).',
         },
       },
       {
@@ -92,7 +92,7 @@ export default function LandingPage() {
         name: 'Welche Symbole sind verfügbar?',
         acceptedAnswer: {
           '@type': 'Answer',
-          text: 'Alle 117 offiziellen FKS/BABS-Signaturen sind integriert. Zusätzlich können eigene Symbole hochgeladen werden.',
+          text: 'Alle 117 taktischen FEUKOS-Symbole der Feuerwehr Koordination Schweiz FKS sind integriert (Bildquelle: FKS). Zusätzlich können eigene Symbole hochgeladen werden.',
         },
       },
       {
@@ -237,10 +237,10 @@ export default function LandingPage() {
         <div className="max-w-5xl mx-auto">
           <div className="grid grid-cols-2 md:grid-cols-4 gap-6 md:gap-8">
             {[
-              { value: '117', label: 'FKS-Signaturen', sub: 'Offizielle taktische Zeichen' },
+              { value: '117', label: 'FKS-Signaturen', sub: 'Taktische Zeichen (Bildquelle FKS)' },
-              { value: '100%', label: 'Swiss Hosted', sub: 'Server in der Schweiz' },
+              { value: 'CH', label: 'Swiss Made', sub: 'In der Schweiz entwickelt' },
-              { value: '0.—', label: 'Kostenlos', sub: 'Für alle Feuerwehren' },
+              { value: '0.—', label: 'Kostenlos', sub: 'Grundnutzung für Feuerwehren' },
-              { value: '24/7', label: 'Verfügbar', sub: 'Browser-basiert, jedes Gerät' },
+              { value: 'Web', label: 'Überall nutzbar', sub: 'Browser, Tablet, Smartphone' },
             ].map((stat, i) => (
               <div key={i} className="text-center">
                 <p className="text-3xl sm:text-4xl font-extrabold text-red-600">{stat.value}</p>
@@ -333,8 +333,8 @@ export default function LandingPage() {
                   Hinter jeder Funktion stecken Stunden an Entwicklung, Testing und Feinschliff.
                   Server-Hosting, Domain, SSL-Zertifikate — das alles kostet. Ich finanziere das aktuell
                   komplett aus eigener Tasche, weil mir das Projekt am Herzen liegt.
-                  Wenn du Lageplan nützlich findest, kannst du die Weiterentwicklung mit einer freiwilligen
+                  Wenn du Lageplan nützlich findest, kannst du die Weiterentwicklung mit einem freiwilligen
-                  Spende unterstützen. Jeder Beitrag hilft, neue Features zu bauen und die Server am Laufen zu halten.
+                  Beitrag unterstützen. Jeder Beitrag hilft, neue Features zu bauen und die Server am Laufen zu halten.
                 </p>
               </div>
             </div>
@@ -352,13 +352,13 @@ export default function LandingPage() {
           <div className="grid md:grid-cols-2 lg:grid-cols-3 gap-8">
             {[
               { icon: Map, title: 'Interaktive Karte', desc: 'Lagepläne auf OSM-Karten zeichnen mit Linien, Polygonen, Pfeilen und Freihandzeichnung.' },
-              { icon: Shield, title: 'FKS-Signaturen', desc: 'Alle offiziellen FKS/BABS-Signaturen per Drag & Drop platzieren. Eigene Symbole hochladen.' },
+              { icon: Shield, title: 'FEUKOS-Symbole', desc: 'Taktische FEUKOS-Symbole der FKS (Bildquelle: FKS) per Drag & Drop platzieren. Eigene Symbole hochladen.' },
               { icon: Ruler, title: 'Messwerkzeug', desc: 'Distanzen messen mit Druckverlustberechnung und Pumpenanzahl für Schlauchleitungen.' },
               { icon: FileText, title: 'Einsatzjournal', desc: 'Journal mit Zeitstempel, SOMA-Checkliste und Pendenzenliste — alles an einem Ort.' },
               { icon: Smartphone, title: 'Installierbare App (PWA)', desc: 'Auf dem Homescreen installierbar — funktioniert offline wie eine native App. Desktop, Tablet & Smartphone.' },
               { icon: Users, title: 'Echtzeit-Zusammenarbeit', desc: 'Mehrere Benutzer können gleichzeitig am selben Lageplan arbeiten.' },
-              { icon: Clock, title: 'Audit Trail', desc: 'Lückenlose Protokollierung aller Aktionen mit Zeitstempel für Nachvollziehbarkeit.' },
+              { icon: Clock, title: 'Nachvollziehbarkeit', desc: 'Protokollierung von Aktionen mit Zeitstempel für bessere Nachvollziehbarkeit.' },
-              { icon: Lock, title: 'Sicher & Schweiz', desc: 'Rollenbasierte Zugriffskontrolle. Gehostet in der Schweiz — DSG/DSGVO-konform.' },
+              { icon: Lock, title: 'Sicherheit & Datenschutz', desc: 'Rollenbasierte Zugriffskontrolle und Mandantentrennung. Angemessene technische und organisatorische Schutzmassnahmen — Details in der Datenschutzerklärung.' },
               { icon: FileText, title: 'PDF-Export', desc: 'Lagepläne als PDF exportieren mit Metadaten, Datum und Einsatzinformationen.' },
             ].map((f, i) => (
               <div key={i} className="bg-white rounded-xl p-6 border border-gray-100 hover:shadow-lg transition-shadow">
@@ -389,7 +389,7 @@ export default function LandingPage() {
           <div className="space-y-4">
             {[
               { status: 'done', title: 'Interaktive Karte mit Zeichenwerkzeugen', desc: 'Linien, Polygone, Pfeile, Freihand, Punkte' },
-              { status: 'done', title: 'FKS-Signaturen (117 offizielle Symbole)', desc: 'Alle taktischen Zeichen nach Schweizer Standard (Bildquelle: Feuerwehr Koordination Schweiz FKS)' },
+              { status: 'done', title: 'FEUKOS-Symbole (117 taktische Zeichen)', desc: 'Taktische Zeichen nach der Systematik der Feuerwehr Koordination Schweiz FKS (Bildquelle: Feuerwehr Koordination Schweiz FKS)' },
               { status: 'done', title: 'Einsatzjournal mit SOMA-Checkliste', desc: 'Zeitstempel, Pendenzen, Protokollierung' },
               { status: 'done', title: 'Messwerkzeug mit Druckverlustberechnung', desc: 'Distanzen, Höhenmeter, Pumpenanzahl' },
               { status: 'done', title: 'Echtzeit-Zusammenarbeit (WebSocket)', desc: 'Mehrere Benutzer gleichzeitig am Lageplan' },
@@ -439,7 +439,7 @@ export default function LandingPage() {
             {[
               {
                 q: 'Was kostet Lageplan?',
-                a: 'Nichts. Lageplan ist kostenlos für alle Feuerwehren in der Schweiz. Die Entwicklung wird durch freiwillige Spenden finanziert.',
+                a: 'Lageplan wird Feuerwehren grundsätzlich kostenlos zur Verfügung gestellt. Der Betrieb wird durch freiwillige Unterstützungsbeiträge mitfinanziert. Ein Anspruch darauf, dass alle Funktionen dauerhaft kostenlos bleiben, besteht nicht.',
               },
               {
                 q: 'Brauche ich eine Installation?',
@@ -455,11 +455,11 @@ export default function LandingPage() {
               },
               {
                 q: 'Wo werden meine Daten gespeichert?',
-                a: 'Alle Daten werden auf Servern in der Schweiz gespeichert. Die Applikation ist DSG- und DSGVO-konform.',
+                a: 'Kontodaten werden in einer Datenbank gespeichert. Die eingesetzten Dienstleister und Speicherorte sind in der Datenschutzerklärung transparent aufgeführt. Lageplan orientiert sich am Schweizer Datenschutzgesetz (DSG).',
               },
               {
                 q: 'Welche Symbole sind verfügbar?',
-                a: 'Alle 117 offiziellen FKS/BABS-Signaturen sind integriert. Zusätzlich können eigene Symbole hochgeladen werden.',
+                a: 'Alle 117 taktischen FEUKOS-Symbole der Feuerwehr Koordination Schweiz FKS sind integriert (Bildquelle: FKS). Zusätzlich können eigene Symbole hochgeladen werden.',
               },
               {
                 q: 'Kann ich Lagepläne exportieren?',
@@ -508,7 +508,11 @@ export default function LandingPage() {
               </div>
               <p className="text-sm text-gray-500">Digitale Lagepläne für die Schweizer Feuerwehr</p>
               <p className="text-sm text-gray-500 mt-1">Ein Projekt von Pepe Ziberi</p>
-              <p className="text-sm text-gray-500">Gehostet in der Schweiz — Swiss Made 🇨🇭</p>
+              <p className="text-sm text-gray-500">In der Schweiz entwickelt — Swiss Made 🇨🇭</p>
+              <p className="text-xs text-gray-400 mt-2 max-w-xs">
+                Unterstützendes Werkzeug ohne garantierte Verfügbarkeit. Kein Einsatzleit- oder
+                Alarmierungssystem. Angaben vor Verwendung fachlich prüfen.
+              </p>
             </div>
             <div className="text-sm text-gray-500">
               <p className="font-medium text-gray-700 mb-2">Kontakt</p>
@@ -526,11 +530,17 @@ export default function LandingPage() {
               <p className="font-medium text-gray-700 mb-2">Rechtliches</p>
               <Link href="/impressum" className="block hover:text-gray-700">Impressum</Link>
               <Link href="/datenschutz" className="block hover:text-gray-700 mt-1">Datenschutz</Link>
+              <Link href="/nutzungsbedingungen" className="block hover:text-gray-700 mt-1">Nutzungsbedingungen</Link>
+              <Link href="/verantwortungsvolle-nutzung" className="block hover:text-gray-700 mt-1">Verantwortungsvolle Nutzung</Link>
+              <Link href="/sicherheit" className="block hover:text-gray-700 mt-1">Sicherheit</Link>
+              <Link href="/quellen-und-lizenzen" className="block hover:text-gray-700 mt-1">Quellen &amp; Lizenzen</Link>
+              <Link href="/organisationen/datenschutzvereinbarung" className="block hover:text-gray-700 mt-1">Datenschutzvereinbarung (Org.)</Link>
+              <Link href="/unterstuetzen" className="block hover:text-gray-700 mt-1">Unterstützen</Link>
             </div>
           </div>
           <div className="border-t border-gray-100 mt-8 pt-6 text-center space-y-1">
-            <p className="text-sm text-gray-500">&copy; {new Date().getFullYear()} Lageplan — Purepixel. Alle Rechte vorbehalten.</p>
+            <p className="text-sm text-gray-500">&copy; {new Date().getFullYear()} Lageplan — Perparim Ziberi. Alle Rechte vorbehalten.</p>
-            <p className="text-xs text-gray-500">Taktische Symbole: Bildquelle Feuerwehr Koordination Schweiz FKS</p>
+            <p className="text-xs text-gray-500">Bildquelle: Feuerwehr Koordination Schweiz FKS · <Link href="/quellen-und-lizenzen" className="underline hover:text-gray-700">Quellen &amp; Lizenzen</Link></p>
             <p className="text-xs text-gray-400 mt-1">v{process.env.APP_VERSION}</p>
           </div>
         </div>
@@ -548,8 +558,8 @@ function SupportSection() {
           <Coffee className="w-10 h-10 text-red-600 mx-auto mb-4" />
           <h2 className="text-3xl font-bold text-gray-900">Projekt unterstützen</h2>
           <p className="mt-3 text-lg text-gray-500 max-w-xl mx-auto">
-            Lageplan ist und bleibt kostenlos. Wenn du die Weiterentwicklung unterstützen möchtest,
+            Lageplan wird grundsätzlich kostenlos angeboten. Wenn du die Weiterentwicklung unterstützen
-            freue ich mich über einen freiwilligen Beitrag.
+            möchtest, freue ich mich über einen freiwilligen Beitrag — ohne Anspruch auf eine Gegenleistung.
           </p>
         </div>
 
@@ -571,13 +581,13 @@ function SupportSection() {
           </div>
 
           <p className="text-gray-500 mb-6">
-            Wähle einen Betrag auf unserer Spendenseite — Zahlung sicher via Stripe (Kreditkarte, Twint, Apple Pay, Google Pay).
+            Wähle einen Betrag auf der Unterstützungsseite — Zahlung über Stripe (Kreditkarte, Twint, Apple Pay, Google Pay).
           </p>
 
           <Link href="/spenden">
             <Button className="bg-red-600 hover:bg-red-700 h-12 text-base px-8">
               <Heart className="w-4 h-4 mr-2" />
-              Zur Spendenseite
+              Zur Unterstützungsseite
             </Button>
           </Link>
         </div>
@@ -585,8 +595,10 @@ function SupportSection() {
         {/* Trust note */}
         <div className="mt-8 text-center">
           <p className="text-sm text-gray-500">
-            100% deiner Spende fliesst direkt in Serverkosten und Weiterentwicklung.
+            Beiträge helfen, Hosting, Infrastruktur und Weiterentwicklung zu finanzieren.
-            <br />Kein Unternehmen, keine Investoren — nur ein Feuerwehrmann mit einer Idee.
+            Ein Beitrag ist freiwillig und erfolgt ohne Anspruch auf eine Gegenleistung; Gebühren des
+            Zahlungsanbieters können abgezogen werden.
+            <br />Ein Projekt aus der Feuerwehr-Praxis — entwickelt in der Freizeit.
           </p>
         </div>
       </div>

src/app/quellen-und-lizenzen/page.tsx

@@ -0,0 +1,63 @@
+'use client'
+
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal } from '@/config/legal'
+
+export default function QuellenUndLizenzenPage() {
+  const d = legal.documents.fksAttribution
+  const fks = legal.fksAttribution
+  return (
+    <LegalPage
+      title="Quellen und Lizenzen"
+      version={d?.version}
+      publishedAt={d?.publishedAt}
+      intro={`Herkunft und Nutzungsgrundlagen der in ${legal.projectName} verwendeten Symbole, Karten- und Geodaten sowie weiterer Inhalte.`}
+    >
+      <section>
+        <h2>Feuerwehr Koordination Schweiz FKS</h2>
+        <ul>
+          <li><strong>Inhalte:</strong> FEUKOS-Markierungen und -Symbole sowie bewilligtes Bildmaterial.</li>
+          <li><strong>Grundlage:</strong> schriftliche Genehmigung für die Verwendung innerhalb des Webprojekts {legal.projectName}.</li>
+          <li><strong>Quellenangabe:</strong> {fks.label}</li>
+        </ul>
+        <p>{fks.note}</p>
+        <p className="text-xs">
+          Hinweis: Es besteht keine offizielle Partnerschaft, Zertifizierung, Prüfung, behördliche
+          Anerkennung oder Empfehlung von {legal.projectName} durch die FKS. Nutzer erhalten keine
+          weitergehenden Rechte, die Symbole ausserhalb der von {legal.projectName} vorgesehenen
+          Funktionen separat zu vervielfältigen, weiterzugeben, zu verkaufen oder in anderen Anwendungen
+          zu verwenden.
+        </p>
+      </section>
+
+      <section>
+        <h2>Karten- und Geodaten</h2>
+        <ul>
+          <li><strong>OpenStreetMap:</strong> Basiskarte und Adresssuche (Nominatim) — © OpenStreetMap-Mitwirkende, Daten unter ODbL.</li>
+          <li><strong>Esri World Imagery:</strong> Satellitenbilder — Nutzung gemäss Esri-Bedingungen.</li>
+          <li><strong>swisstopo (geo.admin.ch):</strong> Schweizer Landeskarte — © swisstopo, Nutzung gemäss Bedingungen von swisstopo.</li>
+          <li><strong>Open-Meteo / Open-Elevation:</strong> Wind- und Höhendaten.</li>
+        </ul>
+        <p className="text-xs">Karten-, Adress- und Geodaten können unvollständig, ungenau oder veraltet sein.</p>
+      </section>
+
+      <section>
+        <h2>Schriftarten, Icons &amp; Bibliotheken</h2>
+        <ul>
+          <li><strong>Barlow</strong> (SIL Open Font License 1.1), build-time selbst gehostet.</li>
+          <li><strong>lucide-react</strong> (ISC) für Oberflächen-Icons.</li>
+          <li>Wesentliche Open-Source-Bibliotheken: Next.js/React (MIT), MapLibre GL (BSD-3), jsPDF (MIT), u.a.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>Eigene Inhalte</h2>
+        <p>
+          Von Benutzern hochgeladene Inhalte (Pläne, Logos, eigene Symbole) verbleiben bei den jeweiligen
+          Benutzern bzw. Organisationen. Für die Rechtmässigkeit hochgeladener Inhalte sind die Benutzer
+          verantwortlich (siehe <a href="/nutzungsbedingungen">Nutzungsbedingungen</a>).
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/rapport/[token]/page.tsx

@@ -225,7 +225,7 @@ export default function RapportViewerPage({ params }: { params: Promise<{ token:
                   <span className="text-center font-bold">{s.confirmed ? '✓' : '—'}</span>
                   <span className="text-center font-bold">{s.ok ? '✓' : '—'}</span>
                   <span className="font-medium">{s.label}</span>
-                  <span className="text-right text-[8pt] text-gray-500 font-mono">{s.confirmedAt || ''}</span>
+                  <span className="text-right text-[8pt] text-gray-500 font-mono">{s.confirmedAt || s.okAt || ''}</span>
                 </div>
               ))}
             </div>
@@ -260,6 +260,38 @@ export default function RapportViewerPage({ params }: { params: Promise<{ token:
           </Section>
         )}
 
+        {/* 6b. Eigene Cockpit-Module (Modul-Baukasten) */}
+        {Array.isArray(d.moduleTables) && d.moduleTables.map((mt: any, ti: number) => (
+          Array.isArray(mt.rows) && mt.rows.length > 0 ? (
+            <Section key={`mod-${ti}`} num="•" title={mt.name}>
+              <table className="w-full border-collapse border rounded text-xs">
+                <thead>
+                  <tr className="bg-gray-900 text-white">
+                    {(mt.columns || []).map((c: any) => (
+                      <th key={c.key} className={`p-1.5 font-semibold uppercase tracking-wider text-[7pt] ${c.type === 'check' ? 'text-center w-10' : c.type === 'time' ? 'text-left w-16' : c.type === 'number' ? 'text-right w-20' : 'text-left'}`}>{c.label}</th>
+                    ))}
+                  </tr>
+                </thead>
+                <tbody>
+                  {mt.rows.map((row: any, ri: number) => (
+                    <tr key={ri} className={ri % 2 === 1 ? 'bg-gray-50' : ''}>
+                      {(mt.columns || []).map((c: any) => (
+                        <td key={c.key} className={`p-1.5 border-b border-gray-100 ${c.type === 'check' ? 'text-center font-bold' : ''} ${c.type === 'time' ? 'font-mono text-[8pt] text-gray-500' : ''} ${c.type === 'number' ? 'text-right font-mono tabular-nums' : ''}`}>
+                          {c.type === 'check'
+                            ? (row[c.key] ? '✓' : '—')
+                            : c.type === 'time'
+                              ? formatCellTime(row[c.key] || row._createdAt)
+                              : (row[c.key] ?? '')}
+                        </td>
+                      ))}
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </Section>
+          ) : null
+        ))}
+
         {/* 7. Eingesetzte Mittel */}
         {d.fahrzeuge?.length > 0 && (
           <Section num="7" title="Eingesetzte Mittel">
@@ -330,6 +362,16 @@ export default function RapportViewerPage({ params }: { params: Promise<{ token:
   )
 }
 
+// Zeit-Zellen der Modul-Tabellen: ISO-Datum → HH:MM, sonst Rohwert
+function formatCellTime(value: any): string {
+  if (!value) return ''
+  const d = new Date(value)
+  if (!isNaN(d.getTime()) && typeof value === 'string' && value.includes('T')) {
+    return d.toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })
+  }
+  return String(value)
+}
+
 function Section({ num, title, children }: { num: string; title: string; children: React.ReactNode }) {
   return (
     <div className="mb-4">

src/app/register/page.tsx

@@ -16,7 +16,8 @@ export default function RegisterPage() {
   const [email, setEmail] = useState('')
   const [password, setPassword] = useState('')
   const [confirmPassword, setConfirmPassword] = useState('')
-  const [privacyAccepted, setPrivacyAccepted] = useState(false)
+  const [acceptTerms, setAcceptTerms] = useState(false)
+  const [acceptPrivacy, setAcceptPrivacy] = useState(false)
   const [isLoading, setIsLoading] = useState(false)
   const [isSuccess, setIsSuccess] = useState(false)
   const router = useRouter()
@@ -40,7 +41,7 @@ export default function RegisterPage() {
       const res = await fetch('/api/auth/register', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ organizationName, name, email, password, privacyAccepted }),
+        body: JSON.stringify({ organizationName, name, email, password, acceptTerms, acceptPrivacy }),
       })
 
       const data = await res.json()
@@ -188,13 +189,28 @@ export default function RegisterPage() {
               />
             </div>
 
-            {/* Privacy Policy Checkbox */}
+            {/* Zustimmungen — je einzeln aktiv zu setzen, keine Vorauswahl */}
-            <div className="pt-2 border-t border-border">
+            <div className="pt-2 border-t border-border space-y-2.5">
               <label className="flex items-start gap-2.5 cursor-pointer">
                 <input
                   type="checkbox"
-                  checked={privacyAccepted}
+                  checked={acceptTerms}
-                  onChange={(e) => setPrivacyAccepted(e.target.checked)}
+                  onChange={(e) => setAcceptTerms(e.target.checked)}
+                  className="mt-0.5 w-4 h-4 rounded border-gray-300 text-red-600 focus:ring-red-500 cursor-pointer"
+                  disabled={isLoading}
+                />
+                <span className="text-xs text-muted-foreground leading-relaxed">
+                  Ich akzeptiere die{' '}
+                  <Link href="/nutzungsbedingungen" target="_blank" className="text-red-500 hover:text-red-400 underline font-medium">
+                    Nutzungsbedingungen
+                  </Link>.
+                </span>
+              </label>
+              <label className="flex items-start gap-2.5 cursor-pointer">
+                <input
+                  type="checkbox"
+                  checked={acceptPrivacy}
+                  onChange={(e) => setAcceptPrivacy(e.target.checked)}
                   className="mt-0.5 w-4 h-4 rounded border-gray-300 text-red-600 focus:ring-red-500 cursor-pointer"
                   disabled={isLoading}
                 />
@@ -203,7 +219,7 @@ export default function RegisterPage() {
                   <Link href="/datenschutz" target="_blank" className="text-red-500 hover:text-red-400 underline font-medium">
                     Datenschutzerklärung
                   </Link>{' '}
-                  gelesen und akzeptiere die Nutzungsbedingungen.
+                  zur Kenntnis genommen.
                 </span>
               </label>
             </div>
@@ -211,7 +227,7 @@ export default function RegisterPage() {
             <Button
               type="submit"
               className="w-full bg-red-600 hover:bg-red-700"
-              disabled={isLoading || !organizationName || !name || !email || !password || !confirmPassword || !privacyAccepted}
+              disabled={isLoading || !organizationName || !name || !email || !password || !confirmPassword || !acceptTerms || !acceptPrivacy}
             >
               {isLoading ? (
                 <><Loader2 className="w-4 h-4 mr-2 animate-spin" /> Wird erstellt...</>

src/app/settings/page.tsx

@@ -9,6 +9,7 @@ import { useToast } from '@/components/ui/use-toast'
 import {
   ArrowLeft, Building2, Trash2, AlertTriangle, Loader2, Shield, Users, FileText,
 } from 'lucide-react'
+import { MfaSettings } from '@/components/settings/mfa-settings'
 
 export default function SettingsPage() {
   const [tenant, setTenant] = useState<any>(null)
@@ -120,6 +121,9 @@ export default function SettingsPage() {
               </div>
             </div>
 
+            {/* Zwei-Faktor-Authentisierung */}
+            <MfaSettings />
+
             {/* Danger Zone */}
             <div className="bg-red-50 dark:bg-red-950/20 rounded-lg border border-red-200 dark:border-red-800/50 p-5">
               <h2 className="text-lg font-semibold text-red-700 dark:text-red-400 mb-2 flex items-center gap-2">

src/app/sicherheit/page.tsx

@@ -0,0 +1,60 @@
+'use client'
+
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal } from '@/config/legal'
+
+export default function SicherheitPage() {
+  return (
+    <LegalPage
+      title="Sicherheit"
+      version={legal.documents.privacy.version}
+      publishedAt={legal.documents.privacy.publishedAt}
+      intro={`Übersicht über die technischen und organisatorischen Sicherheitsmassnahmen von ${legal.projectName}. Diese Darstellung ist allgemein gehalten; ein vollständiger Schutz vor allen Risiken kann nicht garantiert werden.`}
+    >
+      <section>
+        <h2>Grundsatz</h2>
+        <p>
+          Wir setzen angemessene technische und organisatorische Sicherheitsmassnahmen ein. Ein vollständiger
+          Schutz vor allen Risiken kann jedoch nicht garantiert werden. Sicherheit ist ein fortlaufender Prozess.
+        </p>
+      </section>
+
+      <section>
+        <h2>Technische Massnahmen (Auszug)</h2>
+        <ul>
+          <li><strong>Zugriffstrennung:</strong> Mandantentrennung je Organisation sowie ein Rollen- und Rechtekonzept (Server-Admin, Organisations-Admin, Bearbeiter, Betrachter).</li>
+          <li><strong>Passwörter:</strong> werden mit einem geeigneten Einwegverfahren (bcrypt) gehasht, nie im Klartext gespeichert.</li>
+          <li><strong>Übertragung:</strong> verschlüsselt über HTTPS/TLS; HSTS aktiviert.</li>
+          <li><strong>Sitzungen:</strong> httpOnly-Session-Cookie, in Produktion mit <code>secure</code>-Flag.</li>
+          <li><strong>Zwei-Faktor (2FA):</strong> optional pro Konto — Authenticator-App (TOTP) und Sicherheitsschlüssel/Passkeys (WebAuthn/YubiKey), mit Backup-Codes.</li>
+          <li><strong>Web-Härtung:</strong> Sicherheits-Header (u.a. Content-Security-Policy, <code>X-Content-Type-Options</code>, Referrer-Policy, Schutz vor Clickjacking über <code>frame-ancestors</code>).</li>
+          <li><strong>Missbrauchsschutz:</strong> Rate-Limiting für Login, Registrierung, Passwort-Reset, Kontaktformular und geteilte Ansichten.</li>
+          <li><strong>Uploads:</strong> Validierung und Zugriffsschutz für hochgeladene Dateien.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>Organisatorische Massnahmen</h2>
+        <ul>
+          <li>Zugriff auf Systemdaten nur im betrieblich notwendigen Umfang.</li>
+          <li>Trennung von Entwicklungs-/Test- und Produktionsumgebung.</li>
+          <li>Regelmässige Aktualisierung von Abhängigkeiten.</li>
+          <li>Definierter Prozess für Sicherheitsvorfälle (siehe interne Dokumentation).</li>
+        </ul>
+        <p className="text-xs">
+          Der detaillierte, laufend gepflegte Ist-Zustand inkl. offener Punkte ist intern in{' '}
+          <code>docs/legal/technical-organizational-measures.md</code> dokumentiert.
+        </p>
+      </section>
+
+      <section>
+        <h2>Sicherheitslücke melden</h2>
+        <p>
+          Wenn Sie eine mögliche Sicherheitslücke entdecken, melden Sie diese bitte vertraulich an{' '}
+          <strong>{legal.supportEmail}</strong>. Bitte nutzen Sie gefundene Schwachstellen nicht aus und geben Sie
+          uns angemessene Zeit zur Behebung.
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/sitemap.ts

@@ -46,5 +46,11 @@ export default function sitemap(): MetadataRoute.Sitemap {
       changeFrequency: 'yearly',
       priority: 0.3,
     },
+    { url: `${baseUrl}/nutzungsbedingungen`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
+    { url: `${baseUrl}/verantwortungsvolle-nutzung`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
+    { url: `${baseUrl}/sicherheit`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
+    { url: `${baseUrl}/quellen-und-lizenzen`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
+    { url: `${baseUrl}/unterstuetzen`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
+    { url: `${baseUrl}/organisationen/datenschutzvereinbarung`, lastModified: new Date(), changeFrequency: 'yearly', priority: 0.3 },
   ]
 }

src/app/spenden/danke/page.tsx

@@ -30,7 +30,7 @@ export default function DankePage() {
         </h1>
 
         <p className="text-xl text-gray-500 mb-2">
-          Deine Spende ist angekommen.
+          Dein Beitrag ist angekommen.
         </p>
         <p className="text-gray-400 mb-10 max-w-md mx-auto">
           Dein Beitrag hilft direkt dabei, Lageplan weiterzuentwickeln und die Server am Laufen zu halten.
@@ -40,7 +40,7 @@ export default function DankePage() {
         <div className="bg-red-50 rounded-2xl p-8 border border-red-100 mb-10">
           <Heart className="w-8 h-8 text-red-500 mx-auto mb-3" />
           <p className="text-gray-700 font-medium">
-            &laquo;Jede Spende motiviert mich, weiterzumachen. Danke von Herzen!&raquo;
+            &laquo;Jeder Beitrag motiviert mich, weiterzumachen. Danke von Herzen!&raquo;
           </p>
           <p className="text-sm text-gray-500 mt-2">— Pepe Ziberi, Entwickler von Lageplan</p>
         </div>

src/app/spenden/layout.tsx

@@ -1,8 +1,8 @@
 import type { Metadata } from 'next'
 
 export const metadata: Metadata = {
-  title: 'Spenden',
+  title: 'Unterstützen',
-  description: 'Unterstützen Sie die Weiterentwicklung von Lageplan.ch – der kostenlosen Krokier-App für Schweizer Feuerwehren.',
+  description: 'Freiwilliger Unterstützungsbeitrag für die Weiterentwicklung von Lageplan.ch – der kostenlosen Krokier-App für Schweizer Feuerwehren.',
   robots: { index: true, follow: true },
 }
 

src/app/spenden/page.tsx

@@ -85,7 +85,7 @@ export default function SpendenPage() {
           <h1 className="text-4xl font-extrabold text-gray-900 mb-4">Lageplan unterstützen</h1>
           <p className="text-lg text-gray-500 max-w-xl mx-auto">
             Lageplan ist ein kostenloses Herzensprojekt von einem Feuerwehrmann für Feuerwehrleute.
-            Mit deiner Spende hilfst du, die Weiterentwicklung und den Betrieb zu finanzieren.
+            Mit deinem freiwilligen Beitrag hilfst du, die Weiterentwicklung und den Betrieb zu finanzieren.
           </p>
         </div>
 
@@ -94,9 +94,9 @@ export default function SpendenPage() {
           <div className="flex items-start gap-4">
             <Lightbulb className="w-7 h-7 text-red-500 shrink-0 mt-0.5" />
             <div>
-              <h3 className="font-bold text-gray-900 mb-2">Wohin fliesst deine Spende?</h3>
+              <h3 className="font-bold text-gray-900 mb-2">Wohin fliesst dein Beitrag?</h3>
               <ul className="space-y-2 text-sm text-gray-600">
-                <li className="flex items-center gap-2"><Shield className="w-4 h-4 text-red-500 shrink-0" /> Server-Hosting in der Schweiz (monatliche Kosten)</li>
+                <li className="flex items-center gap-2"><Shield className="w-4 h-4 text-red-500 shrink-0" /> Server-Hosting und Infrastruktur (monatliche Kosten)</li>
                 <li className="flex items-center gap-2"><Sparkles className="w-4 h-4 text-red-500 shrink-0" /> Entwicklung neuer Features (PWA, Vorlagen, Einsatzpläne)</li>
                 <li className="flex items-center gap-2"><Coffee className="w-4 h-4 text-red-500 shrink-0" /> Domain, SSL-Zertifikate und Infrastruktur</li>
               </ul>
@@ -206,7 +206,7 @@ export default function SpendenPage() {
           {/* CTA */}
           {stripeConfigured === false ? (
             <div className="bg-yellow-50 border border-yellow-200 text-yellow-800 rounded-lg p-4 text-sm text-center">
-              Spenden sind aktuell nicht möglich. Die Zahlungsabwicklung wird gerade eingerichtet.
+              Beiträge sind aktuell nicht möglich. Die Zahlungsabwicklung wird gerade eingerichtet.
             </div>
           ) : (
             <Button
@@ -217,18 +217,30 @@ export default function SpendenPage() {
               {isLoading ? (
                 <><Loader2 className="w-4 h-4 mr-2 animate-spin" /> Weiterleitung zu Stripe...</>
               ) : (
-                <><Heart className="w-4 h-4 mr-2" /> CHF {amount} spenden</>
+                <><Heart className="w-4 h-4 mr-2" /> CHF {amount} beitragen</>
               )}
             </Button>
           )}
 
           <div className="mt-4 flex flex-wrap items-center justify-center gap-3 text-xs text-gray-400">
-            <span className="flex items-center gap-1"><Shield className="w-3.5 h-3.5" /> Sichere Zahlung via Stripe</span>
+            <span className="flex items-center gap-1"><Shield className="w-3.5 h-3.5" /> Zahlung über Stripe</span>
             <span className="flex items-center gap-1"><Check className="w-3.5 h-3.5" /> Kreditkarte</span>
             <span className="flex items-center gap-1"><Check className="w-3.5 h-3.5" /> Twint</span>
             <span className="flex items-center gap-1"><Check className="w-3.5 h-3.5" /> Apple Pay</span>
             <span className="flex items-center gap-1"><Check className="w-3.5 h-3.5" /> Google Pay</span>
           </div>
+
+          {/* Rechtlicher Hinweis zum freiwilligen Beitrag */}
+          <div className="mt-5 rounded-lg bg-gray-50 border border-gray-100 p-4 text-xs text-gray-500 leading-relaxed">
+            <strong className="text-gray-700">Freiwilliger Unterstützungsbeitrag.</strong> Ein Beitrag ist
+            freiwillig und erfolgt ohne Anspruch auf eine Gegenleistung. Daraus entsteht insbesondere kein
+            Anspruch auf Funktionen, Support, Verfügbarkeit, bevorzugte Behandlung oder eine bestimmte
+            Weiterentwicklung. Zahlungs- und Transaktionsgebühren des Zahlungsanbieters (Stripe) können vom
+            Beitrag abgezogen werden. Es wird keine steuerlich abzugsfähige Bescheinigung ausgestellt,
+            solange keine entsprechende behördliche Anerkennung besteht. Es handelt sich um eine einmalige
+            Zahlung; es wird keine wiederkehrende Zahlung eingerichtet. Details zur Zahlungsabwicklung siehe{' '}
+            <Link href="/datenschutz" className="text-red-600 underline">Datenschutzerklärung</Link>.
+          </div>
         </div>
 
         {/* Story */}
@@ -236,21 +248,22 @@ export default function SpendenPage() {
           <h3 className="font-bold text-gray-900 mb-3">Die Geschichte hinter Lageplan</h3>
           <p className="text-sm text-gray-600 leading-relaxed">
             Lageplan wird seit über 2 Jahren von einem aktiven Feuerwehrmann in seiner Freizeit entwickelt.
-            Die App ist und bleibt <strong>kostenlos</strong> — weil jede Feuerwehr Zugang zu guten Werkzeugen haben soll,
+            Die App wird <strong>grundsätzlich kostenlos</strong> angeboten — weil jede Feuerwehr Zugang zu guten
-            unabhängig vom Budget. Es gibt zwar kommerzielle Alternativen, aber die Idee war immer:
+            Werkzeugen haben soll, unabhängig vom Budget. Die Idee war immer:
             Ein Werkzeug <em>von der Feuerwehr, für die Feuerwehr</em>.
           </p>
           <p className="text-sm text-gray-600 leading-relaxed mt-3">
-            Mit deiner Spende hilfst du, dass das so bleibt. Jeder Franken fliesst direkt in
+            Beiträge helfen, Hosting, Infrastruktur und Weiterentwicklung mitzufinanzieren. Danke für deine
-            Serverkosten und Weiterentwicklung. Danke für deine Unterstützung!
+            Unterstützung!
           </p>
         </div>
 
         {/* Trust */}
         <div className="mt-8 text-center">
           <p className="text-sm text-gray-500">
-            100% deiner Spende fliesst direkt in Serverkosten und Weiterentwicklung.
+            Beiträge werden nach Abzug allfälliger Zahlungsgebühren für Hosting, Infrastruktur und
-            <br />Kein Unternehmen, keine Investoren — nur ein Feuerwehrmann mit einer Idee.
+            Weiterentwicklung eingesetzt.
+            <br />Ein Projekt aus der Feuerwehr-Praxis — entwickelt in der Freizeit.
           </p>
           <div className="mt-6">
             <Link href="/">

src/app/unterstuetzen/page.tsx

@@ -0,0 +1,55 @@
+'use client'
+
+import Link from 'next/link'
+import { Heart } from 'lucide-react'
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal } from '@/config/legal'
+
+export default function UnterstuetzenPage() {
+  return (
+    <LegalPage
+      title="Freiwilliger Unterstützungsbeitrag"
+      version={legal.documents.terms.version}
+      publishedAt={legal.documents.terms.publishedAt}
+      draft={false}
+      intro={`${legal.projectName} wird grundsätzlich kostenlos angeboten. Freiwillige Beiträge helfen bei der Finanzierung von Hosting, Infrastruktur und Weiterentwicklung.`}
+    >
+      <section>
+        <p>
+          Ein Beitrag ist <strong>freiwillig</strong> und erfolgt ohne Anspruch auf eine bestimmte Gegenleistung.
+          Daraus entsteht insbesondere kein Anspruch auf Funktionen, Support, Verfügbarkeit, bevorzugte Behandlung
+          oder eine bestimmte Weiterentwicklung.
+        </p>
+        <p>
+          Zahlungs- und Transaktionsgebühren des eingesetzten Zahlungsanbieters (Stripe) können vom Beitrag
+          abgezogen werden. {legal.projectName} stellt keine steuerlich abzugsfähige Bescheinigung aus,
+          solange keine entsprechende behördliche Anerkennung besteht.
+        </p>
+        <p>
+          Es handelt sich um eine <strong>einmalige Zahlung</strong>; es wird keine automatisch wiederkehrende
+          Zahlung eingerichtet. Angaben zur Zahlungsabwicklung enthält die{' '}
+          <a href="/datenschutz">Datenschutzerklärung</a>.
+        </p>
+      </section>
+
+      <section>
+        <h2>Beitrag leisten</h2>
+        <p>Auf der Zahlungsseite kannst du einen Betrag wählen. Die Zahlung erfolgt über Stripe.</p>
+        <Link
+          href="/spenden"
+          className="not-prose inline-flex items-center gap-2 rounded-lg bg-red-600 hover:bg-red-700 text-white px-5 py-2.5 font-semibold no-underline print:hidden"
+        >
+          <Heart className="w-4 h-4" /> Zur Zahlungsseite
+        </Link>
+      </section>
+
+      <section>
+        <h2>Versehentliche Zahlung</h2>
+        <p>
+          Falls eine Zahlung versehentlich erfolgt ist, melde dich bitte unter <strong>{legal.supportEmail}</strong>{' '}
+          zur Prüfung einer Rückerstattung.
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/verantwortungsvolle-nutzung/page.tsx

@@ -0,0 +1,66 @@
+'use client'
+
+import { LegalPage } from '@/components/legal/legal-page'
+import { legal } from '@/config/legal'
+
+export default function VerantwortungsvolleNutzungPage() {
+  const d = legal.documents.responsibleUse
+  return (
+    <LegalPage
+      title="Verantwortungsvolle Nutzung"
+      version={d.version}
+      publishedAt={d.publishedAt}
+      intro={`${legal.projectName} ist ein unterstützendes Werkzeug. Diese Seite erklärt, wie es sicher und verantwortungsvoll eingesetzt wird — damit es im Einsatz zu keinen Missverständnissen kommt.`}
+    >
+      <section>
+        <h2>Was {legal.projectName} ist – und was nicht</h2>
+        <p>
+          {legal.projectName} hilft beim Erstellen, Verwalten, Visualisieren und Exportieren von Lage- und
+          Objektplänen sowie bei unterstützenden Berechnungen. Es ist <strong>kein Alarmierungssystem, keine
+          Leitstelle und kein Einsatzleitsystem</strong> und ersetzt keine behördlich vorgeschriebenen Unterlagen.
+        </p>
+      </section>
+
+      <section>
+        <h2>Grundregeln für den Einsatz</h2>
+        <ul>
+          <li>Haltet unabhängig von {legal.projectName} <strong>aktuelle Offline- und Notfallunterlagen</strong> bereit.</li>
+          <li>Verwendet {legal.projectName} <strong>nicht als einzige Informationsquelle</strong> für operative Entscheidungen.</li>
+          <li>Lasst Pläne, Adressen, Symbole, Distanzen und Berechnungen vor der operativen Verwendung durch <strong>fachkundige Personen prüfen</strong>.</li>
+          <li>Rechnet mit möglichen Störungen oder Nichtverfügbarkeit — es besteht keine garantierte Verfügbarkeit und kein SLA.</li>
+          <li>Erstellt regelmässig <strong>Exporte</strong> wichtiger Pläne als Rückfallebene.</li>
+        </ul>
+      </section>
+
+      <section>
+        <h2>Umgang mit sensiblen Daten</h2>
+        <p>
+          Speichert ohne separate schriftliche Vereinbarung <strong>keine besonders schützenswerten Daten</strong>
+          {' '}(z.B. Patienten-, Gesundheits-, Polizei-, Passwort-, Zugangs- oder Schlüsselcode-Daten). Auch reine
+          Objektinformationen können sicherheitsrelevant sein und dürfen nur berechtigten Personen zugänglich
+          gemacht werden. Details siehe <a href="/nutzungsbedingungen">Nutzungsbedingungen</a> und{' '}
+          <a href="/datenschutz">Datenschutzerklärung</a>.
+        </p>
+      </section>
+
+      <section>
+        <h2>Aktualität von Karten und Berechnungen</h2>
+        <p>
+          Karten-, Adress- und Geodaten können unvollständig, ungenau oder veraltet sein. Berechnungen (z.B.
+          Distanzen, Druckverlust, Höhen) sind <strong>Richtwerte</strong> und ersetzen keine Lagebeurteilung.
+          Änderungen an Gebäuden, Zufahrten, Wasserbezugsstellen oder Gefahren müssen durch die Organisation
+          gepflegt werden.
+        </p>
+      </section>
+
+      <section>
+        <h2>Warum das wichtig ist</h2>
+        <p>
+          {legal.projectName} wird mit viel Eigenleistung entwickelt und Feuerwehren kostenlos zur Verfügung
+          gestellt. Eine verantwortungsvolle Nutzung sorgt dafür, dass das Projekt langfristig sicher und
+          kostenlos angeboten werden kann — und dass im Ernstfall keine falschen Erwartungen entstehen.
+        </p>
+      </section>
+    </LegalPage>
+  )
+}

src/app/view/[token]/page.tsx

@@ -0,0 +1,231 @@
+'use client'
+
+import { useEffect, useRef, useState, useCallback } from 'react'
+import { useParams } from 'next/navigation'
+import dynamic from 'next/dynamic'
+import { DndProvider } from 'react-dnd'
+import { HTML5Backend } from 'react-dnd-html5-backend'
+import { Eye, Lock, Loader2, MapPin, Wind } from 'lucide-react'
+import { getSocket, setSocketRoom } from '@/lib/socket'
+import { degToCompass } from '@/components/map/map-compass'
+import type { DrawFeature, Project } from '@/types'
+
+// MapLibre nur clientseitig laden (kein SSR)
+const MapView = dynamic(() => import('@/components/map/map-view').then(m => m.MapView), { ssr: false })
+
+type Phase = 'loading' | 'pin' | 'ready' | 'error'
+
+interface ShareMeta {
+  title: string
+  einsatzNr?: string | null
+  location?: string | null
+}
+
+export default function SharedViewPage() {
+  const params = useParams()
+  const token = String(params?.token || '')
+
+  const [phase, setPhase] = useState<Phase>('loading')
+  const [meta, setMeta] = useState<ShareMeta | null>(null)
+  const [project, setProject] = useState<Project | null>(null)
+  const [features, setFeatures] = useState<DrawFeature[]>([])
+  const [pin, setPin] = useState('')
+  const [error, setError] = useState('')
+  const [submitting, setSubmitting] = useState(false)
+  const projectIdRef = useRef<string | null>(null)
+  const pinRef = useRef('')
+
+  // Snapshot laden (mit optionaler PIN)
+  const loadSnapshot = useCallback(async (pinValue?: string) => {
+    setSubmitting(true)
+    setError('')
+    try {
+      const res = await fetch(`/api/share/${token}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pin: pinValue || undefined }),
+      })
+      const data = await res.json()
+      if (res.status === 401) {
+        setPhase('pin')
+        setError(pinValue ? 'Falsche PIN — bitte erneut versuchen.' : '')
+        return false
+      }
+      if (!res.ok) {
+        setError(data.error || 'Link ungültig.')
+        setPhase('error')
+        return false
+      }
+      projectIdRef.current = data.projectId
+      pinRef.current = pinValue || ''
+      setProject(data.project as Project)
+      setFeatures(data.features || [])
+      setPhase('ready')
+      return true
+    } catch {
+      setError('Verbindungsfehler.')
+      setPhase('error')
+      return false
+    } finally {
+      setSubmitting(false)
+    }
+  }, [token])
+
+  // Beim Laden: Meta holen, dann ggf. direkt Snapshot (ohne PIN) laden
+  useEffect(() => {
+    if (!token) return
+    let cancelled = false
+    ;(async () => {
+      try {
+        const res = await fetch(`/api/share/${token}`)
+        const data = await res.json()
+        if (cancelled) return
+        if (!res.ok) { setError(data.error || 'Link ungültig oder deaktiviert.'); setPhase('error'); return }
+        setMeta({ title: data.title, einsatzNr: data.einsatzNr, location: data.location })
+        if (data.requiresPin) {
+          setPhase('pin')
+        } else {
+          await loadSnapshot()
+        }
+      } catch {
+        if (!cancelled) { setError('Verbindungsfehler.'); setPhase('error') }
+      }
+    })()
+    return () => { cancelled = true }
+  }, [token, loadSnapshot])
+
+  // Live-Updates: Socket-Raum beitreten + auf Feature-Änderungen hören.
+  // Zusätzlich alle 30s als Fallback neu laden (falls ein Socket-Event verloren geht).
+  useEffect(() => {
+    if (phase !== 'ready' || !projectIdRef.current) return
+    const pid = projectIdRef.current
+    const socket = getSocket()
+    setSocketRoom(pid)
+    socket.emit('join-project', pid)
+
+    const onFeatures = (data: { features?: DrawFeature[] }) => {
+      if (Array.isArray(data?.features)) setFeatures(data.features)
+    }
+    socket.on('features-changed', onFeatures)
+
+    const poll = setInterval(async () => {
+      try {
+        const res = await fetch(`/api/share/${token}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ pin: pinRef.current || undefined }),
+        })
+        if (res.ok) {
+          const data = await res.json()
+          if (Array.isArray(data.features)) setFeatures(data.features)
+        }
+      } catch { /* offline — beim nächsten Tick erneut */ }
+    }, 30000)
+
+    return () => {
+      socket.off('features-changed', onFeatures)
+      socket.emit('leave-project', pid)
+      setSocketRoom(null)
+      clearInterval(poll)
+    }
+  }, [phase, token])
+
+  // ─── PIN-Eingabe ───
+  if (phase === 'pin') {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-muted/30 p-4">
+        <form
+          onSubmit={(e) => { e.preventDefault(); if (pin.length >= 4) loadSnapshot(pin) }}
+          className="w-full max-w-sm bg-card border border-border rounded-xl shadow-lg p-6 space-y-4"
+        >
+          <div className="flex items-center gap-2 text-lg font-bold">
+            <Lock className="w-5 h-5 text-primary" /> Geschützte Ansicht
+          </div>
+          {meta?.title && <p className="text-sm text-muted-foreground">{meta.einsatzNr ? `${meta.einsatzNr} · ` : ''}{meta.title}</p>}
+          <p className="text-sm">Bitte PIN eingeben, um die Lage anzusehen.</p>
+          <input
+            type="text"
+            inputMode="numeric"
+            autoFocus
+            value={pin}
+            onChange={(e) => setPin(e.target.value.replace(/\D/g, '').slice(0, 8))}
+            placeholder="PIN"
+            className="w-full text-center text-2xl tracking-[0.4em] font-mono border border-border rounded-lg py-2.5 bg-background"
+          />
+          {error && <p className="text-sm text-red-600">{error}</p>}
+          <button
+            type="submit"
+            disabled={pin.length < 4 || submitting}
+            className="w-full bg-primary text-primary-foreground rounded-lg py-2.5 font-semibold disabled:opacity-50 flex items-center justify-center gap-2"
+          >
+            {submitting && <Loader2 className="w-4 h-4 animate-spin" />} Ansehen
+          </button>
+        </form>
+      </div>
+    )
+  }
+
+  // ─── Fehler ───
+  if (phase === 'error') {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-muted/30 p-4">
+        <div className="w-full max-w-sm bg-card border border-border rounded-xl shadow-lg p-6 text-center space-y-2">
+          <div className="text-lg font-bold">Nicht verfügbar</div>
+          <p className="text-sm text-muted-foreground">{error || 'Dieser Teilen-Link ist ungültig oder wurde deaktiviert.'}</p>
+        </div>
+      </div>
+    )
+  }
+
+  // ─── Laden ───
+  if (phase === 'loading' || !project) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-muted/30">
+        <Loader2 className="w-6 h-6 animate-spin text-muted-foreground" />
+      </div>
+    )
+  }
+
+  // ─── Karte (read-only) ───
+  return (
+    <div className="h-screen w-screen flex flex-col">
+      {/* Schlanke Kopfzeile für Ansichts-Modus */}
+      <header className="h-12 shrink-0 border-b border-border bg-card flex items-center gap-3 px-3 md:px-4">
+        <span className="inline-flex items-center gap-1.5 rounded-full bg-blue-600 text-white text-xs font-semibold px-2.5 py-1">
+          <Eye className="w-3.5 h-3.5" /> Nur Ansicht · live
+        </span>
+        <div className="flex items-center gap-2 min-w-0">
+          <span className="font-semibold text-sm truncate">
+            {(project as any).einsatzNr ? `${(project as any).einsatzNr} · ` : ''}{(project as any).title}
+          </span>
+          {(project as any).location && (
+            <span className="hidden sm:inline-flex items-center gap-1 text-xs text-muted-foreground truncate">
+              <MapPin className="w-3.5 h-3.5" /> {(project as any).location}
+            </span>
+          )}
+        </div>
+        {typeof project.windDirection === 'number' && (
+          <span className="ml-auto hidden sm:inline-flex items-center gap-1 rounded-full bg-blue-50 dark:bg-blue-950/40 text-blue-700 dark:text-blue-300 text-xs font-medium px-2 py-1">
+            <Wind className="w-3.5 h-3.5" /> Wind aus {degToCompass(project.windDirection)}
+          </span>
+        )}
+      </header>
+
+      <div className="flex-1 relative overflow-hidden">
+        <DndProvider backend={HTML5Backend}>
+          <MapView
+            project={project}
+            features={features}
+            drawMode="select"
+            selectedColor="#ef4444"
+            selectedWidth={4}
+            onFeaturesChange={() => {}}
+            onSymbolDrop={() => {}}
+            onTextPlace={() => {}}
+            canEdit={false}
+          />
+        </DndProvider>
+      </div>
+    </div>
+  )
+}

src/components/admin/backup-tab.tsx

@@ -0,0 +1,160 @@
+'use client'
+
+import { useEffect, useState, useCallback } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { useToast } from '@/components/ui/use-toast'
+import { HardDriveDownload, Loader2, ShieldCheck, PlugZap, Save } from 'lucide-react'
+
+interface MaskedCfg {
+  enabled: boolean
+  schedule: 'off' | 'daily' | 'weekly'
+  retentionDays: number
+  hasPassphrase: boolean
+  destinationType: 'sftp' | 'webdav'
+  sftp?: { host: string; port: number; username: string; remotePath: string; hasPassword: boolean }
+  webdav?: { url: string; username: string; remotePath: string; hasPassword: boolean }
+  lastRun?: string | null
+  lastStatus?: 'ok' | 'error' | null
+  lastMessage?: string | null
+}
+
+export function BackupTab() {
+  const { toast } = useToast()
+  const [cfg, setCfg] = useState<MaskedCfg | null>(null)
+  const [busy, setBusy] = useState<'' | 'save' | 'test' | 'run'>('')
+  // Neue Geheimnisse (nur senden, wenn ausgefüllt)
+  const [passphrase, setPassphrase] = useState('')
+  const [sftpPw, setSftpPw] = useState('')
+  const [webdavPw, setWebdavPw] = useState('')
+
+  const load = useCallback(async () => {
+    const r = await fetch('/api/admin/backup/config')
+    if (r.ok) setCfg(await r.json())
+  }, [])
+  useEffect(() => { load() }, [load])
+
+  if (!cfg) return <div className="py-10 flex justify-center"><Loader2 className="w-6 h-6 animate-spin text-muted-foreground" /></div>
+
+  const patch = (p: Partial<MaskedCfg>) => setCfg(c => c ? { ...c, ...p } : c)
+  const patchSftp = (p: any) => setCfg(c => c ? { ...c, sftp: { ...(c.sftp || { host: '', port: 22, username: '', remotePath: '/lageplan-backups', hasPassword: false }), ...p } } : c)
+  const patchWebdav = (p: any) => setCfg(c => c ? { ...c, webdav: { ...(c.webdav || { url: '', username: '', remotePath: '/Lageplan-Backups', hasPassword: false }), ...p } } : c)
+
+  const save = async () => {
+    setBusy('save')
+    try {
+      const body: any = {
+        enabled: cfg.enabled, schedule: cfg.schedule, retentionDays: cfg.retentionDays,
+        destinationType: cfg.destinationType,
+      }
+      if (passphrase) body.passphrase = passphrase
+      if (cfg.destinationType === 'sftp' && cfg.sftp) body.sftp = { ...cfg.sftp, password: sftpPw || undefined }
+      if (cfg.destinationType === 'webdav' && cfg.webdav) body.webdav = { ...cfg.webdav, password: webdavPw || undefined }
+      const r = await fetch('/api/admin/backup/config', { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) })
+      if (r.ok) { setCfg(await r.json()); setPassphrase(''); setSftpPw(''); setWebdavPw(''); toast({ title: 'Gespeichert' }) }
+      else { const d = await r.json(); toast({ title: 'Fehler', description: d.error, variant: 'destructive' }) }
+    } finally { setBusy('') }
+  }
+
+  const test = async () => {
+    setBusy('test')
+    try {
+      const r = await fetch('/api/admin/backup/test', { method: 'POST' })
+      const d = await r.json()
+      toast({ title: d.ok ? 'Verbindung ok' : 'Verbindung fehlgeschlagen', description: d.message, variant: d.ok ? undefined : 'destructive' })
+    } finally { setBusy('') }
+  }
+
+  const runNow = async () => {
+    if (!confirm('Jetzt ein Backup erstellen und zum Ziel hochladen?')) return
+    setBusy('run')
+    try {
+      const r = await fetch('/api/admin/backup/run', { method: 'POST' })
+      const d = await r.json()
+      toast({ title: d.ok ? 'Backup erstellt' : 'Backup fehlgeschlagen', description: d.message, variant: d.ok ? undefined : 'destructive' })
+      load()
+    } finally { setBusy('') }
+  }
+
+  return (
+    <div className="space-y-6 max-w-2xl">
+      <div>
+        <h3 className="text-lg font-semibold flex items-center gap-2"><HardDriveDownload className="w-5 h-5 text-primary" /> Backup (verschlüsselt, extern)</h3>
+        <p className="text-sm text-muted-foreground mt-1">
+          Sichert Datenbank + hochgeladene Dateien verschlüsselt auf ein externes Ziel (SFTP oder Nextcloud/WebDAV).
+          Best Practice: zusätzlich zum lokalen Backup, an einen anderen Ort.
+        </p>
+      </div>
+
+      {/* Status */}
+      {cfg.lastRun && (
+        <div className={`rounded-lg border p-3 text-sm ${cfg.lastStatus === 'ok' ? 'border-green-300 bg-green-50 dark:bg-green-950/30 dark:border-green-800' : 'border-red-300 bg-red-50 dark:bg-red-950/30 dark:border-red-800'}`}>
+          <strong>Letztes Backup:</strong> {new Date(cfg.lastRun).toLocaleString('de-CH')} — {cfg.lastStatus === 'ok' ? '✅' : '❌'} {cfg.lastMessage}
+        </div>
+      )}
+
+      {/* Zeitplan */}
+      <div className="rounded-lg border p-4 space-y-3">
+        <h4 className="font-semibold text-sm">Zeitplan</h4>
+        <div className="grid grid-cols-2 gap-3">
+          <div>
+            <Label className="text-xs">Automatisch</Label>
+            <select value={cfg.schedule} onChange={e => patch({ schedule: e.target.value as any, enabled: e.target.value !== 'off' })} className="w-full h-9 rounded-md border border-input bg-background px-2 text-sm">
+              <option value="off">Aus (nur manuell)</option>
+              <option value="daily">Täglich</option>
+              <option value="weekly">Wöchentlich</option>
+            </select>
+          </div>
+          <div>
+            <Label className="text-xs">Aufbewahrung (Tage)</Label>
+            <Input type="number" min={1} max={3650} value={cfg.retentionDays} onChange={e => patch({ retentionDays: Number(e.target.value) })} className="h-9" />
+          </div>
+        </div>
+      </div>
+
+      {/* Verschlüsselung */}
+      <div className="rounded-lg border p-4 space-y-2">
+        <h4 className="font-semibold text-sm flex items-center gap-1.5"><ShieldCheck className="w-4 h-4" /> Verschlüsselung</h4>
+        <Label className="text-xs">Passphrase {cfg.hasPassphrase && <span className="text-green-600">· gesetzt</span>}</Label>
+        <Input type="password" value={passphrase} onChange={e => setPassphrase(e.target.value)} placeholder={cfg.hasPassphrase ? 'Zum Beibehalten leer lassen' : 'Passphrase wählen (sicher aufbewahren!)'} className="h-9" />
+        <p className="text-xs text-muted-foreground">⚠️ Ohne diese Passphrase ist kein Restore möglich — im Passwort-Manager speichern.</p>
+      </div>
+
+      {/* Ziel */}
+      <div className="rounded-lg border p-4 space-y-3">
+        <div className="flex items-center gap-3">
+          <h4 className="font-semibold text-sm">Ziel</h4>
+          <select value={cfg.destinationType} onChange={e => patch({ destinationType: e.target.value as any })} className="h-8 rounded-md border border-input bg-background px-2 text-sm">
+            <option value="sftp">SFTP</option>
+            <option value="webdav">Nextcloud / WebDAV</option>
+          </select>
+        </div>
+
+        {cfg.destinationType === 'sftp' ? (
+          <div className="grid grid-cols-2 gap-3">
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">Host</Label><Input value={cfg.sftp?.host || ''} onChange={e => patchSftp({ host: e.target.value })} placeholder="nas.example.com" className="h-9" /></div>
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">Port</Label><Input type="number" value={cfg.sftp?.port ?? 22} onChange={e => patchSftp({ port: Number(e.target.value) })} className="h-9" /></div>
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">Benutzer</Label><Input value={cfg.sftp?.username || ''} onChange={e => patchSftp({ username: e.target.value })} className="h-9" /></div>
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">Passwort {cfg.sftp?.hasPassword && <span className="text-green-600">· gesetzt</span>}</Label><Input type="password" value={sftpPw} onChange={e => setSftpPw(e.target.value)} placeholder={cfg.sftp?.hasPassword ? 'leer lassen' : ''} className="h-9" /></div>
+            <div className="col-span-2"><Label className="text-xs">Zielordner (Remote-Pfad)</Label><Input value={cfg.sftp?.remotePath || ''} onChange={e => patchSftp({ remotePath: e.target.value })} placeholder="/lageplan-backups" className="h-9" /></div>
+          </div>
+        ) : (
+          <div className="grid grid-cols-2 gap-3">
+            <div className="col-span-2"><Label className="text-xs">WebDAV-URL</Label><Input value={cfg.webdav?.url || ''} onChange={e => patchWebdav({ url: e.target.value })} placeholder="https://cloud.example.com/remote.php/dav/files/USER/" className="h-9" /></div>
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">Benutzer</Label><Input value={cfg.webdav?.username || ''} onChange={e => patchWebdav({ username: e.target.value })} className="h-9" /></div>
+            <div className="col-span-2 sm:col-span-1"><Label className="text-xs">App-Passwort {cfg.webdav?.hasPassword && <span className="text-green-600">· gesetzt</span>}</Label><Input type="password" value={webdavPw} onChange={e => setWebdavPw(e.target.value)} placeholder={cfg.webdav?.hasPassword ? 'leer lassen' : 'Nextcloud App-Passwort'} className="h-9" /></div>
+            <div className="col-span-2"><Label className="text-xs">Zielordner</Label><Input value={cfg.webdav?.remotePath || ''} onChange={e => patchWebdav({ remotePath: e.target.value })} placeholder="/Lageplan-Backups" className="h-9" /></div>
+          </div>
+        )}
+      </div>
+
+      <div className="flex flex-wrap gap-2">
+        <Button onClick={save} disabled={busy !== ''}>{busy === 'save' ? <Loader2 className="w-4 h-4 mr-1.5 animate-spin" /> : <Save className="w-4 h-4 mr-1.5" />} Speichern</Button>
+        <Button variant="outline" onClick={test} disabled={busy !== ''}>{busy === 'test' ? <Loader2 className="w-4 h-4 mr-1.5 animate-spin" /> : <PlugZap className="w-4 h-4 mr-1.5" />} Verbindung testen</Button>
+        <Button variant="outline" onClick={runNow} disabled={busy !== ''}>{busy === 'run' ? <Loader2 className="w-4 h-4 mr-1.5 animate-spin" /> : <HardDriveDownload className="w-4 h-4 mr-1.5" />} Jetzt sichern</Button>
+      </div>
+      <p className="text-xs text-muted-foreground">Speichern → Verbindung testen → Jetzt sichern. Restore: siehe <code>docs/BACKUP.md</code> (Entschlüsseln mit der Passphrase).</p>
+    </div>
+  )
+}

src/components/admin/settings-tab.tsx

@@ -239,7 +239,7 @@ export function SettingsTab({ onNavigateTab }: SettingsTabProps) {
           <Mail className="w-5 h-5 text-primary" />
           E-Mail / SMTP Konfiguration
         </h3>
-        <p className="text-sm text-muted-foreground mb-4">SMTP-Server für den E-Mail-Versand konfigurieren. Empfohlen: TLS auf Port 587. Passwörter werden verschlüsselt in der Datenbank gespeichert.</p>
+        <p className="text-sm text-muted-foreground mb-4">SMTP-Server für den E-Mail-Versand konfigurieren. Empfohlen: TLS auf Port 587. Zugangsdaten werden serverseitig gespeichert und im Interface maskiert.</p>
         <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
           <div><Label>SMTP Host</Label><Input value={smtpHost} onChange={e => setSmtpHost(e.target.value)} placeholder="smtp.gmail.com" /></div>
           <div className="grid grid-cols-2 gap-2">
@@ -284,10 +284,10 @@ export function SettingsTab({ onNavigateTab }: SettingsTabProps) {
       <div className="border rounded-lg p-6 md:col-span-2">
         <h3 className="font-semibold text-lg mb-4 flex items-center gap-2">
           <CreditCard className="w-5 h-5 text-primary" />
-          Stripe / Spenden-Konfiguration
+          Stripe / Unterstützungs-Konfiguration
         </h3>
         <p className="text-sm text-muted-foreground mb-4">
-          Stripe API-Keys für die Spendenseite konfigurieren. Unterstützt Kreditkarte, Twint und weitere Zahlungsmethoden.
+          Stripe API-Keys für die Unterstützungsseite konfigurieren. Unterstützt Kreditkarte, Twint und weitere Zahlungsmethoden.
           Keys findest du im <a href="https://dashboard.stripe.com/apikeys" target="_blank" rel="noopener noreferrer" className="text-primary underline">Stripe Dashboard</a>.
         </p>
         <div className="grid grid-cols-1 md:grid-cols-2 gap-4">

src/components/admin/users-tab.tsx

@@ -109,6 +109,15 @@ export function UsersTab() {
     } catch { toast({ title: 'Fehler', variant: 'destructive' }) }
   }
 
+  const handleResetUserMfa = async (targetUser: UserRecord) => {
+    if (!confirm(`Zwei-Faktor (2FA) von "${targetUser.name}" zurücksetzen? Der Benutzer meldet sich danach nur mit Passwort an, bis er 2FA neu einrichtet.`)) return
+    try {
+      const res = await fetch(`/api/admin/users/${targetUser.id}/mfa-reset`, { method: 'POST' })
+      if (res.ok) { toast({ title: '2FA zurückgesetzt' }) }
+      else { const err = await res.json(); toast({ title: 'Fehler', description: err.error, variant: 'destructive' }) }
+    } catch { toast({ title: 'Fehler', variant: 'destructive' }) }
+  }
+
   const handleToggleUserVerified = async (targetUser: UserRecord) => {
     try {
       const newVal = !targetUser.emailVerified
@@ -251,6 +260,9 @@ export function UsersTab() {
                     <Button variant="ghost" size="icon" className="h-8 w-8" title="Passwort zurücksetzen" onClick={() => handleResetUserPassword(u)}>
                       <KeyRound className="w-4 h-4" />
                     </Button>
+                    <Button variant="ghost" size="icon" className="h-8 w-8" title="Zwei-Faktor (2FA) zurücksetzen" onClick={() => handleResetUserMfa(u)}>
+                      <ShieldCheck className="w-4 h-4" />
+                    </Button>
                     <Button variant="ghost" size="icon" className="h-8 w-8" title="Bearbeiten" onClick={() => openEditUser(u)}>
                       <Pencil className="w-4 h-4" />
                     </Button>

src/components/dialogs/project-dialog.tsx

@@ -33,6 +33,23 @@ interface NominatimResult {
   }
 }
 
+// Baut aus einem Nominatim-Ergebnis eine kurze, lesbare Adresse (Strasse Nr, PLZ Ort)
+function buildDisplayName(result: NominatimResult): string {
+  const addr = result.address
+  if (!addr) return result.display_name
+  const parts: string[] = []
+  if (addr.road) {
+    parts.push(addr.road + (addr.house_number ? ' ' + addr.house_number : ''))
+  }
+  const city = addr.city || addr.town || addr.village || addr.municipality
+  if (addr.postcode && city) {
+    parts.push(`${addr.postcode} ${city}`)
+  } else if (city) {
+    parts.push(city)
+  }
+  return parts.length > 0 ? parts.join(', ') : result.display_name
+}
+
 interface ProjectDialogProps {
   open: boolean
   onOpenChange: (open: boolean) => void
@@ -65,6 +82,9 @@ export function ProjectDialog({
   const [isSearching, setIsSearching] = useState(false)
   const [showSuggestions, setShowSuggestions] = useState(false)
   const [selectedCoords, setSelectedCoords] = useState<{ lat: number; lng: number } | null>(null)
+  const [isLocating, setIsLocating] = useState(false)
+  const [locateError, setLocateError] = useState('')
+  const autoLocatedRef = useRef(false)
   const debounceRef = useRef<NodeJS.Timeout | null>(null)
   const suggestionsRef = useRef<HTMLDivElement>(null)
 
@@ -103,28 +123,64 @@ export function ProjectDialog({
   }
 
   const handleSelectSuggestion = (result: NominatimResult) => {
-    // Build a clean display name
+    setLocation(buildDisplayName(result))
-    const addr = result.address
-    let displayName = result.display_name
-    if (addr) {
-      const parts: string[] = []
-      if (addr.road) {
-        parts.push(addr.road + (addr.house_number ? ' ' + addr.house_number : ''))
-      }
-      const city = addr.city || addr.town || addr.village || addr.municipality
-      if (addr.postcode && city) {
-        parts.push(`${addr.postcode} ${city}`)
-      } else if (city) {
-        parts.push(city)
-      }
-      if (parts.length > 0) displayName = parts.join(', ')
-    }
-    setLocation(displayName)
     setSelectedCoords({ lat: parseFloat(result.lat), lng: parseFloat(result.lon) })
     setSuggestions([])
     setShowSuggestions(false)
   }
 
+  // Aktuellen Standort ermitteln und als Einsatzort vorschlagen (Reverse-Geocoding)
+  const applyCurrentLocation = useCallback(() => {
+    if (typeof navigator === 'undefined' || !navigator.geolocation) {
+      setLocateError('Standort auf diesem Gerät nicht verfügbar')
+      return
+    }
+    setIsLocating(true)
+    setLocateError('')
+    navigator.geolocation.getCurrentPosition(
+      async (pos) => {
+        const { latitude, longitude } = pos.coords
+        setSelectedCoords({ lat: latitude, lng: longitude })
+        setShowSuggestions(false)
+        try {
+          const res = await fetch(
+            `https://nominatim.openstreetmap.org/reverse?lat=${latitude}&lon=${longitude}&format=json&addressdetails=1`
+          )
+          if (res.ok) {
+            const data: NominatimResult = await res.json()
+            setLocation(buildDisplayName(data))
+          } else {
+            setLocation(`${latitude.toFixed(5)}, ${longitude.toFixed(5)}`)
+          }
+        } catch {
+          setLocation(`${latitude.toFixed(5)}, ${longitude.toFixed(5)}`)
+        } finally {
+          setIsLocating(false)
+        }
+      },
+      (err) => {
+        setIsLocating(false)
+        setLocateError(
+          err.code === err.PERMISSION_DENIED
+            ? 'Standortzugriff verweigert'
+            : 'Standort konnte nicht ermittelt werden'
+        )
+      },
+      { enableHighAccuracy: true, timeout: 8000, maximumAge: 60000 }
+    )
+  }, [])
+
+  // Beim Öffnen eines neuen Einsatzes den Standort automatisch als Ort vorschlagen
+  useEffect(() => {
+    if (open && mode === 'EINSATZ' && !autoLocatedRef.current && !location && !selectedCoords) {
+      autoLocatedRef.current = true
+      applyCurrentLocation()
+    }
+    if (!open) {
+      autoLocatedRef.current = false
+    }
+  }, [open, mode, location, selectedCoords, applyCurrentLocation])
+
   // Close suggestions on click outside
   useEffect(() => {
     const handleClickOutside = (e: MouseEvent) => {
@@ -186,6 +242,8 @@ export function ProjectDialog({
       setJournalfuehrer('')
       setSelectedCoords(null)
       setSuggestions([])
+      setLocateError('')
+      setIsLocating(false)
     } catch (error) {
       toast({
         title: 'Fehler',
@@ -207,6 +265,8 @@ export function ProjectDialog({
       setJournalfuehrer('')
       setSelectedCoords(null)
       setSuggestions([])
+      setLocateError('')
+      setIsLocating(false)
       onOpenChange(false)
     }
   }
@@ -269,14 +329,26 @@ export function ProjectDialog({
           </div>
 
           <div className="space-y-2">
-            <Label htmlFor="project-location">
+            <div className="flex items-center justify-between gap-2">
-              Einsatzort
+              <Label htmlFor="project-location">
-              {selectedCoords && (
+                Einsatzort
-                <span className="ml-2 text-xs text-green-600 font-normal inline-flex items-center gap-1">
+                {selectedCoords && (
-                  <MapPin className="w-3 h-3" /> Koordinaten gesetzt
+                  <span className="ml-2 text-xs text-green-600 font-normal inline-flex items-center gap-1">
-                </span>
+                    <MapPin className="w-3 h-3" /> Koordinaten gesetzt
-              )}
+                  </span>
-            </Label>
+                )}
+              </Label>
+              <button
+                type="button"
+                onClick={applyCurrentLocation}
+                disabled={isCreating || isLocating}
+                className="shrink-0 inline-flex items-center gap-1 text-xs font-medium text-primary hover:underline disabled:opacity-50"
+                title="Aktuellen Standort als Einsatzort übernehmen"
+              >
+                {isLocating ? <Loader2 className="w-3.5 h-3.5 animate-spin" /> : <MapPin className="w-3.5 h-3.5" />}
+                {isLocating ? 'Ermittle…' : 'Mein Standort'}
+              </button>
+            </div>
             <div className="relative" ref={suggestionsRef}>
               <div className="relative">
                 <Input
@@ -336,19 +408,25 @@ export function ProjectDialog({
                 </div>
               )}
             </div>
-            <p className="text-xs text-muted-foreground">
+            {locateError ? (
-              Adresse suchen — die Karte springt automatisch zum Einsatzort
+              <p className="text-xs text-amber-600">{locateError} — Adresse bitte manuell eingeben.</p>
-            </p>
+            ) : (
+              <p className="text-xs text-muted-foreground">
+                Standort wird beim Öffnen vorgeschlagen — oder Adresse suchen. Die Karte springt automatisch zum Einsatzort.
+              </p>
+            )}
           </div>
 
           <div className="space-y-2">
             <Label htmlFor="project-description">Beschreibung</Label>
-            <Input
+            <textarea
               id="project-description"
               value={description}
               onChange={(e) => setDescription(e.target.value)}
               placeholder="Optionale Notizen zum Einsatz"
               disabled={isCreating}
+              rows={3}
+              className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-ring disabled:opacity-60 resize-y"
             />
           </div>
 

src/components/dialogs/share-dialog.tsx

@@ -0,0 +1,186 @@
+'use client'
+
+import { useEffect, useState, useCallback } from 'react'
+import QRCode from 'qrcode'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogDescription,
+} from '@/components/ui/dialog'
+import { Loader2, Copy, Check, Eye, Link2, Trash2 } from 'lucide-react'
+
+interface ShareDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  projectId: string | null
+  projectTitle?: string
+}
+
+export function ShareDialog({ open, onOpenChange, projectId, projectTitle }: ShareDialogProps) {
+  const [loading, setLoading] = useState(false)
+  const [saving, setSaving] = useState(false)
+  const [enabled, setEnabled] = useState(false)
+  const [url, setUrl] = useState<string | null>(null)
+  const [hasPin, setHasPin] = useState(false)
+  const [usePin, setUsePin] = useState(false)
+  const [pinInput, setPinInput] = useState('')
+  const [copied, setCopied] = useState(false)
+  const [qr, setQr] = useState<string>('')
+  const [error, setError] = useState('')
+
+  // Status beim Öffnen laden
+  useEffect(() => {
+    if (!open || !projectId) return
+    setLoading(true)
+    setError('')
+    setPinInput('')
+    setCopied(false)
+    fetch(`/api/projects/${projectId}/share`)
+      .then(r => r.json())
+      .then(d => {
+        setEnabled(!!d.enabled)
+        setUrl(d.url || null)
+        setHasPin(!!d.hasPin)
+        setUsePin(!!d.hasPin)
+      })
+      .catch(() => setError('Konnte Teilen-Status nicht laden.'))
+      .finally(() => setLoading(false))
+  }, [open, projectId])
+
+  // QR-Code erzeugen, wenn ein Link existiert
+  useEffect(() => {
+    if (url) {
+      QRCode.toDataURL(url, { width: 220, margin: 1 }).then(setQr).catch(() => setQr(''))
+    } else {
+      setQr('')
+    }
+  }, [url])
+
+  const post = useCallback(async (body: any) => {
+    if (!projectId) return
+    setSaving(true)
+    setError('')
+    try {
+      const res = await fetch(`/api/projects/${projectId}/share`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      })
+      const d = await res.json()
+      if (!res.ok) { setError(d.error || 'Fehler beim Speichern.'); return }
+      setEnabled(!!d.enabled)
+      setUrl(d.url || null)
+      setHasPin(!!d.hasPin)
+    } catch {
+      setError('Verbindungsfehler.')
+    } finally {
+      setSaving(false)
+    }
+  }, [projectId])
+
+  const handleEnable = () => post({ enabled: true })
+  const handleDisable = () => { setUsePin(false); post({ enabled: false }) }
+
+  const handleSavePin = () => {
+    if (usePin) {
+      if (!/^\d{4,8}$/.test(pinInput)) { setError('PIN muss 4–8 Ziffern haben.'); return }
+      post({ enabled: true, pin: pinInput }).then(() => setPinInput(''))
+    } else {
+      post({ enabled: true, pin: null })
+    }
+  }
+
+  const handleCopy = async () => {
+    if (!url) return
+    try {
+      await navigator.clipboard.writeText(url)
+      setCopied(true)
+      setTimeout(() => setCopied(false), 2000)
+    } catch { /* Clipboard evtl. blockiert */ }
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-md">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <Link2 className="w-5 h-5" /> Lage teilen (Nur-Ansicht)
+          </DialogTitle>
+          <DialogDescription>
+            Erzeugt einen Link, über den andere die Lage <strong>live nur ansehen</strong> können —
+            ohne Login. Nichts kann darüber verändert werden.
+          </DialogDescription>
+        </DialogHeader>
+
+        {loading ? (
+          <div className="py-8 flex justify-center"><Loader2 className="w-6 h-6 animate-spin text-muted-foreground" /></div>
+        ) : (
+          <div className="space-y-4 py-2">
+            {!enabled ? (
+              <Button onClick={handleEnable} disabled={saving} className="w-full">
+                {saving ? <Loader2 className="w-4 h-4 mr-2 animate-spin" /> : <Eye className="w-4 h-4 mr-2" />}
+                Teilen aktivieren
+              </Button>
+            ) : (
+              <>
+                {/* Link + Kopieren */}
+                <div className="space-y-1.5">
+                  <Label>Teilen-Link</Label>
+                  <div className="flex gap-2">
+                    <Input readOnly value={url || ''} className="font-mono text-xs" onFocus={(e) => e.target.select()} />
+                    <Button variant="outline" size="icon" onClick={handleCopy} title="Link kopieren">
+                      {copied ? <Check className="w-4 h-4 text-green-600" /> : <Copy className="w-4 h-4" />}
+                    </Button>
+                  </div>
+                </div>
+
+                {/* QR-Code zum Scannen vor Ort */}
+                {qr && (
+                  <div className="flex justify-center">
+                    {/* eslint-disable-next-line @next/next/no-img-element */}
+                    <img src={qr} alt="QR-Code zum Teilen-Link" className="w-40 h-40 rounded-lg border border-border" />
+                  </div>
+                )}
+
+                {/* PIN-Schutz */}
+                <div className="rounded-lg border border-border p-3 space-y-2">
+                  <label className="flex items-center gap-2 text-sm font-medium cursor-pointer">
+                    <input type="checkbox" checked={usePin} onChange={(e) => setUsePin(e.target.checked)} className="w-4 h-4" />
+                    Mit PIN schützen {hasPin && <span className="text-xs text-green-600 font-normal">· aktiv</span>}
+                  </label>
+                  {usePin && (
+                    <div className="flex gap-2">
+                      <Input
+                        inputMode="numeric"
+                        value={pinInput}
+                        onChange={(e) => setPinInput(e.target.value.replace(/\D/g, '').slice(0, 8))}
+                        placeholder={hasPin ? 'Neue PIN (4–8 Ziffern)' : 'PIN (4–8 Ziffern)'}
+                        className="font-mono tracking-widest"
+                      />
+                      <Button variant="outline" onClick={handleSavePin} disabled={saving}>Speichern</Button>
+                    </div>
+                  )}
+                  {!usePin && hasPin && (
+                    <Button variant="outline" size="sm" onClick={handleSavePin} disabled={saving}>PIN entfernen</Button>
+                  )}
+                </div>
+
+                {/* Deaktivieren */}
+                <Button variant="outline" onClick={handleDisable} disabled={saving} className="w-full text-destructive hover:text-destructive">
+                  <Trash2 className="w-4 h-4 mr-2" /> Teilen beenden (Link ungültig machen)
+                </Button>
+              </>
+            )}
+
+            {error && <p className="text-sm text-red-600">{error}</p>}
+          </div>
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}

src/components/dialogs/text-dialog.tsx

@@ -1,6 +1,6 @@
 'use client'
 
-import { useState } from 'react'
+import { useState, useEffect } from 'react'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Label } from '@/components/ui/label'
@@ -23,6 +23,11 @@ export function TextDialog({ open, onOpenChange, onConfirm, selectedColor }: Tex
   const [text, setText] = useState('')
   const [fontSize, setFontSize] = useState(16)
 
+  // Beim Öffnen zurücksetzen — sonst erscheint beim nächsten Text der alte Inhalt
+  useEffect(() => {
+    if (open) { setText(''); setFontSize(16) }
+  }, [open])
+
   const handleConfirm = () => {
     if (text.trim()) {
       onConfirm(text.trim(), fontSize)

src/components/exercise/exercise-cockpit.tsx

@@ -4,6 +4,9 @@ import { useState, useEffect, useRef, useCallback } from 'react'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { useToast } from '@/components/ui/use-toast'
+import { getSocket } from '@/lib/socket'
+import { TableModule } from '@/components/journal/modules/table-module'
+import type { CockpitModule } from '@/lib/modules'
 import {
   GraduationCap,
   Plus,
@@ -15,6 +18,7 @@ import {
   Trash2,
   ClipboardCheck,
   Loader2,
+  Blocks,
 } from 'lucide-react'
 
 type GoalStatus = 'OPEN' | 'REACHED' | 'PARTIAL' | 'MISSED'
@@ -74,6 +78,24 @@ export function ExerciseCockpit({ projectId, projectTitle, canEdit, initialEvalu
   const evalDebounce = useRef<NodeJS.Timeout | null>(null)
   const { toast } = useToast()
 
+  // Modul-Baukasten: dieselben eigenen Tabellen-Module wie im Einsatz
+  const [tableModules, setTableModules] = useState<CockpitModule[]>([])
+  useEffect(() => {
+    fetch('/api/tenant/modules')
+      .then(r => r.ok ? r.json() : null)
+      .then(data => {
+        if (data?.modules) {
+          setTableModules(data.modules.filter((m: CockpitModule) => m.enabled && m.type === 'table' && m.columns?.length))
+        }
+      })
+      .catch(() => {})
+  }, [])
+
+  const notifyModuleChanged = useCallback(() => {
+    if (!projectId) return
+    try { getSocket().emit('journal-updated', { projectId }) } catch { /* offline */ }
+  }, [projectId])
+
   // Ziele laden
   const loadGoals = useCallback(async () => {
     if (!projectId) {
@@ -299,6 +321,19 @@ export function ExerciseCockpit({ projectId, projectTitle, canEdit, initialEvalu
           />
           <p className="text-xs text-muted-foreground mt-1">Wird automatisch gespeichert.</p>
         </section>
+
+        {/* Eigene Cockpit-Module (Modul-Baukasten) — z.B. Atemschutz, Kräfte vor Ort */}
+        {projectId && tableModules.map((mod) => (
+          <section key={mod.id}>
+            <h3 className="text-sm font-semibold flex items-center gap-2 mb-3 text-foreground/80">
+              <Blocks className="w-4 h-4 text-blue-600" />
+              {mod.name}
+            </h3>
+            <div className="border rounded-lg bg-white dark:bg-card overflow-hidden">
+              <TableModule projectId={projectId} module={mod} canEdit={canEdit} notifyChanged={notifyModuleChanged} />
+            </div>
+          </section>
+        ))}
       </div>
     </div>
   )

src/components/journal/module-manager-dialog.tsx

@@ -0,0 +1,319 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import {
+  Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter,
+} from '@/components/ui/dialog'
+import {
+  ArrowUp, ArrowDown, Plus, Trash2, Loader2, Blocks, X, Pencil, PanelLeft, Columns2, Check,
+} from 'lucide-react'
+import { MODULE_PRESETS, type CockpitModule, type ModuleColumn, type ModuleColumnType } from '@/lib/modules'
+
+interface ModuleManagerDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  modules: CockpitModule[]
+  /** Mandant, dessen Module gespeichert werden (Einsatz-Mandant; für SERVER_ADMIN relevant). */
+  tenantId?: string | null
+  onSaved: (modules: CockpitModule[]) => void
+}
+
+/**
+ * "Module verwalten" — der Baukasten:
+ * Module ein-/ausschalten, Reihenfolge ändern, eigene Tabellen-Module
+ * aus Vorlagen erstellen (Checkliste, Atemschutz, Kräfte, Lagemeldungen, leer).
+ * Gespeichert wird pro Mandant (gilt für alle Einsätze).
+ */
+export function ModuleManagerDialog({ open, onOpenChange, modules, tenantId, onSaved }: ModuleManagerDialogProps) {
+  const [working, setWorking] = useState<CockpitModule[]>(modules)
+  const [isSaving, setIsSaving] = useState(false)
+  const [error, setError] = useState('')
+
+  // Neues Modul aus Vorlage / Bearbeiten
+  const [showAdd, setShowAdd] = useState(false)
+  const [editId, setEditId] = useState<string | null>(null) // null = neu, sonst Modul-ID
+  const [presetKey, setPresetKey] = useState(MODULE_PRESETS[0].key)
+  const [newName, setNewName] = useState('')
+  const [newSlot, setNewSlot] = useState<'main' | 'side'>(MODULE_PRESETS[0].slot)
+  const [newColumns, setNewColumns] = useState<ModuleColumn[]>(MODULE_PRESETS[0].columns)
+
+  useEffect(() => {
+    if (open) {
+      setWorking(modules)
+      setError('')
+      setShowAdd(false)
+      setEditId(null)
+    }
+  }, [open, modules])
+
+  const move = (idx: number, dir: -1 | 1) => {
+    const next = [...working]
+    const target = idx + dir
+    if (target < 0 || target >= next.length) return
+    ;[next[idx], next[target]] = [next[target], next[idx]]
+    setWorking(next.map((m, i) => ({ ...m, sortOrder: i })))
+  }
+
+  const toggle = (idx: number) => {
+    setWorking(prev => prev.map((m, i) => i === idx ? { ...m, enabled: !m.enabled } : m))
+  }
+
+  const removeCustom = (idx: number) => {
+    setWorking(prev => prev.filter((_, i) => i !== idx).map((m, i) => ({ ...m, sortOrder: i })))
+  }
+
+  const selectPreset = (key: string) => {
+    const preset = MODULE_PRESETS.find(p => p.key === key)!
+    setPresetKey(key)
+    setNewName(preset.key === 'leer' ? '' : preset.name)
+    setNewSlot(preset.slot)
+    setNewColumns(preset.columns)
+  }
+
+  const openNew = () => {
+    setEditId(null)
+    selectPreset(MODULE_PRESETS[0].key)
+    setShowAdd(true)
+  }
+
+  const openEdit = (m: CockpitModule) => {
+    setEditId(m.id)
+    setNewName(m.name)
+    setNewSlot(m.slot)
+    const cols: ModuleColumn[] = m.columns && m.columns.length ? m.columns : [{ key: 'text', label: 'Text', type: 'text' }]
+    setNewColumns(cols.map(c => ({ ...c })))
+    setShowAdd(true)
+  }
+
+  const addModule = () => {
+    const preset = MODULE_PRESETS.find(p => p.key === presetKey)!
+    const name = newName.trim() || preset.name
+    const columns = newColumns.filter(c => c.label.trim())
+    if (columns.length === 0) return
+
+    if (editId) {
+      // Bestehendes Modul aktualisieren (Name/Slot/Spalten)
+      setWorking(prev => prev.map(m => m.id === editId ? { ...m, name, slot: newSlot, columns } : m))
+    } else {
+      const mod: CockpitModule = {
+        id: `custom-${Date.now().toString(36)}`,
+        type: 'table',
+        name,
+        icon: preset.icon,
+        slot: newSlot,
+        enabled: true,
+        sortOrder: working.length,
+        columns,
+      }
+      setWorking(prev => [...prev, mod])
+    }
+    setShowAdd(false)
+    setEditId(null)
+    setNewName('')
+  }
+
+  const updateColumn = (idx: number, patch: Partial<ModuleColumn>) => {
+    setNewColumns(prev => prev.map((c, i) => i === idx ? { ...c, ...patch } : c))
+  }
+
+  const addColumn = () => {
+    if (newColumns.length >= 8) return
+    setNewColumns(prev => [...prev, { key: `col${prev.length}-${Date.now().toString(36).slice(-4)}`, label: '', type: 'text' }])
+  }
+
+  const removeColumn = (idx: number) => {
+    setNewColumns(prev => prev.filter((_, i) => i !== idx))
+  }
+
+  const save = async () => {
+    setIsSaving(true)
+    setError('')
+    try {
+      const res = await fetch('/api/tenant/modules', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ modules: working, tenantId: tenantId || undefined }),
+      })
+      const data = await res.json()
+      if (!res.ok) throw new Error(data.error || 'Speichern fehlgeschlagen')
+      onSaved(data.modules)
+      onOpenChange(false)
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+    } finally {
+      setIsSaving(false)
+    }
+  }
+
+  const COLUMN_TYPES: { value: ModuleColumnType; label: string }[] = [
+    { value: 'text', label: 'Text' },
+    { value: 'number', label: 'Zahl' },
+    { value: 'check', label: 'Haken' },
+    { value: 'time', label: 'Zeit (auto)' },
+  ]
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-lg max-h-[85vh] overflow-y-auto">
+        <DialogHeader>
+          <DialogTitle className="flex items-center gap-2">
+            <Blocks className="w-5 h-5" />
+            Cockpit-Module verwalten
+          </DialogTitle>
+        </DialogHeader>
+
+        <p className="text-xs text-muted-foreground -mt-2">
+          Stelle das Einsatz-Cockpit für deine Feuerwehr zusammen. Gilt für alle Einsätze deiner Organisation.
+        </p>
+
+        {/* Modul-Liste */}
+        <div className="space-y-1.5">
+          {working.map((m, idx) => (
+            <div key={m.id} className={`flex items-center gap-2 rounded-lg border px-2.5 py-2 ${m.enabled ? 'bg-card' : 'bg-muted/40 opacity-60'}`}>
+              {/* An/aus */}
+              <button
+                onClick={() => toggle(idx)}
+                className={`relative w-9 h-5 rounded-full transition-colors shrink-0 ${m.enabled ? 'bg-green-500' : 'bg-muted-foreground/30'}`}
+                title={m.enabled ? 'Deaktivieren' : 'Aktivieren'}
+              >
+                <span className={`absolute top-0.5 w-4 h-4 rounded-full bg-white shadow transition-all ${m.enabled ? 'left-[18px]' : 'left-0.5'}`} />
+              </button>
+
+              <div className="flex-1 min-w-0">
+                <p className="text-sm font-medium truncate">{m.name}</p>
+                <p className="text-[10px] text-muted-foreground">
+                  {m.type === 'table' ? `Eigenes Modul · ${m.columns?.length || 0} Spalten` : 'Eingebaut'}
+                  {' · '}{m.slot === 'main' ? 'Hauptbereich' : 'Seitenspalte'}
+                </p>
+              </div>
+
+              <div className="flex items-center gap-0.5 shrink-0">
+                <button onClick={() => move(idx, -1)} disabled={idx === 0} className="p-1 text-muted-foreground hover:text-foreground disabled:opacity-30" title="Nach oben">
+                  <ArrowUp className="w-3.5 h-3.5" />
+                </button>
+                <button onClick={() => move(idx, 1)} disabled={idx === working.length - 1} className="p-1 text-muted-foreground hover:text-foreground disabled:opacity-30" title="Nach unten">
+                  <ArrowDown className="w-3.5 h-3.5" />
+                </button>
+                {m.type === 'table' && (
+                  <button onClick={() => openEdit(m)} className="p-1 text-muted-foreground hover:text-foreground" title="Modul bearbeiten">
+                    <Pencil className="w-3.5 h-3.5" />
+                  </button>
+                )}
+                {m.type === 'table' && (
+                  <button onClick={() => removeCustom(idx)} className="p-1 text-muted-foreground hover:text-destructive" title="Modul löschen (Daten bleiben in der DB)">
+                    <Trash2 className="w-3.5 h-3.5" />
+                  </button>
+                )}
+              </div>
+            </div>
+          ))}
+        </div>
+
+        {/* Neues Modul / Bearbeiten */}
+        {!showAdd ? (
+          <Button variant="outline" size="sm" onClick={openNew} className="w-full">
+            <Plus className="w-4 h-4 mr-1.5" /> Modul hinzufügen
+          </Button>
+        ) : (
+          <div className="rounded-lg border p-3 space-y-3 bg-muted/20">
+            <div className="flex items-center justify-between">
+              <p className="text-sm font-semibold">{editId ? 'Modul bearbeiten' : 'Neues Modul'}</p>
+              <button onClick={() => { setShowAdd(false); setEditId(null) }} className="text-muted-foreground hover:text-foreground"><X className="w-4 h-4" /></button>
+            </div>
+
+            {/* Vorlagen — nur beim Neuanlegen */}
+            {!editId && (
+              <div className="grid grid-cols-2 gap-1.5">
+                {MODULE_PRESETS.map(p => (
+                  <button
+                    key={p.key}
+                    onClick={() => selectPreset(p.key)}
+                    className={`text-left rounded-md border-2 px-2 py-1.5 transition-colors ${
+                      presetKey === p.key ? 'border-primary bg-primary/5' : 'border-border hover:border-muted-foreground'
+                    }`}
+                    title={p.description}
+                  >
+                    <p className="text-xs font-medium">{p.name}</p>
+                    <p className="text-[10px] text-muted-foreground line-clamp-1">{p.description}</p>
+                  </button>
+                ))}
+              </div>
+            )}
+
+            <div className="space-y-1.5">
+              <Label className="text-xs">Name</Label>
+              <Input value={newName} onChange={e => setNewName(e.target.value)} placeholder="z.B. Atemschutz Zug 1" className="h-8 text-sm" />
+            </div>
+
+            {/* Anzeige-Bereich (Slot) frei wählbar */}
+            <div className="space-y-1.5">
+              <Label className="text-xs">Anzeige</Label>
+              <div className="grid grid-cols-2 gap-1.5">
+                <button
+                  type="button"
+                  onClick={() => setNewSlot('main')}
+                  className={`flex items-center gap-1.5 rounded-md border-2 px-2 py-1.5 text-xs transition-colors ${newSlot === 'main' ? 'border-primary bg-primary/5' : 'border-border hover:border-muted-foreground'}`}
+                >
+                  <PanelLeft className="w-3.5 h-3.5" /> Hauptbereich (gross)
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setNewSlot('side')}
+                  className={`flex items-center gap-1.5 rounded-md border-2 px-2 py-1.5 text-xs transition-colors ${newSlot === 'side' ? 'border-primary bg-primary/5' : 'border-border hover:border-muted-foreground'}`}
+                >
+                  <Columns2 className="w-3.5 h-3.5" /> Seitenspalte
+                </button>
+              </div>
+            </div>
+
+            {/* Spalten-Editor */}
+            <div className="space-y-1.5">
+              <Label className="text-xs">Spalten</Label>
+              {newColumns.map((c, i) => (
+                <div key={c.key} className="flex items-center gap-1.5">
+                  <Input
+                    value={c.label}
+                    onChange={e => updateColumn(i, { label: e.target.value })}
+                    placeholder={`Spalte ${i + 1}`}
+                    className="h-7 text-xs flex-1"
+                  />
+                  <select
+                    value={c.type}
+                    onChange={e => updateColumn(i, { type: e.target.value as ModuleColumnType })}
+                    className="h-7 text-xs rounded-md border border-input bg-background px-1.5"
+                  >
+                    {COLUMN_TYPES.map(t => <option key={t.value} value={t.value}>{t.label}</option>)}
+                  </select>
+                  <button onClick={() => removeColumn(i)} disabled={newColumns.length <= 1} className="p-1 text-muted-foreground hover:text-destructive disabled:opacity-30">
+                    <Trash2 className="w-3.5 h-3.5" />
+                  </button>
+                </div>
+              ))}
+              {newColumns.length < 8 && (
+                <button onClick={addColumn} className="text-xs text-primary hover:underline flex items-center gap-1">
+                  <Plus className="w-3 h-3" /> Spalte hinzufügen
+                </button>
+              )}
+            </div>
+
+            <Button size="sm" onClick={addModule} disabled={newColumns.filter(c => c.label.trim()).length === 0} className="w-full">
+              {editId ? <><Check className="w-4 h-4 mr-1" /> Änderungen übernehmen</> : <><Plus className="w-4 h-4 mr-1" /> Modul erstellen</>}
+            </Button>
+          </div>
+        )}
+
+        {error && <p className="text-sm text-destructive">{error}</p>}
+
+        <DialogFooter className="gap-2">
+          <Button variant="outline" onClick={() => onOpenChange(false)} disabled={isSaving}>Abbrechen</Button>
+          <Button onClick={save} disabled={isSaving}>
+            {isSaving ? <><Loader2 className="w-4 h-4 mr-1.5 animate-spin" /> Speichern…</> : 'Speichern'}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

src/components/journal/modules/pendenzen-module.tsx

@@ -0,0 +1,108 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Plus, Trash2, Check } from 'lucide-react'
+import { type JournalPendenz, formatTime } from '@/components/journal/types'
+
+interface PendenzenModuleProps {
+  items: JournalPendenz[]
+  canEdit: boolean
+  onAdd: (what: string, who: string, whenHow: string) => void
+  onToggle: (p: JournalPendenz) => void
+  onDelete: (id: string) => void
+}
+
+/** Pendenzen — eingebautes Cockpit-Modul (Was/Wer/Wann mit Erledigt-Haken) */
+export function PendenzenModule({ items, canEdit, onAdd, onToggle, onDelete }: PendenzenModuleProps) {
+  const [what, setWhat] = useState('')
+  const [who, setWho] = useState('')
+  const [whenHow, setWhenHow] = useState('')
+
+  const submit = () => {
+    if (!what.trim()) return
+    onAdd(what.trim(), who.trim(), whenHow.trim())
+    setWhat('')
+    setWho('')
+    setWhenHow('')
+  }
+
+  return (
+    <>
+      {items.length === 0 ? (
+        <div className="text-center text-muted-foreground py-4 text-xs">
+          Keine Pendenzen
+        </div>
+      ) : (
+        <div className="divide-y divide-border/50">
+          {items.map((p) => (
+            <div key={p.id} className={`flex items-start gap-1.5 px-2 py-1.5 text-xs print:text-[9px] group ${p.done ? 'bg-green-50 dark:bg-green-950/20 print:bg-green-50' : ''}`}>
+              <button
+                onClick={() => canEdit && onToggle(p)}
+                className={`w-4 h-4 mt-0.5 rounded border-2 flex items-center justify-center shrink-0 transition-colors ${
+                  p.done
+                    ? 'bg-green-500 border-green-500 text-white'
+                    : 'border-muted-foreground/30 hover:border-primary'
+                }`}
+                disabled={!canEdit}
+              >
+                {p.done && <Check className="w-2.5 h-2.5" />}
+              </button>
+              <div className="flex-1 min-w-0">
+                <p className={`${p.done ? 'text-muted-foreground' : ''}`}>
+                  {p.what}
+                  {p.done && p.doneAt && (
+                    <span className="ml-1 text-green-600 text-[10px] print:text-[8px] font-medium no-underline">
+                      (erledigt um {formatTime(p.doneAt)})
+                    </span>
+                  )}
+                </p>
+                <div className="flex gap-2 text-[10px] text-muted-foreground">
+                  {p.who && <span>Wer: {p.who}</span>}
+                  {p.whenHow && <span>Wann: {p.whenHow}</span>}
+                </div>
+              </div>
+              {canEdit && (
+                <button
+                  onClick={() => onDelete(p.id)}
+                  className="opacity-0 group-hover:opacity-100 text-muted-foreground hover:text-destructive shrink-0 mt-0.5 print:hidden"
+                >
+                  <Trash2 className="w-3 h-3" />
+                </button>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+      {canEdit && (
+        <div className="border-t border-border p-1.5 print:hidden">
+          <div className="flex gap-1">
+            <Input
+              placeholder="Was..."
+              value={what}
+              onChange={(e) => setWhat(e.target.value)}
+              onKeyDown={(e) => e.key === 'Enter' && submit()}
+              className="flex-1 h-6 text-[11px]"
+            />
+            <Input
+              placeholder="Wer"
+              value={who}
+              onChange={(e) => setWho(e.target.value)}
+              className="w-14 h-6 text-[11px]"
+            />
+            <Input
+              placeholder="Wann"
+              value={whenHow}
+              onChange={(e) => setWhenHow(e.target.value)}
+              className="w-14 h-6 text-[11px]"
+            />
+            <Button size="sm" variant="ghost" onClick={submit} disabled={!what.trim()} className="h-6 px-1.5">
+              <Plus className="w-3 h-3" />
+            </Button>
+          </div>
+        </div>
+      )}
+    </>
+  )
+}

src/components/journal/modules/soma-module.tsx

@@ -0,0 +1,99 @@
+'use client'
+
+import { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Plus, Trash2, Check } from 'lucide-react'
+import { type JournalCheckItem, formatTime, formatDateTime } from '@/components/journal/types'
+
+interface SomaModuleProps {
+  items: JournalCheckItem[]
+  canEdit: boolean
+  onToggle: (item: JournalCheckItem, field: 'confirmed' | 'ok') => void
+  onAdd: (label: string) => void
+  onDelete: (itemId: string) => void
+}
+
+/** SOMA-Checkliste — eingebautes Cockpit-Modul (JA/Ok mit Zeitstempel) */
+export function SomaModule({ items, canEdit, onToggle, onAdd, onDelete }: SomaModuleProps) {
+  const [newLabel, setNewLabel] = useState('')
+
+  const submit = () => {
+    if (!newLabel.trim()) return
+    onAdd(newLabel.trim())
+    setNewLabel('')
+  }
+
+  return (
+    <>
+      {/* Spalten-Kopf */}
+      <div className="grid grid-cols-[1fr_28px_28px] print:grid-cols-[1fr_24px_24px] text-[10px] font-semibold text-muted-foreground border-b border-border/50">
+        <div className="px-2 py-1"></div>
+        <div className="px-0.5 py-1 text-center text-red-600">JA</div>
+        <div className="px-0.5 py-1 text-center text-red-500">Ok</div>
+      </div>
+      <div className="divide-y divide-border/50">
+        {items.map((item, idx) => (
+          <div key={item.id} className={`grid grid-cols-[1fr_28px_28px] print:grid-cols-[1fr_24px_24px] items-center text-xs md:text-sm print:text-[9px] group ${idx % 2 === 0 ? '' : 'bg-stone-50 dark:bg-muted/20'}`}>
+            <div className="px-2 py-1.5 flex items-center gap-1 min-w-0">
+              <span className="truncate">{item.label}</span>
+              {item.confirmedAt && item.confirmed && (
+                <span className="text-[9px] text-red-500 shrink-0">{formatTime(item.confirmedAt)}</span>
+              )}
+              {canEdit && (
+                <button
+                  onClick={() => onDelete(item.id)}
+                  className="ml-auto opacity-0 group-hover:opacity-100 text-muted-foreground hover:text-destructive shrink-0 print:hidden"
+                >
+                  <Trash2 className="w-3 h-3" />
+                </button>
+              )}
+            </div>
+            <div className="flex items-center justify-center py-1.5">
+              <button
+                onClick={() => canEdit && onToggle(item, 'confirmed')}
+                className={`w-5 h-5 rounded border-2 flex items-center justify-center transition-colors ${
+                  item.confirmed
+                    ? 'bg-blue-500 border-blue-500 text-white'
+                    : 'border-muted-foreground/30 hover:border-blue-400'
+                }`}
+                title={item.confirmedAt ? `JA: ${formatDateTime(item.confirmedAt)}` : 'JA'}
+                disabled={!canEdit}
+              >
+                {item.confirmed && <Check className="w-3 h-3" />}
+              </button>
+            </div>
+            <div className="flex items-center justify-center py-1.5">
+              <button
+                onClick={() => canEdit && onToggle(item, 'ok')}
+                className={`w-5 h-5 rounded border-2 flex items-center justify-center transition-colors ${
+                  item.ok
+                    ? 'bg-green-500 border-green-500 text-white'
+                    : 'border-muted-foreground/30 hover:border-green-400'
+                }`}
+                title={item.okAt ? `Ok: ${formatDateTime(item.okAt)}` : 'Ok'}
+                disabled={!canEdit}
+              >
+                {item.ok && <Check className="w-3 h-3" />}
+              </button>
+            </div>
+          </div>
+        ))}
+      </div>
+      {canEdit && (
+        <div className="flex gap-1 px-2 py-1.5 border-t border-border/50 print:hidden">
+          <Input
+            placeholder="Neuer Punkt..."
+            value={newLabel}
+            onChange={(e) => setNewLabel(e.target.value)}
+            onKeyDown={(e) => e.key === 'Enter' && submit()}
+            className="h-6 text-[11px]"
+          />
+          <Button size="sm" variant="ghost" onClick={submit} disabled={!newLabel.trim()} className="h-6 px-1.5">
+            <Plus className="w-3 h-3" />
+          </Button>
+        </div>
+      )}
+    </>
+  )
+}

src/components/journal/modules/table-module.tsx

@@ -0,0 +1,231 @@
+'use client'
+
+import { useState, useEffect, useCallback } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Plus, Trash2, Check, Loader2 } from 'lucide-react'
+import type { CockpitModule, ModuleColumn } from '@/lib/modules'
+
+interface ModuleItemRow {
+  id: string
+  data: Record<string, any>
+  createdAt: string
+}
+
+interface TableModuleProps {
+  projectId: string
+  module: CockpitModule
+  canEdit: boolean
+  /** Live-Sync: andere Clients über Änderung informieren */
+  notifyChanged: () => void
+}
+
+function formatTime(dateStr: string) {
+  return new Date(dateStr).toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })
+}
+
+/**
+ * Generisches Tabellen-Modul des Modul-Baukastens.
+ * Rendert beliebige Spalten (text / check / time) gemäss Modul-Konfiguration.
+ * Daten liegen als JSON-Zeilen in module_items (generische API).
+ */
+export function TableModule({ projectId, module, canEdit, notifyChanged }: TableModuleProps) {
+  const [items, setItems] = useState<ModuleItemRow[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [draft, setDraft] = useState<Record<string, string>>({})
+
+  const columns: ModuleColumn[] = module.columns || []
+  // Eingebbare Spalten: Text UND Zahl (Zeit = auto, Haken = Klick)
+  const textColumns = columns.filter(c => c.type === 'text' || c.type === 'number')
+
+  const load = useCallback(async () => {
+    try {
+      const res = await fetch(`/api/projects/${projectId}/modules/${module.id}/items`)
+      if (res.ok) {
+        const data = await res.json()
+        setItems(data.items || [])
+      }
+    } catch (err) {
+      console.error(`Failed to load module ${module.id}:`, err)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [projectId, module.id])
+
+  useEffect(() => { load() }, [load])
+
+  // Live-Refresh, wenn andere Clients Journal-Änderungen melden
+  useEffect(() => {
+    const onRefresh = () => load()
+    window.addEventListener('journal-refresh', onRefresh)
+    return () => window.removeEventListener('journal-refresh', onRefresh)
+  }, [load])
+
+  const addRow = useCallback(async () => {
+    const hasContent = textColumns.some(c => (draft[c.key] || '').trim())
+    if (!hasContent) return
+    const data: Record<string, any> = {}
+    for (const c of textColumns) {
+      const v = (draft[c.key] || '').trim()
+      if (v) data[c.key] = v
+    }
+    try {
+      const res = await fetch(`/api/projects/${projectId}/modules/${module.id}/items`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ data }),
+      })
+      if (res.ok) {
+        const item = await res.json()
+        setItems(prev => [...prev, item])
+        setDraft({})
+        notifyChanged()
+      }
+    } catch (err) {
+      console.error('Failed to add module item:', err)
+    }
+  }, [projectId, module.id, draft, textColumns, notifyChanged])
+
+  const toggleCheck = useCallback(async (item: ModuleItemRow, key: string) => {
+    if (!canEdit) return
+    const next = !item.data[key]
+    try {
+      const res = await fetch(`/api/projects/${projectId}/modules/${module.id}/items/${item.id}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ data: { [key]: next, [`${key}At`]: next ? new Date().toISOString() : null } }),
+      })
+      if (res.ok) {
+        const updated = await res.json()
+        setItems(prev => prev.map(i => i.id === updated.id ? updated : i))
+        notifyChanged()
+      }
+    } catch (err) {
+      console.error('Failed to toggle module item:', err)
+    }
+  }, [projectId, module.id, canEdit, notifyChanged])
+
+  const deleteRow = useCallback(async (itemId: string) => {
+    try {
+      await fetch(`/api/projects/${projectId}/modules/${module.id}/items/${itemId}`, { method: 'DELETE' })
+      setItems(prev => prev.filter(i => i.id !== itemId))
+      notifyChanged()
+    } catch (err) {
+      console.error('Failed to delete module item:', err)
+    }
+  }, [projectId, module.id, notifyChanged])
+
+  // Spaltenbreite ableiten — respektiert optionale Breiten-Hinweise (w-16 … w-32)
+  const WIDTH_MAP: Record<string, string> = { 'w-10': '40px', 'w-16': '68px', 'w-20': '92px', 'w-24': '108px', 'w-28': '124px', 'w-32': '140px' }
+  const colSize = (c: ModuleColumn): string => {
+    if (c.type === 'check') return '36px'
+    if (c.type === 'time') return '58px'
+    if (c.width && WIDTH_MAP[c.width]) return WIDTH_MAP[c.width]
+    if (c.type === 'number') return '96px'
+    return 'minmax(90px,1fr)'
+  }
+  // Grid-Template aus Spalten ableiten (+ Lösch-Spalte)
+  const gridCols = columns.map(colSize).join(' ') + (canEdit ? ' 28px' : '')
+
+  return (
+    <div>
+      {/* Spalten-Kopf */}
+      <div className="grid text-[10px] font-semibold text-muted-foreground border-b border-border/50" style={{ gridTemplateColumns: gridCols }}>
+        {columns.map(c => (
+          <div key={c.key} className={`px-1.5 py-1 truncate ${c.type !== 'text' ? 'text-center' : ''}`}>{c.label}</div>
+        ))}
+        {canEdit && <div />}
+      </div>
+
+      {isLoading ? (
+        <div className="flex items-center justify-center py-4 text-muted-foreground text-xs">
+          <Loader2 className="w-3.5 h-3.5 animate-spin mr-1.5" /> Laden…
+        </div>
+      ) : items.length === 0 ? (
+        <div className="text-center text-muted-foreground py-3 text-xs">Keine Einträge</div>
+      ) : (
+        <div className="divide-y divide-border/50">
+          {items.map((item, idx) => (
+            <div key={item.id} className={`grid items-center text-xs print:text-[9px] group ${idx % 2 === 0 ? '' : 'bg-stone-50 dark:bg-muted/20'}`} style={{ gridTemplateColumns: gridCols }}>
+              {columns.map(c => {
+                if (c.type === 'check') {
+                  const checked = !!item.data[c.key]
+                  const at = item.data[`${c.key}At`]
+                  return (
+                    <div key={c.key} className="flex items-center justify-center py-1.5">
+                      <button
+                        onClick={() => toggleCheck(item, c.key)}
+                        disabled={!canEdit}
+                        title={at ? `${c.label}: ${formatTime(at)}` : c.label}
+                        className={`w-5 h-5 rounded border-2 flex items-center justify-center transition-colors ${
+                          checked ? 'bg-green-500 border-green-500 text-white' : 'border-muted-foreground/30 hover:border-green-400'
+                        }`}
+                      >
+                        {checked && <Check className="w-3 h-3" />}
+                      </button>
+                    </div>
+                  )
+                }
+                if (c.type === 'time') {
+                  // Zeit-Spalte: automatisch = Erstellzeit (oder explizit gesetzter Wert)
+                  const t = item.data[c.key] || item.createdAt
+                  return (
+                    <div key={c.key} className="px-1.5 py-1.5 font-mono tabular-nums text-muted-foreground text-center text-[11px]">
+                      {t ? formatTime(t) : '–'}
+                    </div>
+                  )
+                }
+                if (c.type === 'number') {
+                  return (
+                    <div key={c.key} className="px-1.5 py-1.5 font-mono tabular-nums text-right min-w-0 truncate">
+                      {item.data[c.key] || <span className="text-muted-foreground">–</span>}
+                    </div>
+                  )
+                }
+                return (
+                  <div key={c.key} className="px-1.5 py-1.5 break-words min-w-0">
+                    {item.data[c.key] || <span className="text-muted-foreground">–</span>}
+                  </div>
+                )
+              })}
+              {canEdit && (
+                <button
+                  onClick={() => deleteRow(item.id)}
+                  className="opacity-0 group-hover:opacity-100 text-muted-foreground hover:text-destructive flex items-center justify-center print:hidden"
+                >
+                  <Trash2 className="w-3 h-3" />
+                </button>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {/* Neue Zeile — im selben Raster wie die Spalten, damit Eingaben unter den Titeln stehen */}
+      {canEdit && (
+        <div className="grid items-center gap-1 px-1.5 py-1.5 border-t border-border/50 print:hidden" style={{ gridTemplateColumns: gridCols }}>
+          {columns.map(c => {
+            if (c.type === 'text' || c.type === 'number') {
+              return (
+                <Input
+                  key={c.key}
+                  placeholder={c.label}
+                  inputMode={c.type === 'number' ? 'numeric' : undefined}
+                  value={draft[c.key] || ''}
+                  onChange={(e) => setDraft(prev => ({ ...prev, [c.key]: e.target.value }))}
+                  onKeyDown={(e) => e.key === 'Enter' && addRow()}
+                  className="h-6 text-[11px] min-w-0 px-1.5"
+                />
+              )
+            }
+            // Zeit/Haken: leere Zelle (wird automatisch/durch Klick gesetzt)
+            return <div key={c.key} className="text-center text-[10px] text-muted-foreground/50">{c.type === 'time' ? 'auto' : ''}</div>
+          })}
+          <Button size="sm" variant="ghost" onClick={addRow} disabled={!textColumns.some(c => (draft[c.key] || '').trim())} className="h-6 w-6 p-0 shrink-0">
+            <Plus className="w-3 h-3" />
+          </Button>
+        </div>
+      )}
+    </div>
+  )
+}

src/components/journal/rapport-dialog.tsx

@@ -235,6 +235,24 @@ export function RapportDialog({
               </div>
             </div>
           )}
+          {/* Eigene Cockpit-Module (read-only, aus dem Journal) */}
+          {Array.isArray(rapportForm.moduleTables) && rapportForm.moduleTables.filter((mt: any) => mt.rows?.length > 0).map((mt: any, i: number) => (
+            <div key={i}>
+              <label className="text-xs font-semibold text-muted-foreground uppercase">{mt.name}</label>
+              <div className="border rounded-md p-2 bg-muted text-sm max-h-32 overflow-auto">
+                {mt.rows.map((row: any, ri: number) => (
+                  <div key={ri} className="py-0.5 flex flex-wrap gap-x-3 text-xs">
+                    {(mt.columns || []).filter((c: any) => c.type !== 'time').map((c: any) => (
+                      <span key={c.key} className="text-muted-foreground">
+                        <span className="font-medium text-foreground">{c.label}:</span>{' '}
+                        {c.type === 'check' ? (row[c.key] ? '✓' : '—') : (row[c.key] || '—')}
+                      </span>
+                    ))}
+                  </div>
+                ))}
+              </div>
+            </div>
+          ))}
           {/* Bemerkungen */}
           <div>
             <label className="text-xs font-semibold text-muted-foreground uppercase">Bemerkungen</label>

src/components/journal/types.ts

@@ -0,0 +1,40 @@
+/** Gemeinsame Typen der Cockpit-Module */
+
+export interface JournalEntry {
+  id: string
+  time: string
+  what: string
+  who: string | null
+  done: boolean
+  doneAt: string | null
+  isCorrected?: boolean
+  correctionOfId?: string | null
+}
+
+export interface JournalCheckItem {
+  id: string
+  label: string
+  confirmed: boolean
+  confirmedAt: string | null
+  ok: boolean
+  okAt: string | null
+}
+
+export interface JournalPendenz {
+  id: string
+  what: string
+  who: string | null
+  whenHow: string | null
+  done: boolean
+  doneAt: string | null
+}
+
+export function formatTime(dateStr: string) {
+  return new Date(dateStr).toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })
+}
+
+export function formatDateTime(dateStr: string) {
+  const d = new Date(dateStr)
+  return d.toLocaleDateString('de-CH', { day: '2-digit', month: '2-digit' }) + ' ' +
+    d.toLocaleTimeString('de-CH', { hour: '2-digit', minute: '2-digit' })
+}

src/components/layout/left-toolbar.tsx

@@ -21,6 +21,7 @@ import {
   MoveRight,
   Ruler,
   Eraser,
+  AlertTriangle,
 } from 'lucide-react'
 import type { DrawMode } from '@/types'
 import { cn } from '@/lib/utils'
@@ -58,10 +59,17 @@ const drawTools: { mode: DrawMode; icon: typeof MousePointer2; label: string; sh
   { mode: 'freehand', icon: Pencil, label: 'Freihand', shortcut: 'F' },
   { mode: 'arrow', icon: MoveRight, label: 'Pfeil / Route', shortcut: 'A' },
   { mode: 'text', icon: Type, label: 'Text', shortcut: 'T' },
+  { mode: 'dangerzone', icon: AlertTriangle, label: 'Gefahrenzone', shortcut: 'D' },
   { mode: 'eraser', icon: Eraser, label: 'Radiergummi', shortcut: 'E' },
   { mode: 'measure', icon: Ruler, label: 'Messen', shortcut: 'M' },
 ]
 
+const widths = [
+  { value: 2, label: 'Dünn' },
+  { value: 4, label: 'Mittel' },
+  { value: 7, label: 'Dick' },
+]
+
 export function LeftToolbar({
   drawMode,
   onDrawModeChange,
@@ -75,8 +83,8 @@ export function LeftToolbar({
 }: LeftToolbarProps) {
   return (
     <TooltipProvider delayDuration={300}>
-      <aside className="w-14 lg:w-20 border-r border-border bg-card flex flex-col items-center py-1.5 lg:py-2 shrink-0 overflow-y-auto overflow-x-hidden z-10">
+      <aside data-tour="toolbar" className="w-14 lg:w-20 border-r border-border bg-card flex flex-col items-center py-1 lg:py-2 pb-3 shrink-0 overflow-y-auto overflow-x-hidden z-10">
-        {/* Draw Tools — Touch-Ziele mind. 44px auf Mobil/Tablet */}
+        {/* Draw Tools — Touch-Ziele gross genug für Finger */}
         <div className="flex flex-col gap-0.5">
           {drawTools.map((tool) => (
             <Tooltip key={tool.mode}>
@@ -84,7 +92,7 @@ export function LeftToolbar({
                 <Button
                   variant={drawMode === tool.mode ? 'default' : 'ghost'}
                   size="icon"
-                  className="w-11 h-11 lg:w-12 lg:h-12"
+                  className="w-11 h-10 lg:w-12 lg:h-12"
                   onClick={() => onDrawModeChange(tool.mode)}
                   disabled={!canEdit && tool.mode !== 'select'}
                 >
@@ -98,16 +106,16 @@ export function LeftToolbar({
           ))}
         </div>
 
-        <div className="w-8 lg:w-12 h-px bg-border my-1" />
+        <div className="w-8 lg:w-12 h-px bg-border my-0.5 lg:my-1" />
 
-        {/* Undo/Redo — mobil gestapelt (44px), Desktop 2-spaltig */}
+        {/* Undo/Redo — mobil gestapelt (flach), Desktop 2-spaltig */}
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-0.5">
           <Tooltip>
             <TooltipTrigger asChild>
               <Button
                 variant="ghost"
                 size="icon"
-                className="w-11 h-11 lg:w-8 lg:h-8"
+                className="w-11 h-9 lg:w-8 lg:h-8"
                 onClick={onUndo}
                 disabled={!canEdit}
               >
@@ -124,7 +132,7 @@ export function LeftToolbar({
               <Button
                 variant="ghost"
                 size="icon"
-                className="w-11 h-11 lg:w-8 lg:h-8"
+                className="w-11 h-9 lg:w-8 lg:h-8"
                 onClick={onRedo}
                 disabled={!canEdit}
               >
@@ -138,10 +146,10 @@ export function LeftToolbar({
 
         </div>
 
-        <div className="w-8 lg:w-12 h-px bg-border my-1" />
+        <div className="w-8 lg:w-12 h-px bg-border my-0.5 lg:my-1" />
 
         {/* Color Picker - 2-col grid, grössere Swatches für Touch */}
-        <div className="grid grid-cols-2 gap-1">
+        <div className="grid grid-cols-2 gap-1 shrink-0">
           {colors.map((color) => (
             <button
               key={color.value}
@@ -158,6 +166,30 @@ export function LeftToolbar({
             />
           ))}
         </div>
+
+        <div className="w-8 lg:w-12 h-px bg-border my-0.5 lg:my-1" />
+
+        {/* Linienstärke */}
+        <div className="flex flex-col gap-0.5 shrink-0">
+          {widths.map((w) => (
+            <button
+              key={w.value}
+              onClick={() => onWidthChange(w.value)}
+              disabled={!canEdit}
+              title={`Linienstärke: ${w.label}`}
+              className={cn(
+                'w-11 h-7 lg:w-12 lg:h-8 rounded-md flex items-center justify-center transition-colors',
+                selectedWidth === w.value ? 'bg-primary/15 ring-1 ring-primary' : 'hover:bg-accent',
+                !canEdit && 'opacity-50 cursor-not-allowed'
+              )}
+            >
+              <span
+                className="rounded-full bg-foreground"
+                style={{ width: '20px', height: `${w.value}px` }}
+              />
+            </button>
+          ))}
+        </div>
       </aside>
     </TooltipProvider>
   )