chore: Testversion 0.1.41

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.claude/settings.json

@@ -0,0 +1,17 @@
+{
+  "model": "claude-fable-5",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python -c \"import json,sys,datetime; d=json.load(sys.stdin); f=d.get('tool_input',{}).get('file_path','unknown'); t=d.get('tool_name','Edit'); ts=datetime.datetime.now().strftime('%Y-%m-%d %H:%M'); open('CHANGES.md','a').write(f'{ts} [{t}] {f}\\n')\" 2>/dev/null || true",
+            "statusMessage": "Dokumentation wird aktualisiert..."
+          }
+        ]
+      }
+    ]
+  }
+}

.gitignore

@@ -43,3 +43,9 @@ app.*.map.json
 /android/app/debug
 /android/app/profile
 /android/app/release
+autopilot.log
+.claude/worktrees/
+*.bak
+
+# Skript-Backups vor riskanten Aenderungen (bleiben lokal als Rollback)
+*.bak-*

ANTWORTEN_BERND.md

@@ -0,0 +1,42 @@
+# Bernds Entscheidungen – Richtungsfragen aus PROGRESS.md beantwortet
+
+Diese Datei beantwortet die über mehrere Sessions in PROGRESS.md gesammelten
+„Fragen an Bernd". Sie ist ab jetzt **maßgeblich** – die betroffenen Punkte in
+ROADMAP.md/PROGRESS.md gelten als entschieden.
+Zuletzt aktualisiert: **2026-07-05** (Bernd + Claude am PC).
+
+## 1. SQLCipher (lokale DB + Access-Token verschlüsseln) → VOR M2 priorisieren
+- **Entscheidung:** Ja. Die Verschlüsselung der lokalen `pyramid.sqlite` hat Vorrang
+  vor dem M2-Refactoring. Betrifft den M1-Punkt „Sichere Speicherung von Access-Token
+  & Krypto-DB".
+- Umsetzung nach `docs/SQLCIPHER_MIGRATION.md`. **Wichtig:** Die Migration bestehender
+  Klartext-DBs (Utas Gerät!) ist der riskante Teil und braucht einen echten
+  PC-/Gerätetest. Auf dem Pi (kein GUI) nur so weit vorbereiten, wie es OHNE GUI sicher
+  testbar ist; alles Verhaltensrelevante klar als UNGETESTET markieren und erst nach
+  `docs/PC_TESTPLAN.md` als erledigt abhaken. Grundsatz „Kein Datenverlust" – im Zweifel
+  für den PC-Termin liegen lassen.
+
+## 2. M2 – erstes Umbau-Modul → Call-Pilot zuerst
+- **Entscheidung:** Wenn M2 startet (nach SQLCipher), zuerst die Call-Schicht entwirren
+  (Call-Pilot / gemeinsame Fassade über `voip_manager.dart` + `livekit_call_manager.dart`),
+  wie in `docs/M2_MODULE_SCHNITT.md` vorgeschlagen. **Nicht** zuerst `settings_modal.dart`
+  aufsplitten.
+- **Wichtig:** heiliger Call-Pfad → braucht zwingend echten Call-Test auf einem Gerät.
+  Auf dem Pi nicht blind umbauen; Vorbereitung/Analyse ok, Umsetzung + Test am PC.
+
+## 3. Dashboard-Fernzugriff (stats.html) → Heimnetz-only lassen
+- **Entscheidung:** KEIN Fernzugriff. Das Interims-Gate (nur Heimnetz/localhost) bleibt so.
+  Die offene A/B-Frage (Cloudflare Access vs. DASH_TOKEN) aus
+  `docs/DASHBOARD_AUTH_HARDENING.md` ist damit **geschlossen** – nicht weiter daran
+  arbeiten. Unterwegs per WireGuard erreichbar.
+
+## 4. Git-History / Admin-Token → vorerst NICHTS tun
+- **Entscheidung:** Kein Git-History-Rewrite und aktuell keine Token-Rotation durch den
+  Autopilot. Der Admin-Token ist bereits aus dem App-Code heraus (eigener `DIAG_TOKEN`).
+  Eine spätere Rotation bleibt Bernds manuelle Sache – nicht eigenmächtig anstoßen.
+
+---
+
+**Kurzfassung fürs Arbeiten:** SQLCipher vor M2, dann Call-Pilot als erstes M2-Modul.
+Dashboard bleibt Heimnetz-only. History unangetastet. Riskante/GUI-relevante Teile
+warten auf den PC-Termin (`docs/PC_TESTPLAN.md`); auf dem Pi nur sicher Vorbereitbares.

CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+## [0.1.33+34] – 2026-06-11
+
+### Anrufe & Sprache
+- Anruf-Steuerung neu platziert: eigenes "Dock" über dem Konto-Balken (Discord-Stil) statt darin eingebettet; das doppelte Mini-Panel im Profilbereich wurde entfernt.
+- Alle Anrufe – auch Sprachkanäle – nutzen jetzt das vollwertige Mini-Call-Widget mit Mikrofon, Deafen, Kamera und Bildschirmübertragung.
+- Ein-/Ausblenden des Call-Docks animiert (220 ms).
+- Querformat-Optimierung: Stream-Vorschau schrumpft bei wenig Bildschirmhöhe (140 -> 84 px), damit die Raumliste nutzbar bleibt.
+- Ausgabelautstärke-Regler (0–150 %) in "Sprache & Video", wirkt sofort auf laufende Anrufe.
+- Geräteauswahl verdrahtet: Mikrofon/Lautsprecher/Kamera aus den Einstellungen werden jetzt tatsächlich auf Anrufe angewendet (vorher wurden die Einstellungen nirgends gelesen).
+- Ehrliche Fehlermeldung, wenn Windows-Audiotreiber keine Geräteliste an WebRTC melden (bekannter libwebrtc-Bug; Anrufe laufen trotzdem über das Standardgerät).
+- Bildschirmübertragungs-Picker passt sich kleinen Bildschirmen an.
+
+### Chat & Medien
+- Bilder werden nicht mehr abgeschnitten: Anpassung an die Chatbreite, kein Verzerren oder Hochskalieren mehr.
+- SVG-Inline-Vorschau im Chat (vorher als generische Datei oder fehlerhaft).
+- Video-Ladeplatzhalter passen sich der Breite an (keine festen 360 px).
+- Lesebestätigungen verbessert: goldener Doppelhaken, Zusammenführung von globalen und Thread-Bestätigungen, korrektes Verhalten wenn die andere Person antwortet/liest.
+- Drag-&-Drop-Overlay animiert (Scale + Fade + wippendes Icon, Akzent-Glow).
+- Anhang-Dialog öffnet mit Scale-Animation.
+- Tastatur-Zwischenablage (Android): frisch kopierte Bilder erscheinen in der Tastatur-Vorschlagsleiste und landen im Anhang-Dialog.
+- Banner-Wechsel: Absturz ("setState returned a Future") und Doppelanzeige behoben.
+
+### Profile & DMs
+- Aufklappbarer DM-Header: Klick auf Avatar/Name klappt das Profil auf – Banner als Hintergrund, Avatar skaliert mit (32 -> 96 px), Name wächst, Handle + Biographie blenden ein.
+- Profilbild-Bug beim schnellen DM-Wechsel behoben (kein Übersprechen mehr zwischen Kanälen).
+- Profil-Einstellungen laden sofort aus dem Cache, Server-Daten parallel im Hintergrund.
+- Persistenter Bild-Cache: Avatare und Banner sind nach Neustart sofort da statt nachzuladen.
+
+### Spaces & Berechtigungen
+- Selbst-Aussperr-Schutz: Berechtigungsänderungen werden gegen den echten Server-Stand gemischt (nie mehr den lokalen Cache überschreiben). Zusätzlich bricht Pyramid jede Änderung ab, die den eigenen Account aussperren würde.
+- Space-Banner überleben jetzt App-Neustarts (importantStateEvents).
+- Aussagekräftige Fehlerdiagnose bei abgelehnten Space-Änderungen.
+
+### Präsenz / Online-Status
+- Online wird nur noch angezeigt, wenn die letzte Aktivität < 5 Min. her ist (behebt "alle wirken online").
+- Präsenz-Heartbeat von 10 s auf 55 s reduziert (weniger Netzwerk/Akku).
+
+### Teilen
+- "Teilen nach Pyramid" (Android): Text und Dateien aus anderen Apps teilen, mit Raum-Picker (Suche + Vorschau).
+
+### Performance & Build
+- Inter-Schrift als Asset gebündelt (google_fonts entfernt) – offline-fähig, schnellerer Start.
+- Bilder laden zuerst als Thumbnail (spart Bandbreite, v. a. mobil).
+- 12 tote Quelldateien und ungenutzte Abhängigkeit dynamic_color entfernt.
+- Android-Release-Build: eigener Release-Keystore, R8/Minify + Resource-Shrinking, ProGuard-Keep-Regeln für WebRTC/LiveKit/Notifications.
+
+### Infrastruktur (Server)
+- Defekter Space "Just us serious" repariert: sauber dupliziert (gleicher Name/Topic/Avatar/Banner, alle 6 Kanäle, Admin-Rechte wiederhergestellt).
+
+### Hinweis zur Verteilung
+- Wegen des neuen Release-Keystores müssen bestehende (Debug-signierte) Android-Installationen einmalig deinstalliert und neu installiert werden – danach laufen Updates normal.

CLAUDE.md

@@ -0,0 +1,73 @@
+# Pyramid – Arbeitsregeln für Claude
+
+Pyramid ist Bernds eigener Matrix-Client (Flutter, kein FluffyChat-Fork). Bernd ist
+**kein Entwickler** – er gibt Ziele und Prioritäten vor, Claude trifft die technischen
+Entscheidungen und erklärt sie in einfachem Deutsch. Die App ist bei echten Nutzern im
+Einsatz (u. a. Uta) – Stabilität und Datensicherheit gehen vor Feature-Tempo.
+
+**Dies ist das einzige aktuelle Repo:** `C:\Users\nordm\pyramid - Kopie\`.
+(`C:\Users\nordm\pyramid` und `C:\Users\nordm\MatrixPi\pyramid` sind veraltete
+April-Schnappschüsse – dort NIE arbeiten.)
+
+> **Bernds Entscheidungen zu den offenen Richtungsfragen stehen in `ANTWORTEN_BERND.md`
+> (zuletzt 2026-07-05) – vor dem Abarbeiten von ROADMAP-Punkten lesen, sie sind maßgeblich.**
+
+## Infrastruktur
+
+- Homeserver: Continuwuity auf dem Pi5 (`steggi-matrix.work`)
+- LiveKit/TURN: Hetzner „Leuchtturm" → `wss://livekit.steggi-matrix.work` (API-Key LKMatrixPi), coturn 94.130.78.116:3478
+- Git-Remote: Gitea auf dem Pi (`http://192.168.178.71:3000/steggi/pyramid.git`) – Push = Backup
+- Push-Benachrichtigungen: FCM + Sygnal auf dem Pi (Memory „Pyramid Push" lesen, bevor daran gearbeitet wird)
+- Vollbackup vom 2026-07-03: `MatrixPi\backups\pyramid-kopie_backup_2026-07-03.tar.gz`
+
+## Arbeitszyklus (IMMER einhalten)
+
+Jede Session – egal ob frisch gestartet oder fortgesetzt – läuft so:
+
+1. **Einlesen:** `PROGRESS.md` (letzter Stand, Stolperfallen) und `ROADMAP.md`
+   (nächster offener Punkt) lesen. NIE Arbeit doppelt machen, die dort als erledigt steht.
+2. **Einen Punkt nehmen:** den obersten nicht abgehakten Punkt des aktuellen Meilensteins
+   aus `ROADMAP.md` – nicht mehrere gleichzeitig, keine Sprünge in spätere Meilensteine.
+3. **Umsetzen & prüfen:** Nach der Änderung mindestens `flutter analyze` sauber bekommen;
+   wo sinnvoll `flutter test` und `flutter run -d windows` (schnellster Praxistest).
+4. **Protokollieren:** `PROGRESS.md` aktualisieren (Format siehe dort) und den Punkt in
+   `ROADMAP.md` abhaken.
+5. **Commit + Push:** kleiner `git commit` (`feat:`/`fix:`/`refactor:`/`chore:`) und
+   `git push origin master` (Gitea = Backup). Lieber 5 kleine Commits als ein riesiger.
+6. Weiter mit dem nächsten Punkt, solange Kontingent/Zeit da ist.
+
+Wird eine Session mitten in einem Punkt abgebrochen (Limit erreicht), MUSS der letzte
+Eintrag in `PROGRESS.md` den Zwischenstand beschreiben: was halb fertig ist, welche
+Dateien angefasst wurden, was der nächste konkrete Handgriff ist.
+
+## Qualitätsleitplanken
+
+- **Kein Aussperren, kein Datenverlust:** Alles rund um Login, Sessions, Verschlüsselung
+  und Key-Backup ist heilig. Der Uta-Random-Logout-Bug zeigt: Fehlerpfade dürfen NIE in
+  einem stillen Logout enden. Änderungen daran immer mit Test: Login → Nachrichten →
+  Logout → erneuter Login → alte verschlüsselte Nachrichten noch lesbar?
+- **Nach dem Refactoring (M2) gilt:** keine Verhaltensänderung ohne Not – Refactoring
+  heißt gleiche Funktion, bessere Struktur. Nach jedem Refactoring-Schritt App starten
+  und Kernflows prüfen (Login, Raum öffnen, Nachricht senden, Voice-Channel beitreten).
+- **Keine Secrets ins Repo:** Tokens, Recovery-Keys, Passwörter, Keystore-Dateien
+  niemals committen (Signing-Keys liegen in `Documents\pyramid_keys_20260425.txt`).
+- **Modularität (Bernd wichtig!):** Die Architektur muss aus austauschbaren Bausteinen
+  bestehen – jedes Feature (Calls, Streaming, Push, Chat-Timeline, …) hinter einer klaren,
+  schmalen Schnittstelle, sodass man einen alten Baustein durch einen neuen ersetzen kann,
+  ohne den Rest anzufassen. Beim Refactoring (M2) ist das DAS Leitprinzip; bei jedem neuen
+  Feature fragen: „Könnte man dieses Modul in einem Jahr komplett neu schreiben, ohne
+  andere Module zu ändern?"
+- **Abhängigkeiten:** neue Pakete nur mit gutem Grund, etabliert und gepflegt.
+- **Umgebung beachten:** Auf dem Pi (SSH/tmux-Sessions) ist evtl. kein Flutter-Toolchain
+  verfügbar. Dann trotzdem sauber arbeiten, aber jeden Schritt in PROGRESS.md als
+  „UNGETESTET (Pi)" markieren – der nächste PC-Lauf holt `flutter analyze` + Praxistest nach.
+- **Bernd fragen** nur bei echten Richtungsentscheidungen (UX-Geschmack, Priorität) –
+  Fragen in PROGRESS.md unter „Fragen an Bernd" sammeln statt die Session zu blockieren.
+
+## Nützliches Wissen
+
+- Discord ist die UX-Referenz für Calls/Voice-Channels (Join/Leave, Nutzer-Lautstärke,
+  Geräteauswahl, Noise Suppression, Streaming-Qualitätswahl).
+- `CHANGES.md` ist ein automatisches Änderungslog (Hook) – nicht von Hand pflegen.
+- Windows-Build ist der schnellste Testweg; Android-Release über das Release-Skript
+  (siehe Commit d706ace), signiert – Play-Protect-Warnung siehe ROADMAP M6.

PROTOKOLL.md

@@ -0,0 +1,386 @@
+# Pyramid – Entwicklungsprotokoll
+Stand: 24.04.2026
+
+---
+
+## Projektübersicht
+
+**Pyramid** ist ein Flutter-basierter Matrix-Client, modelliert nach einem FluffyChat-Fork,
+mit zwei parallelen Call-Systemen:
+
+| System | Einsatz | Datei |
+|--------|---------|-------|
+| **LiveKit** (`livekit_client`) | Gruppen-Sprachräume | `lib/core/livekit_call_manager.dart` |
+| **Matrix VoIP** (`matrix` SDK) | 1:1 Direktnachrichten | `lib/core/voip_manager.dart` |
+
+Server-Infrastruktur läuft auf einem Raspberry Pi (`steggi-matrix.work`), LiveKit unter
+`livekit.steggi-matrix.work`.
+
+---
+
+## Erledigte Änderungen
+
+### 1. LiveKit – Qualitäts-Bugs behoben (`livekit_call_manager.dart`)
+
+**Problem:** Streamer und Zuschauer konnten die Übertragungsqualität nicht ändern.
+
+**Ursachen:**
+- `_screenShareEncoding()` hatte einen hardcodierten `switch ('balanced')` — gab immer
+  halbe Bitrate zurück, unabhängig vom eingestellten Qualitäts-Key.
+- `setSubscribeQuality('auto')` sprang vorzeitig raus und setzte die Qualität nie.
+
+**Fix:**
+```dart
+VideoEncoding _screenShareEncoding() {
+  return _screenShareEncodings[_localQualityKey] ??
+      const VideoEncoding(maxBitrate: 1_500_000, maxFramerate: 15);
+}
+```
+`setSubscribeQuality` wendet jetzt immer die Qualität an, auch bei 'auto'.
+
+---
+
+### 2. LiveKit – Track-Events lösen UI-Rebuild aus (`livekit_call_manager.dart`)
+
+**Problem:** Kamera-Feed wurde nach dem Publishen nicht angezeigt, weil kein Widget-Rebuild ausgelöst wurde.
+
+**Fix:** Handler für alle Track-Events hinzugefügt:
+```dart
+..on<LocalTrackPublishedEvent>((_) => notifyListeners())
+..on<TrackPublishedEvent>((_) => notifyListeners())
+..on<TrackUnpublishedEvent>((_) => notifyListeners())
+..on<TrackSubscribedEvent>((_) => notifyListeners())
+..on<TrackUnsubscribedEvent>((_) => notifyListeners())
+..on<ParticipantConnectedEvent>((_) => notifyListeners())
+..on<ParticipantDisconnectedEvent>((_) => notifyListeners())
+```
+
+---
+
+### 3. LiveKit – Optimistic Mute (`livekit_call_manager.dart`)
+
+**Problem:** Mute-Button hatte eine spürbare Verzögerung (async API-Call).
+
+**Fix:** `notifyListeners()` wird jetzt vor dem `await` aufgerufen:
+```dart
+Future<void> toggleMute() async {
+  isMuted = !isMuted;
+  notifyListeners(); // Sofort
+  await _room?.localParticipant?.setMicrophoneEnabled(!isMuted);
+}
+```
+
+---
+
+### 4. VoIP – Kamera-Fix (`voip_manager.dart`)
+
+**Problem:** Kamera-Tracks wurden nicht korrekt zugewiesen, weil der Renderer bereits belegt
+wurde bevor Video-Daten verfügbar waren.
+
+**Fix:**
+- Track-Zuweisung erfolgt jetzt erst wenn `getVideoTracks().isNotEmpty` — kein Renderer-Update
+  auf leere Streams mehr.
+- `_isCameraMuted` wird bei eingehenden Calls korrekt aus dem Call-Typ gesetzt:
+  `_isCameraMuted = call.type == CallType.kVoice;`
+- Bei `kConnected`-State wird `setLocalVideoMuted(false)` nochmals aufgerufen falls Kamera
+  aktiv sein soll.
+- Poll-Intervall von 1500ms auf 1000ms reduziert für schnellere Feed-Erkennung.
+
+---
+
+### 5. VoIP – Optimistic Mic/Camera Toggle (`voip_manager.dart`)
+
+**Problem:** `toggleMic()` und `toggleCamera()` nutzten `safeAction()` mit 1500ms Delay.
+
+**Fix:**
+- `toggleMic()` flippt State sofort, reverted bei Fehler automatisch.
+- `toggleCamera()` flippt `_isCameraMuted` sofort (optimistic), ruft `_updateRenderers()`
+  mehrfach nach kurzen Delays auf.
+
+---
+
+### 6. VoIP – Desktop Speakerphone Fix (`voip_manager.dart`)
+
+**Problem:** `MissingPluginException: No implementation found for method enableSpeakerphone`
+auf Windows/Desktop.
+
+**Fix:** Speakerphone-Callback wird im Konstruktor unterdrückt:
+```dart
+try {
+  (voip as dynamic).onConfigSpeakerphone = (bool _) async {};
+} catch (_) {}
+```
+
+---
+
+### 7. SQLite-Stabilität auf Windows
+
+**Problem:** Sporadische "Database is locked"-Fehler durch parallele Zugriffe.
+
+**Fix:** WAL-Modus aktiviert und `busy_timeout` gesetzt, um Locking-Konflikte zu verhindern.
+
+---
+
+### 8. Einheitliches Call-UI (`voice_channel.dart`) – Kompletter Rewrite
+
+Die gesamte `voice_channel.dart` wurde neu strukturiert mit einer einheitlichen Architektur
+für LiveKit und VoIP.
+
+#### 8a. Unified Participant Model
+
+```dart
+class _ParticipantData {
+  final String id, name;
+  final Widget? videoWidget;
+  final bool isSpeaking, isMuted, hasVideo, isScreenShare;
+  final Color avatarColor;
+  final dynamic originalParticipant;
+}
+```
+
+#### 8b. Adaptive Seitenverhältnisse (`voice_channel.dart`)
+
+**Problem:** Video-Tiles waren auf `AspectRatio(16/9)` festgelegt — Hochkant-Videos vom
+Handy wurden stark beschnitten und falsch dargestellt.
+
+**Fix:**
+- `_ParticipantData` bekommt ein `aspectRatio`-Feld (Default `16.0/9.0`).
+- VoIP: echte Dimension aus `RTCVideoRenderer.videoWidth/videoHeight` ausgelesen.
+- LiveKit: echte Dimension aus `(videoTrack as dynamic).currentDimensions` ausgelesen.
+- Alle Renderer nutzen `VideoViewFit.contain` / `RTCVideoViewObjectFitContain` statt `cover`
+  — kein Beschnitt mehr.
+- `_ParticipantGrid` wechselt von `GridView(childAspectRatio: 16/9)` zu `Wrap` mit
+  individuell berechneter `SizedBox(width, height)` pro Tile.
+- `_ParticipantStrip` passt Tile-Breite an: `101 * p.aspectRatio` für Landscape-Tiles.
+
+#### 8c. Hero/Spotlight-System
+
+- **Auto-Spotlight:** Screenshares werden automatisch als Hero angezeigt
+- **Manuelles Pinnen:** Klick auf Tile → wird Hero; erneuter Klick = unpin
+- Gear-Icon im Hero-Overlay öffnet das Qualitätsmenü (hover-reveal)
+- Fullscreen-Button öffnet eine eigene Fullscreen-Seite via `Navigator.push`
+
+#### 8d. Aktive Sprecher
+
+Pulsierende Rahmen-Animation (`AnimationController`) für Teilnehmer, die gerade sprechen.
+
+#### 8e. Teilnehmer-Sortierung
+
+```
+Screensharer → Kamera-an → Sprechend → Audio-only
+```
+
+#### 8f. Responsive Layouts
+
+**Portrait:** Hero oben (Expanded) + horizontaler Teilnehmer-Strip unten (120px)
+**Landscape:** Hero links (Expanded) + vertikale Sidebar rechts (200px)
+
+Beide Layouts sind **einklappbar** (Swipe-Geste + Pfeil-Button).
+
+#### 8g. Zentrales Mirroring
+
+`_MirrorWrapper` spiegelt nur die eigene Kamera (`isLocal && !isScreenShare`).
+Screenshares und Remote-Teilnehmer bleiben ungespiegelt.
+
+#### 8h. Grid-Layout mit einheitlichen Tiles
+
+`SliverGridDelegateWithFixedCrossAxisCount`:
+- < 600px → 2 Spalten
+- 600–900px → 3 Spalten
+- > 900px → 4 Spalten
+
+#### 8i. Steuerungs-Reihenfolge (alle Views)
+
+```
+[ Mic ] [ Deaf ] [ Kamera ] [ Screen ] | [ Auflegen ]
+```
+
+---
+
+### 9. Mini-Call-Widget – Steuerungs-Reihenfolge (`mini_call_widget.dart`)
+
+Gleiche Reihenfolge wie Haupt-Call-Ansicht: Mic → Deaf → Kamera → Screen.
+
+---
+
+### 10. 4K Support
+
+4K (2160p) als Qualitätsoption in LiveKit- und VoIP-Qualitätsmenüs hinzugefügt.
+
+---
+
+### 11. App-Icon – Pyramid-Logo (`flutter_launcher_icons.yaml`)
+
+**Problem:** App zeigte das Flutter-Standard-Icon statt dem Pyramid-Logo.
+
+**Fix:**
+- `flutter_launcher_icons.yaml` auf `assets/logo.png` (goldene 3D-Pyramide, 1024px) umgestellt.
+- macOS-Generierung explizit aktiviert (`macos: generate: true`).
+- Windows ICO nach `dart run flutter_launcher_icons` mit Pillow neu generiert
+  (16/32/48/64/128/256px multi-size ICO, verhindert das 48px-Limit des Packages).
+
+---
+
+### 12. Lade-Animation – 3D Pyramiden-Painter (`pyramid_loader.dart`)
+
+**Problem:** Lottie-JSON zeigte inkorrekte Farben, SVG wurde nur statisch gerendert
+(flutter_svg führt kein JavaScript aus).
+
+**Lösung:** JavaScript-Animations-Logik aus dem Original-SVG exakt nach Dart portiert
+als `CustomPainter`:
+
+- `_ease(t, exp)`: kubische Ease-In/Out wie im JS-Original
+- `_yawAt(t)`: Yaw-Rotation mit Hold-Phase (80% Rotation, 20% Pause bei π/4)
+- `_PyramidPainter`: 4 Flächen, Y-Rotation, Z-Clipping, orthografische Projektion,
+  20°-Tilt, Depth-Sorting (Painter's Algorithm)
+- Fill: `darken(accent, 0.45)`, Stroke: `accent`, strokeWidth: `1.4 * (size/96)`
+- `useLottie: false` ist nun der Standard — kein Lottie-Asset mehr nötig
+
+**Loader Preview** in den Appearance Settings (zwei 120px-Boxen: Custom Painter + Lottie-Fallback).
+
+---
+
+### 13. Chat-Scroll-Stabilisierung (`chat_view.dart`)
+
+**Problem:** Der Chat zuckte und zitterte je weiter man nach oben scrollte, besonders
+wenn neue History nachgeladen wurde.
+
+**Ursache:** `DateDivider` und `MessageGroup` waren in einem gemeinsamen `Column`-Widget
+mit einem einzigen Key zusammengefasst. Wenn beim Nachladen von History die `showDate`-
+Eigenschaft einer Gruppe sich änderte (z.B. weil sie nicht mehr die älteste Gruppe war),
+änderte sich die Höhe des Items — direkt in dem Bereich, den der User gerade betrachtete.
+
+**Fix:**
+- `DateDivider` und `MessageGroup` sind jetzt separate List-Items mit unabhängigen Keys:
+  - Gruppen: `ValueKey('g:<firstEventId>')`
+  - Datumstrennlinien: `ValueKey('d:<YYYY-MM-DD>')`
+- `findChildIndexCallback` nutzt eine vorberechnete `Map<String, int>` für O(1)-Lookup
+  statt O(n)-`indexWhere`.
+- 200ms Cooldown nach `requestHistory` verhindert sofortige Re-Trigger durch veraltetes
+  `maxScrollExtent`.
+
+---
+
+### 14. Startup-Flash Fix (`app.dart`)
+
+**Problem:** Beim App-Start flackerte kurz die Server-Eingabe-Seite auf, bevor der
+korrekte Redirect zu `/app` stattfand.
+
+**Ursache:** `isLoggedInProvider` (StreamProvider) gibt beim ersten Build `AsyncLoading`
+zurück. `valueOrNull ?? false` ergibt `false` → Router leitet sofort zu `/server` weiter.
+Kurz danach resolvet der Stream und der Router erstellt sich neu mit `isLoggedIn = true`.
+
+**Fix:** `PyramidApp` prüft `isLoggedInProvider` zuerst. Solange noch `isLoading`:
+vollbild `PyramidLoader` statt Router — die Pyramiden-Animation überbrückt den kurzen
+Moment, bis der Auth-State bekannt ist.
+
+---
+
+### 15. Eigenes Profilbild (`user_panel.dart`)
+
+**Problem:** Das eigene Profilbild wurde unten links (UserPanel) nicht angezeigt —
+nur ein Farbverlauf-Platzhalter mit Initial-Buchstabe.
+
+**Fix:**
+- `_ownProfileProvider` (FutureProvider): ruft einmalig `client.getProfileFromUserId(userID)`
+  auf und cached das Ergebnis.
+- `UserPanel` zeigt nun `MxcAvatar` mit dem echten Profilbild.
+- Anzeigename kommt aus `profile.displayName` statt nur aus der UserID.
+- Farbverlauf-Initial-Avatar bleibt als Fallback (`_InitialAvatar`) während des Ladens
+  oder wenn kein Bild gesetzt ist.
+
+---
+
+### 16. QR-Code-Verifikation (`app_shell.dart`, `settings_modal.dart`)
+
+**Problem:** Geräteverifikation unterstützte nur Emoji-SAS — kein QR-Code-Flow.
+
+**Fix:**
+- `KeyVerificationMethod.qrShow` zu `verificationMethods` in `matrix_client.dart` hinzugefügt.
+- `pubspec.yaml`: `pretty_qr_code: ^3.6.0` und `qr: ^3.0.2` ergänzt.
+- Eingehender Verifizierungsdialog (`app_shell.dart`) und ausgehender Dialog (`settings_modal.dart`)
+  unterstützen jetzt beide 3 neue States:
+  - `askChoice` → Methodenwahl (Emoji oder QR)
+  - `confirmQRScan` → QR-Code anzeigen (`QrCode.fromUint8List` + `PrettyQrView`) + "Gescannt bestätigen"-Button
+  - `showQRSuccess` → Erfolgsanzeige
+
+**Technischer Hinweis:** Matrix QR-Codes sind Binärdaten (`qrDataRawBytes: Uint8Buffer`).
+Rendering über `QrCode.fromUint8List(data: rawBytes, errorCorrectLevel: QrErrorCorrectLevel.L)`.
+
+---
+
+### 17. Wiederherstellungsschlüssel ändern (`settings_modal.dart`)
+
+**Problem:** Kein Feature zum Wechseln des SSSS-Wiederherstellungsschlüssels vorhanden.
+
+**Implementierung:** `_ChangeRecoveryKeyDialog` mit Bootstrap-State-Machine:
+
+**Flow:**
+1. **Laden** — Bootstrap startet, `wipeSsss(true)` → `newSsss()` generiert neuen Schlüssel
+2. **Schlüssel anzeigen** — Schlüssel selektierbar + Kopier-Button; wartet auf Nutzer
+3. **Bestätigen** — Nutzer tippt Schlüssel zur Bestätigung ein (`_ConfirmKeyBody`)
+4. **Aktivieren** — wartet auf Bootstrap `done` (Cross-Signing + Key Backup im Hintergrund)
+5. **Fertig** — Erfolgsmeldung
+
+**Kritischer Fix (BootstrapBadStateException):**
+- `newSsss()` ruft intern `checkCrossSigning()` auf → State geht sofort zu `askWipeCrossSigning`.
+- `openExistingSsss()` ist nach `newSsss()` nicht mehr erreichbar — wurde entfernt.
+- Alle Post-`newSsss`-States werden ohne `_step`-Guards auto-advanced.
+- Bootstrap-`done` setzt `_step` nur wenn bereits in `applying` — verhindert vorzeitigen Dialog-Schluss.
+
+---
+
+## Offene Punkte
+
+### ⚠️ Screenshare auf Windows (LiveKit)
+
+`startScreenShare()` wählt auf Windows automatisch die erste verfügbare Screen-Source.
+Der `ScreenSharePicker` ist implementiert, muss noch verifiziert werden.
+
+### ℹ️ Profilbilder in Chats – Lazy Loading
+
+Profilbilder in der Raumliste und im Chat werden erst beim Öffnen des jeweiligen
+Raums geladen (kein Preloading). Ist akzeptables Verhalten, kein Fehler.
+
+### 📋 Noch nicht implementiert (Settings)
+
+~~Alle erledigt in Sitzung 3 (26.04.2026): Gerät umbenennen, Alle anderen Sitzungen abmelden, Ed25519-Fingerabdruck, Blockierte Nutzer, Passwort ändern, Konto löschen, Logout-Button~~
+
+### 💡 Nice-to-have
+
+- **QR-Express-Login** (MSC4108): Desktop zeigt QR → Handy scannt → eingeloggt + verifiziert.
+  Voraussetzung: Rendezvous-Server + SDK-Unterstützung (matrix-dart-sdk ≥ 7.x erwartet).
+  Aktuell blockiert durch fehlende SDK-API in 6.2.0.
+
+---
+
+## Geänderte Dateien (vollständig)
+
+| Datei | Inhalt |
+|-------|--------|
+| `lib/core/livekit_call_manager.dart` | Quality-Bug-Fix, Track-Events, Optimistic Mute, 4K |
+| `lib/core/voip_manager.dart` | Kamera-Fix, Optimistic Toggle, Speakerphone-Fix, 4K |
+| `lib/features/call/voice_channel.dart` | Kompletter Rewrite: Unified Architecture, adaptive AR, Hero, Mirroring, Grid, Sortierung, Controls |
+| `lib/features/call/mini_call_widget.dart` | Steuerungs-Reihenfolge |
+| `lib/core/matrix_client.dart` | WAL-Modus, busy_timeout, qrShow in verificationMethods |
+| `lib/widgets/pyramid_loader.dart` | 3D CustomPainter (JS-Port), useLottie=false Standard |
+| `lib/core/app.dart` | Startup-Flash-Fix: PyramidLoader während isLoggedInProvider lädt |
+| `lib/features/chat/chat_view.dart` | Scroll-Stabilisierung: flache Item-Liste, O(1)-Lookup, Cooldown |
+| `lib/features/rooms/user_panel.dart` | Eigenes Profilbild via _ownProfileProvider + MxcAvatar |
+| `lib/widgets/settings_modal.dart` | QR-Verifikation, Wiederherstellungsschlüssel ändern, Loader-Preview |
+| `lib/layout/app_shell.dart` | QR-Verifikation im eingehenden Verifizierungsdialog |
+| `pubspec.yaml` | pretty_qr_code, qr hinzugefügt |
+| `flutter_launcher_icons.yaml` | Pyramid-Logo für alle Plattformen |
+| `windows/runner/resources/app_icon.ico` | Multi-Size ICO (16/32/48/64/128/256px) via Pillow |
+| `assets/logo.png` | Pyramid-Logo (1024px) |
+| `assets/pyramid-loader.json` | Lottie-Fallback (aus Ordner mit Leerzeichen verschoben) |
+
+---
+
+## Backups
+
+| Datum | Pfad |
+|-------|------|
+| 24.04.2026 (Sitzung 1) | `E:\pyramid_backup_20260424` |
+| 24.04.2026 (Sitzung 2) | `E:\pyramid_backup_20260424_2` |
+| 26.04.2026 | `E:\pyramid_backup_20260426` |

README.md

@@ -1,17 +1,58 @@
-# pyramid
+# Pyramid
 
-A new Flutter project.
+Pyramid ist ein eigenständiger Matrix-Client (Flutter), kein Fork von FluffyChat
+oder Element. Er läuft gegen den selbst gehosteten Homeserver `steggi-matrix.work`
+(Continuwuity) und ist bei echten Nutzern im Einsatz – Stabilität und
+Datensicherheit haben Vorrang vor Feature-Tempo.
 
-## Getting Started
+## Funktionsumfang
 
-This project is a starting point for a Flutter application.
+- Matrix-Chat mit Timeline, Reply, Medien, Link-Vorschauen, lokaler Volltextsuche
+  über entschlüsselte Nachrichten (server-seitige Suche funktioniert bei E2EE nicht)
+- Ende-zu-Ende-Verschlüsselung (vodozemac/Olm/Megolm) inkl. Key-Backup
+- Sprach-/Video-Calls und Bildschirmübertragung über LiveKit
+  (`wss://livekit.steggi-matrix.work`)
+- Push-Benachrichtigungen mit clientseitiger Entschlüsselung auch bei gekillter
+  App (FCM + Sygnal, siehe `docs/NOTIFICATIONS.md`)
+- Größenverstellbares Panel-Layout (Rooms/Chat/Members) statt starrer Tabs
 
-A few resources to get you started if this is your first Flutter project:
+## Build
 
-- [Learn Flutter](https://docs.flutter.dev/get-started/learn-flutter)
-- [Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
-- [Flutter learning resources](https://docs.flutter.dev/reference/learning-resources)
+Voraussetzung: Flutter (stable channel, siehe `environment.sdk` in `pubspec.yaml`
+für die unterstützte Dart-Version).
 
-For help getting started with Flutter development, view the
-[online documentation](https://docs.flutter.dev/), which offers tutorials,
-samples, guidance on mobile development, and a full API reference.
+```
+flutter pub get
+flutter run -d windows   # schnellster Praxistest während der Entwicklung
+flutter analyze          # muss sauber bleiben
+pwsh scripts/test.ps1    # Analyse + Tests (-Live, -Bench, -All: siehe docs/TESTS_UND_BENCHMARKS.md)
+```
+
+Unterstützte Zielplattformen: Android, Windows, Linux, iOS, macOS (Ordner
+`android/`, `windows/`, `linux/`, `ios/`, `macos/` sind Standard-Flutter-Projekte).
+Release-Build (signiert, Windows + Android): `scripts/release.ps1`.
+
+## Projektstruktur
+
+```
+lib/
+  core/        Matrix-Client, Auth, VoIP-Manager, Storage, App-State
+  features/
+    auth/      Login, Server-Auswahl
+    rooms/     Raumliste, Spaces
+    chat/      Timeline, Composer, Medien, Dokumentenvorschau
+    call/      LiveKit-Calls, Voice-Channel, Mini-Call-Widget
+    members/   Mitgliederliste/-panel
+    settings/  Einstellungen
+  layout/      Panel-Layout (resizable)
+  widgets/     geteilte UI-Bausteine
+  utils/       Hilfsfunktionen
+```
+
+## Weiterführende Dokumentation
+
+- `CLAUDE.md` – Arbeitsregeln und Infrastruktur für die Zusammenarbeit mit Claude
+- `ROADMAP.md` / `PROGRESS.md` – aktueller Stand und nächste Schritte
+- `docs/TESTS_UND_BENCHMARKS.md` – Tests, Live-Tests, Benchmarks (ein Befehl)
+- `docs/NOTIFICATIONS.md` – Push-Architektur (native Anzeige vs. Hintergrund-Entschlüsselung)
+- `docs/matrix-sdk/` – Hinweise zum verwendeten Matrix-SDK

ROADMAP.md

@@ -0,0 +1,397 @@
+# Pyramid – Roadmap
+
+Die lange Liste. Wird von oben nach unten abgearbeitet (Arbeitszyklus siehe `CLAUDE.md`).
+Reihenfolge = Priorität: erst Ordnung & Sicherheit (Datenverlust-Risiken!), dann das
+große Refactoring, dann Calls/Streaming/Chat-Features, dann Feinschliff.
+Punkte abhaken (`[x]`), wenn erledigt UND in `PROGRESS.md` protokolliert.
+
+## M0 – Backup & Ordnung
+
+- [x] Vollbackup vor dem Refactoring (2026-07-03 → `MatrixPi\backups\pyramid-kopie_backup_2026-07-03.tar.gz`)
+- [x] Die ~140 uncommitteten Dateien sichten, in thematische Commits aufteilen, zu Gitea pushen
+      (Sicherungs-Commit 25ed765 + Folge-Commits bis 74d38fd; Arbeitsbaum ist jetzt sauber)
+- [x] `flutter analyze` komplett sauber bekommen und sauber halten (nur noch 1 bewusst
+      zurückgestellter Hinweis, siehe PROGRESS.md 2026-07-03)
+- [x] `lib/features/call/` vs. `lib/features/calls/` (leer?) klären – Leiche entfernen
+      (geprüft: `calls/` existiert nicht mehr, nur `call/` mit den echten Dateien)
+- [x] README.md durch echte Projektbeschreibung ersetzt (74d38fd)
+- [x] **Fable-5-Qualitäts-Review aller bisherigen Autopilot-Commits (Bernds Wunsch, VOR allem anderen):**
+      ERLEDIGT – siehe Abschnitt „Fable-5-Review" oben in PROGRESS.md.
+      (a) alle 6 Gott-Datei-Aufteilungen unabhängig verifiziert (Zeilen-Multiset,
+      part-Bezüge): korrekt, verlorene Erklärkommentare waren mit f9979e4 schon
+      wiederhergestellt; (b) Uta-Logout-/Push-Fix gegen matrix-SDK 6.2.0
+      verifiziert: Analyse richtig, Lücke (SDK eskaliert Refresh-Fehler zu
+      logout()+clear()) war mit 891f348 (onSoftLogout-Guard) geschlossen, Guard
+      heute gegenverifiziert; (c) Lint-Fixes verhaltensäquivalent (onReorderItem
+      gegen Flutter-SDK geprüft, kein Off-by-One); (d) abgehakte Punkte stimmen
+      mit dem Code überein. Alles weiterhin UNGETESTET (Pi) → PC-Praxistest bleibt.
+
+- [x] **Uta-Random-Logout untersuchen:** UNGETESTET (Pi) – Ursache im matrix-SDK
+      gefunden + Fix committet (63e4919, 9dc83f7), siehe PROGRESS.md 2026-07-03.
+      Nächster PC-Lauf MUSS den vollen Kreislauf praktisch prüfen (Login →
+      Nachrichten → Logout → erneuter Login → alte Nachrichten lesbar?), erst
+      dann gilt der Punkt als wirklich erledigt.
+- [x] **REGRESSION: Push-Benachrichtigungen werden nicht mehr entschlüsselt** –
+      UNGETESTET (Pi), sehr wahrscheinlich DIESELBE Ursache wie der
+      Uta-Random-Logout-Bug (bereits mit 9dc83f7 mitgefixt), siehe PROGRESS.md
+      2026-07-03. Auf echtem Gerät prüfen: nach Neu-Login (für den Refresh-Token)
+      eine Weile laufen lassen und beobachten, ob Push-Nachrichten wieder mit
+      echtem Text statt nur „Neue Nachricht"-Platzhalter ankommen. Falls das
+      Problem weiterhin auftritt, liegt eine zweite, unabhängige Ursache vor
+      (z. B. fehlende Megolm-Schlüssel/Key-Sharing) – dann `docs/NOTIFICATIONS.md`
+      + Memory „Pyramid Push" erneut konsultieren und die dort gelisteten 3
+      Fallstricke der Hintergrund-Entschlüsselung gegenprüfen.
+- [ ] **Sichere Speicherung von Access-Token & Krypto-DB: LÜCKE GEFUNDEN.**
+      **Stand 2026-07-06: UMGESETZT + auf Windows praxisgetestet** – neue
+      Storage-Fassade `lib/core/app_database.dart` (SQLCipher auf
+      Android/Windows/Linux, Schlüssel im Keystore, Klartext-Migration mit
+      Backup/Verifikation/atomarem Tausch, Push-Isolate-Marker). Bernds echte
+      Windows-DB wurde erfolgreich migriert (PROGRESS.md 2026-07-06), Tests in
+      `test/app_database_test.dart` fahren die Migration mit echtem SQLCipher.
+      **Nachtrag 2026-07-06 (vierte PC-Session): Android-EMULATOR-Test grün**
+      (API 36: Neuanlage verschlüsselt, Klartext-Migration beim ersten Start,
+      Neustart mit Keystore-Schlüssel ohne Re-Migration – Details im
+      Status-Kopf von `docs/SQLCIPHER_MIGRATION.md`).
+      **Nachtrag 2026-07-06 (Nacht-Session): LIVE-E2E-Test mit ECHTEM Login grün**
+      (`test/live_encryption_e2e_test.dart`, Test-Account pyramidtest1 auf
+      steggi-matrix.work, Gate `PYRAMID_LIVE_TEST=1`): Platte nach echtem
+      Login/Nachricht byte-geprüft (kein SQLite-Header, Access-Token und
+      Nachrichtentext NICHT im Klartext auffindbar, Positiv-Kontrolle in
+      Klartext-DB findet beides), Neustart restauriert Session aus der
+      verschlüsselten DB, Logout→Re-Login→alte Nachricht lesbar, und die
+      Klartext-Migration mit einer ECHTEN eingeloggten Session erhält
+      Session+Daten. **Bleibt offen:**
+      echtes ARM-Gerät mit eingeloggter Session + Push-Isolate-Test
+      (FCM liest verschlüsselte DB, secure_storage im Background-Isolate) –
+      Testplan Punkt 4 in `docs/SQLCIPHER_MIGRATION.md`;
+      erst nach grünem Gerätetest Release + Utas Gerät (vorher ihr Key-Backup
+      prüfen!), dann abhaken.
+      `sqlcipher_flutter_libs` steht zwar in `pubspec.yaml`, wird aber nirgends
+      benutzt – `matrix_client.dart` und `background_push.dart` öffnen die
+      `pyramid.sqlite` (Access-Token, gepickelter Olm-Account, Nachrichten) über
+      den normalen `sqflite`/`sqflite_common_ffi`-Factory, also **unverschlüsselt**
+      auf der Platte. Bewusst NICHT blind auf dem Pi gefixt: eine Umstellung auf
+      SQLCipher braucht eine Migration für bereits bestehende Klartext-DBs
+      (Utas Gerät!) – ohne Testgerät hier zu riskant für „Kein Datenverlust".
+      Siehe PROGRESS.md 2026-07-03 + Frage an Bernd. **Umsetzungsplan liegt
+      fertig in `docs/SQLCIPHER_MIGRATION.md`** (2026-07-03, gegen Code und
+      SDK verifiziert) – PC-Termin kann direkt damit starten.
+- [x] Key-Backup einrichten-Flow: bereits vorhanden (`bootstrap_dialog.dart`,
+      wird automatisch getriggert wenn Cross-Signing fehlt, `app_shell.dart`)
+- [x] Key-Backup wiederherstellen-Flow: bereits vorhanden (`bootstrap_dialog.dart`,
+      `BootstrapState.askUnlockSsss` fragt nach Recovery-Key auf neuem Gerät)
+- [x] Logout-Schutz: Warnung mit Klartext-Folgen, wenn Key-Backup fehlt (b5762ea)
+- [x] Geräte-/Sessionverwaltung in den Einstellungen: bereits vorhanden
+      (`_SessionsSection` in `settings_modal.dart` – Liste, Umbenennen, Verifizieren
+      per SAS/QR, Abmelden, Massen-Abmeldung mit Passwort-Reauth)
+- [x] **SICHERHEIT: Dashboard-Admin-Endpoints – ERLEDIGT: Loch geschlossen,
+      Heimnetz-only ist laut Bernd der Endzustand** (Fable-5-Review (o);
+      Entscheidung `ANTWORTEN_BERND.md` Nr. 3, 2026-07-05).
+      `server.py` nimmt `/api/ban`, `/api/unban`, `/api/toggle-registration`,
+      `/api/create-invite`, `/api/run-stats` jetzt NUR noch aus Heimnetz/localhost an
+      (Socket-IP + Cloudflare-Header-Check); Fremde aus dem Internet bekommen 403.
+      Headless verifiziert (öffentlich 403, Heimnetz ok, App-Endpoints unverändert),
+      siehe PROGRESS.md 2026-07-04. **Bernds Dashboard läuft im Heimnetz unverändert:
+      `http://192.168.178.71:8080/stats.html`.** Offen bleibt: Will Bernd die
+      Admin-Buttons auch von unterwegs? Dann Weg A (Cloudflare Access, empfohlen –
+      schließt auch die weiterhin öffentliche Nutzerlisten-Ansicht) oder Weg B
+      (`DASH_TOKEN`), Plan + Restrisiken in `docs/DASHBOARD_AUTH_HARDENING.md`.
+      Zusatz (Fable-5-Review (p), 2026-07-04): `server.py` läuft jetzt multithreaded
+      mit 30-s-Socket-Timeout – ein einzelner langsamer Client kann den Server
+      (und damit `/api/livekit-token`) nicht mehr blockieren; headless verifiziert.
+      Zusatz (Fable-5-Review (q), 2026-07-04): Der durch (p) eingeführte
+      Nebenläufigkeits-Race in den Admin-Routen (Read-Modify-Write auf `conduit.toml`,
+      `send_admin`-Readback) ist mit `ADMIN_LOCK` geschlossen, das NUR die
+      Admin-Mutationen serialisiert – die öffentlichen Routen bleiben nebenläufig;
+      headless verifiziert (2× parallel = 2× Laufzeit, öffentlicher Pfad 11 ms).
+      Zusatz (Fable-5-Review (r), 2026-07-04): drei Restbefunde gefixt –
+      `registration-status`-Leser jetzt unter ADMIN_LOCK (Truncate-Write-Race),
+      negative/übergroße `Content-Length` überall abgelehnt (kein Thread-Hänger,
+      ban/unban 4-KB-Deckel), Einladungs-Token per `secrets` statt `random`.
+      Zusatz (Fable-5-Review (s), 2026-07-04): ban/unban-Body wird jetzt VOR dem
+      ADMIN_LOCK gelesen (hängender Body-Read konnte den Lock 30 s festhalten),
+      und die öffentlichen Routen antworten bei internen Fehlern generisch statt
+      mit Exception-Text (Info-Leak); Details ins Journal. Headless verifiziert.
+      Zusatz (Fable-5-Review (t), 2026-07-04): auch der öffentliche GET-Leser
+      `registration-status` antwortet bei internen Fehlern jetzt generisch
+      statt mit `str(e)` (hätte den `conduit.toml`-Pfad geleakt); headless
+      verifiziert inkl. 500-Beweis.
+      Zusatz (Fable-5-Review (u), 2026-07-04): (t)-Fix gegengelesen – korrekt,
+      kein Befund; die server.py-Härtungskette ist damit KONVERGIERT (alle
+      verbliebenen `str(e)`-Antworten LAN-gegated, absichtlich).
+      **Abschluss (2026-07-05, `ANTWORTEN_BERND.md` Nr. 3): KEIN Fernzugriff
+      gewünscht – die A/B-Frage ist GESCHLOSSEN, das Heimnetz-Gate ist der
+      Endzustand (unterwegs nutzt Bernd WireGuard). Die Restrisiken des Gates
+      (öffentliche Nutzerlisten-Ansicht, theoretisches LAN-CSRF) sind bewusst
+      akzeptiert und in `docs/DASHBOARD_AUTH_HARDENING.md` dokumentiert.
+      Nicht weiter daran arbeiten.**
+- [x] **LiveKit-Token-Route server-seitig gebaut + verifiziert** (Fable-5-Review (n),
+      PROGRESS.md 2026-07-04). `POST /api/livekit-token` läuft live in `server.py`
+      (whoami-Auth, stdlib-HS256-Minting aus `livekit.yaml`), headless geprüft
+      (401/400/413/200, JWT-Signatur unabhängig gegen `livekit.yaml` gültig, Identität =
+      geprüfte user_id). **Client umgestellt 2026-10-07 (756486d):** kein Secret
+      mehr in der App, echter LiveKit-Beitritt mit Testkonto grün
+      (`integration_test/livekit_token_connect_test.dart`). **Offen:** Anruftest
+      auf dem Handy, danach Secret-Rotation durch Bernd (erst wenn alle Geräte die
+      neue Version haben), siehe `docs/LIVEKIT_TOKEN_MIGRATION.md`.
+- [ ] **SICHERHEIT: geleakte Secrets rotieren + aus dem Client holen** (Fable-5-Review (k),
+      PROGRESS.md 2026-07-04). Das Gitea-Repo ist öffentlich (`private:false`), und es lagen
+      vier aktive Secrets drin – teils schon bereinigt (release.ps1, Admin-Doku), aber:
+      - **Rotieren (Pflicht, sie sind bereits geleakt):** Matrix-Server-Admin-Token
+        `J5lax…` (noch gültig, voller Admin!), Gitea-Release-Token, LiveKit-`apiKey`/
+        `apiSecret`, Giphy-Key. Alte jeweils widerrufen.
+      - **LiveKit-Token server-seitig minten:** kleiner Token-Endpoint auf dem Pi, damit
+        `apiSecret` aus `lib/core/livekit_token.dart` verschwindet (App holt nur das JWT).
+        **Client-Teil ERLEDIGT 2026-10-07** (Secret aus dem Code; Rotation steht noch aus).
+        **Umsetzungsplan liegt fertig in `docs/LIVEKIT_TOKEN_MIGRATION.md`** (2026-07-04,
+        gegen Code + Pi-Konfig geschrieben) – braucht echten Call-Test auf einem Gerät.
+      - **E2EE-Diagnose-Upload: ERLEDIGT (2026-07-04).** Der Dashboard-Server auf dem Pi
+        (`/home/steggi/matrix/server.py`) benutzte für `/api/e2ee-diagnostics` denselben
+        String wie den Matrix-Admin-Token – deshalb steckte er im Client. Jetzt hat das
+        Diagnose-Endpoint einen eigenen, eng begrenzten Token (`DIAG_TOKEN`, hängt nur an
+        den Log an, keine Admin-Rechte); `settings_encryption.dart` benutzt diesen. Der
+        **Admin-Token ist damit nicht mehr im App-Code** (per `grep` bestätigt). Server +
+        Client umgestellt und verifiziert (neuer Token 200, alter Admin-Token 403). Der
+        Admin-Token selbst muss trotzdem noch rotiert werden (steht oben, Bernds Sache).
+      - Optional: Git-History-Rewrite (Bernds Entscheidung, Repo ist auch Backup).
+      - **Stand 2026-07-05 (`ANTWORTEN_BERND.md` Nr. 4): Rotation und
+        History-Rewrite ruhen BEWUSST – beides bleibt Bernds manuelle Sache,
+        NICHT vom Autopilot anstoßen oder nachfragen. Der Punkt bleibt nur als
+        Merkposten offen; Autopilot-bearbeitbar ist hier nichts mehr.**
+      - **ACHTUNG bei „Repo einfach privat schalten":** Der In-App-Updater
+        (`lib/core/update_checker.dart`) holt Releases **anonym** über die öffentliche
+        Gitea-API (`/api/v1/repos/steggi/pyramid/releases`). Repo privat = Utas App
+        findet keine Updates mehr (und ein Fix ließe sich nicht mehr per Update
+        verteilen – Henne-Ei). Erst Updater-Strategie klären, dann Sichtbarkeit ändern.
+- [x] **Android-Backup/Geräteumzug abgeschaltet** (2026-10-07): ohne
+      `allowBackup=false` + `dataExtractionRules` wäre die SQLCipher-DB beim
+      Handywechsel ohne ihren Keystore-Schlüssel mitgezogen → App startet
+      nicht (Aussperr-Fall), und der Push-Zugangsschlüssel aus den
+      SharedPreferences läge im Cloud-Backup. Neues Gerät = neu anmelden +
+      Schlüssel per Wiederherstellungsschlüssel. Im APK geprüft (aapt2,
+      `dumpsys package`: kein ALLOW_BACKUP mehr).
+- [ ] Härtetest dokumentieren: Login → Nachrichten → Logout → Login neu → alles noch lesbar
+      (gehört zum ausstehenden PC-Praxistest der beiden Bugfixes oben;
+      kompletter Ablauf inkl. aller aufgelaufenen UNGETESTET-Punkte steht
+      jetzt in `docs/PC_TESTPLAN.md` – dort abarbeiten und abhaken)
+      **Teilstand 2026-07-06 (Autopilot, siehe PC_TESTPLAN):** flutter test
+      grün (29), Session über 3 Starts + DB-Migration stabil eingeloggt,
+      E2EE-Empfang live belegt, auth_log unauffällig; App läuft seit 12:43
+      für die Langzeit-Beobachtung weiter. **Offen (Klick/Bernd):**
+      Senden, Logout-Warnung, Re-Login mit Lesbarkeits-Check.
+- [x] **SDK-Wettlauf: verspätete 401 einer alten Sync-Anfrage löscht ggf. die
+      NEUE Session** – ERLEDIGT 2026-10-07: alle App-Abmeldungen laufen über
+      `logoutWithoutStraySync` (lib/core/session_logout.dart: Sync anhalten,
+      Long-Poll per Account-Daten wecken, auslaufen lassen, dann abmelden).
+      Live gemessen (test/live_logout_race_test.dart): die verspätete 401 tritt
+      real auf, kam aber in allen Läufen an, BEVOR die Neuanmeldung fertig
+      war – reales Risiko in der App klein (Neuanmeldung binnen ~1 s nötig),
+      jetzt ausgeschlossen; Regressionstest in `scripts/test.ps1 -Live`.
+      Ursprüngliche Analyse: (gefunden 2026-10-07 über einen sporadisch roten
+      Live-Test, siehe PROGRESS.md). matrix 6.2 `Client._innerSync` wirft den
+      Fehler einer Sync-Antwort, BEVOR geprüft wird, ob die Anfrage noch
+      aktuell ist (`_currentSyncId`). Läuft beim Logout noch ein Long-Poll
+      (bis 30 s) mit dem alten Token, kommt dessen M_UNKNOWN_TOKEN danach an
+      und das SDK ruft `clear()` – nach einem schnellen Re-Login auf
+      demselben Client wäre das ein „Random-Logout" direkt nach dem Login.
+      Upstream (famedly/matrix-dart-sdk `main`, 2026-10-07) unverändert;
+      neuere SDKs versuchen bei vorhandenem Refresh-Token aber zuerst einen
+      Refresh statt `clear()` (entschärft). Im Live-Test per
+      `_logoutWithoutStraySync` umgangen. **Offen:** App-Logout-Pfad prüfen
+      (läuft der Re-Login auf demselben Client-Objekt? dann vor
+      `client.logout()` Sync anhalten + laufenden Long-Poll abwarten) –
+      heiliger Pfad, nur mit Gerätetest; ggf. Upstream-Issue melden.
+
+## M2 – Das große Refactoring (erst nach M0/M1!)
+
+Ziel: gleiche Funktionen, saubere **modulare** Struktur – als Fundament für alles Folgende.
+Leitprinzip (Bernd): austauschbare Bausteine – jedes Modul muss sich komplett neu schreiben
+lassen, ohne dass andere Module angefasst werden müssen.
+
+- [x] Ist-Analyse geschrieben (PROGRESS.md 2026-07-03): Gott-Datei `settings_modal.dart`
+      (5541 Zeilen/50+ Klassen), Call-Schicht ohne gemeinsame Fassade (4 Module
+      importieren `voice_channel.dart` direkt), `app_state.dart` als Kopplungspunkt
+      aller Features, keine gemeinsame Storage-Schnittstelle (12 direkte
+      `SharedPreferences`-Zugriffe), toter Code (`message_bubble.dart`) + Duplikate
+      (`_formatTime`/`_formatDate` 3-fach). 8 Modul-Kandidaten dokumentiert.
+- [x] Modul-Schnitt definiert (`docs/M2_MODULE_SCHNITT.md`, PROGRESS.md 2026-07-03):
+      „Calls" ist architektonisch zwei getrennte Module (`call_signaling` =
+      Matrix-1:1-VoIP, `voice_channel` = LiveKit-SFU-Kanäle) + `call_ui`;
+      außerdem `settings` (aufgesplittet), `verification` (neu, aus Settings
+      herausgelöst), `storage` (Ausbau `settings_prefs.dart`), `auth`, `push`,
+      `chat_timeline`/`rooms`. Umsetzungsreihenfolge vorgeschlagen, wartet auf
+      Bernds Go für den Call-Pilot (Frage in PROGRESS.md).
+- [ ] Call-Schicht entwirren: EINE klare Zuständigkeit pro Klasse (Signalisierung /
+      LiveKit-Verbindung / UI-State sauber getrennt)
+      **Teilschritt erledigt (2026-07-06, M2-Pilot laut Entscheidung 2):**
+      Module `call_signaling` und `voice_channel` mit Fassaden-Interfaces +
+      Providern existieren (`lib/features/call_signaling/`,
+      `lib/features/voice_channel/`), alle Konsumenten gehen nur noch über
+      `callSignalingProvider`/`voiceChannelProvider` – kein UI-Import der
+      Implementierungen mehr (Details/Abweichungen: Status-Kopf in
+      `docs/M2_MODULE_SCHNITT.md`). App startet, 29 Tests grün, Sync/E2EE
+      laufen. **UNGETESTET:** echter 1:1-Call und Voice-Channel-Join per
+      Klick (braucht Gerät bzw. interaktiven Test) – deshalb nicht abgehakt.
+      **Weitere Teilschritte erledigt (2026-07-06, zweite PC-Session):**
+      `call_ui` ist jetzt ein eigenes Modul (`lib/features/call_ui/`,
+      b2335da) und die voice_*-Prefs laufen über die `VoicePrefs`-Fassade
+      in `core/settings_prefs.dart` statt direktem SharedPreferences-Zugriff
+      (d22f9c2) – beides verhaltensgleich, analyze/Tests grün, App-Start
+      geprüft. **Bewusst zurückgestellt bis Bernds Klick-Test des Piloten
+      (PC_TESTPLAN Abschnitt 8) grün ist:** UI-State aus den Managern
+      herauslösen – kein zweiter ungetesteter Logik-Umbau auf dem heiligen
+      Call-Pfad.
+- [ ] Einheitliches State-Management (Riverpod konsequent, keine Misch-Patterns)
+      **Ist-Analyse + Umbauplan liegen in `docs/M2_STATE_MANAGEMENT.md`**
+      (2026-07-06): Riverpod ist schon dominant (~50 Provider); 4
+      Misch-Patterns identifiziert, Schrittfolge definiert. Schritte 1–2
+      (Call-Manager-UI-State, Voice-Provider-Umzug) GESPERRT bis Bernds
+      Klick-Test (PC_TESTPLAN Abschnitt 8); MediaCache-Umstellung
+      zurückgestellt (hängt an der Chat-Timeline, Korrektur im Doc).
+      Push bleibt bewusst wie er ist (Isolate-Zwang). Toter
+      `incomingCallProvider` bereits entfernt (41bcaf2).
+- [x] Toten Code & Duplikate entfernen, Ordnerstruktur vereinheitlichen
+      (PROGRESS.md 2026-07-03: `message_bubble.dart` tot entfernt, doppelte
+      `_formatTime` in `message_group.dart` zusammengeführt; alle 6 in der
+      Ist-Analyse gefundenen Gott-Dateien per `part`/`part of` in
+      thematische Dateien aufgeteilt – `widgets/settings_modal.dart`
+      (5541→270 Zeilen, 12 Teile unter `widgets/settings/`),
+      `features/chat/message_group.dart` (2775→30 Zeilen, 7 Teile unter
+      `features/chat/message/`), `features/rooms/rooms_panel.dart`
+      (2555→31 Zeilen, 8 Teile unter `features/rooms/panel/`),
+      `features/spaces/space_admin_dialog.dart` (2278→19 Zeilen, 6 Teile
+      unter `features/spaces/admin/`), `features/chat/chat_view.dart`
+      (2116→33 Zeilen, 6 Teile unter `features/chat/view/`),
+      `features/chat/document_viewer.dart` (1773→20 Zeilen, 5 Teile unter
+      `features/chat/document/`) – jeweils verifiziert per automatisiertem
+      Blockvergleich gegen das Original und `flutter analyze`, siehe
+      PROGRESS.md-Einträge. `features/call/voice_channel.dart` (1123 Zeilen)
+      und `layout/app_shell.dart` (1073 Zeilen) waren zunächst bewusst NICHT
+      mit angefasst – beide hängen eng mit der damals unentschiedenen
+      Call-Fassade bzw. dem Bootstrap/Login-Pfad zusammen.
+      **Nachtrag 2026-07-06:** Nach dem Call-Piloten ist
+      `call_ui/voice_channel.dart` jetzt ebenfalls geteilt (5 part-Dateien
+      unter `call_ui/view/`, zeichenidentisch verifiziert, 95d9b07);
+      `app_shell.dart` bleibt wegen des Bootstrap/Login-Pfads (heilig)
+      weiter unangetastet. Ebenso `settings/settings_encryption.dart`
+      (1470 Zeilen, größte verbliebene Teildatei) in 4 part-Dateien unter
+      `settings/encryption/` geteilt (zeichenidentisch verifiziert,
+      6128953) – Vorbereitung für das spätere verification-Modul
+      (Schnitt-Doc Schritt 3), Code selbst unangetastet.
+      UNGETESTET (Pi) im Sinne von „nicht in echter UI gesehen" – nächster
+      Windows-Lauf sollte alle 6 betroffenen Bereiche einmal durchklicken
+      (zusätzlich zu den 5 unten: eine PDF/Text/Archiv/Bild-Datei im Chat
+      öffnen, Vollbild-PDF-Viewer inkl. Thumbnail-Leiste und Speichern-Button
+      prüfen), siehe „Fragen an Bernd"/Nächster-Schritt in den jeweiligen
+      PROGRESS.md-Einträgen)
+- [ ] Nach JEDEM Schritt: App läuft, Kernflows getestet, Commit
+- [x] Test-/Benchmark-Gerüst: `scripts/test.ps1` (Analyse, Unit-, Live-Tests,
+      Benchmarks mit einem Befehl), `benchmark/` mit Baseline, lokale Suche
+      als testbares Modul (`lib/features/search/`). Siehe
+      `docs/TESTS_UND_BENCHMARKS.md`, PROGRESS.md 2026-10-07.
+- [ ] **Abhängigkeiten aktualisieren (3 Monate Stand, 119 Pakete veraltet)** –
+      einzeln, jeweils mit `scripts/test.ps1 -All` abgesichert:
+      - **`sqlcipher_flutter_libs` ist EOL:** 0.7.0 ist ein leerer Platzhalter
+        (pub.dev). Unsere Bindung `^0.6.8` schließt ihn aus – NIEMALS per
+        `pub upgrade --major-versions` mitziehen, sonst fehlt SQLCipher und
+        die App kann die verschlüsselte DB nicht mehr öffnen
+        (`AppDatabase` wirft dann bewusst, kein Datenverlust, aber Aussperren).
+        Nachfolger: `sqlite3` 3.x mit `hooks: user_defines: sqlite3: source:
+        sqlcipher` – Kompatibilität mit `sqflite_common_ffi` und Android
+        vorher klären; Migrations-/DB-Tests + Gerätetest Pflicht.
+      - `matrix` 6.2 → 13.x (großer Sprung, Breaking Changes; heiliger
+        Login-/Krypto-Pfad), `flutter_vodozemac` 0.5 → 0.8 gehört dazu.
+      - `livekit_client` 2.7 → 2.13 (innerhalb der Bindung möglich),
+        `flutter_webrtc`-Override 1.4.1 → 1.6.2: der Windows-Audiogeräte-Fix
+        (libwebrtc #142) ist auch in 1.6.2+hotfix.4 NICHT enthalten
+        (Changelog geprüft 2026-10-07) → Dummy-PeerConnection-Workaround
+        bleibt nötig.
+      - Android-Build: Gradle 8.13 → 8.14.3 ERLEDIGT (2026-10-07). „Built-in Kotlin“
+        **bewusst noch nicht** (Entscheidung 2026-10-07): AGP bleibt 8.11; die vom
+        Flutter-Migrator gesetzten Flags `android.builtInKotlin=false` /
+        `android.newDsl=false` halten den Build stabil. Umstieg erst zusammen mit
+        AGP 9 und wenn flutter_webrtc, livekit_client, media_kit & Co. ihn
+        unterstützen – vorher Release-APK + Anruftest.
+      - ERLEDIGT 2026-10-07 (0ad06e3): `flutter_markdown` → `flutter_markdown_plus`
+        (Rendertest `test/document_markdown_test.dart`).
+
+## M3 – Calls: Logik, UI & Audio (Discord als Referenz)
+
+- [ ] Voice-Channel-Logik robust machen: Beitreten/Verlassen/Wechseln ohne Hänger,
+      klarer Zustand wer drin ist, sauberes Verhalten bei Verbindungsabbruch
+      **Teilfortschritt 2026-07-06 (Nacht, mit 2 echten Test-Accounts durchgeklickt):**
+      Standalone-Voice-Channel in der Raumliste war per Klick gar nicht
+      beitretbar → gefixt (`_toggleVoiceChannel` in rooms_list.dart, wie
+      Space-Liste). Zustands-Härtung in livekit_call_manager.dart:
+      `_callGeneration` verhindert Geisterverbindungen bei Auflegen/Wechsel
+      während `connect`; Fehlerpfade setzen `error` sichtbar statt still zu
+      verschwinden; rooms_panel_core räumt `activeVoiceRoomIdProvider` auf,
+      wenn der Service inaktiv wird, + Fehler-SnackBar. REAL getestet:
+      Beitreten (beide), Teilnehmerliste, bidirektionaler Screenshare,
+      Live-Qualitätswechsel, sauberes Verlassen. **UNGETESTET:** echtes
+      2-Peer-Audio (beide auf 1 PC), Netz-Abbruch mitten im Call (nur im
+      Code abgesichert). Nicht abgehakt.
+- [ ] Call-UI aufräumen: aufgeräumter, intuitiver, konsistent (Mini-Call-Widget, Vollansicht)
+- [ ] **Windows: Audiogeräte-Erkennung reparieren** (Mikrofon/Ausgabe erkennen und in den
+      Einstellungen auswählbar machen – geht aktuell gar nicht)
+- [ ] Noise Suppression als optionale Einstellung (z. B. RNNoise/LiveKit-Audio-Filter)
+- [ ] Lautstärke pro Teilnehmer einstellbar (Discord-Style, persistent pro Nutzer)
+- [ ] Weitere Feinjustierung: Eingangsempfindlichkeit/Gate, Echo-Unterdrückung an/aus,
+      Push-to-Talk prüfen – von Discords Sprach-Einstellungen inspirieren lassen
+- [ ] Anruf-Benachrichtigung auch bei gekillter App (Push-Architektur nutzen)
+
+## M4 – Streaming (Bildschirmübertragung)
+
+- [ ] **Framerate verbessern:** Ursache messen (Encoder? Auflösung? Simulcast-Settings?
+      Software- statt Hardware-Encoding?), dann gezielt fixen
+      **Teilfortschritt 2026-07-06 (Nacht, `docs/STREAMING_60FPS.md`, ffd70ca):**
+      Vier Ruckel-Ursachen adressiert – FPS-Deckel (jetzt hd60/fhd60 mit
+      echten 60 FPS), zu niedrige Bitrate (5/8 Mbit/s), Capture blieb auf
+      1080p/15 (Preset wird jetzt bis in ScreenShareCaptureOptions
+      durchgereicht), degradationPreference (60-FPS-Modi
+      maintainFramerate, kein Simulcast). contentHint='motion' in
+      flutter_webrtc 1.4.1 aus Dart nicht setzbar (dokumentiert). REAL
+      getestet: Umschalten auf Full HD 60fps live, Screenshare läuft weiter.
+      **UNGETESTET:** subjektives Ruckel-Empfinden + realer 60-FPS-RTP
+      (Sender/Empfänger auf 1 PC = nicht beurteilbar), braucht 2 Geräte+Netz.
+- [ ] Auflösung/Qualität wählbar für den **Streamer** (z. B. 720p/1080p + FPS-Wahl)
+      **2026-07-06:** FPS-Wahl umgesetzt – SENDEN-Menü hat jetzt „HD 60fps"
+      und „Full HD 60fps" zusätzlich zu sd/hd/fhd/4k (ffd70ca).
+- [ ] Qualität wählbar für den **Empfänger** (LiveKit-Simulcast-Layer auswählen)
+- [ ] Sauberes Degradieren bei schwacher Bandbreite statt Ruckel-Chaos
+
+## M5 – Chat-Funktionen
+
+- [ ] Sprachnachrichten aufnehmen & abspielen (MSC3245-kompatibel, wie Element)
+- [ ] **Bilder speichern → richtige Galerie:** über MediaStore/Downloads statt in den
+      unzugänglichen App-Ordner (Android Scoped Storage korrekt nutzen)
+- [ ] Medien senden/empfangen generell prüfen (Fortschritt, Vorschau, Videos)
+
+## M6 – Release & Verteilung
+
+- [ ] **Google-Warnung beim Installieren untersuchen:** Play-Protect-Meldung seit der
+      Signatur-Einführung analysieren (Signing-Konfig prüfen; unbekannte Signatur + Sideload
+      löst das oft aus; ggf. Play-Protect-Appeal oder saubere v2/v3-Signierung)
+- [ ] Release-Skript prüfen/aktualisieren (Windows + Android), Versionierung sauber
+- [ ] In-App-Updater testen (existiert laut Git-Historie)
+
+## M7 – Design & Feinschliff
+
+- [x] **Beta-Feedback 2026-10-07 umgesetzt (UNGETESTET auf echtem Handy):**
+      Push als Chat-Verlauf mit Bildvorschau + echtem „Gelesen“, Statusleiste
+      überdeckt nichts mehr, Bild-Vollansicht mit Gesten, weiches Dunkel,
+      Schriftgrößen-Regler, Sprechblasen umschaltbar, Messenger-Chatliste,
+      deutsche Beschriftungen. Test-Version 0.1.37 (siehe PROGRESS.md).
+
+- [ ] Rooms-Icon überarbeiten – passt stilistisch nicht zu den anderen Buttons
+- [ ] Design-Konsistenz-Pass über alle Icons/Buttons
+- [ ] Onboarding: erster Start erklärt Server-Wahl und Verifikation verständlich
+- [ ] Themes/Darkmode-Feinschliff, Schriftgrößen
+
+## Ideen-Parkplatz (unsortiert, erst nach M7 bewerten)
+
+- Threads, Sticker, Standort teilen, mehrere Konten
+- Watch-Together (z. B. Jellyfin gemeinsam schauen)
+
+> Bernd: „Das ist nur der Anfang meiner Liste" – neue Punkte einfach hier in den
+> passenden Meilenstein eintragen (oder Claude sagen, er soll sie einsortieren).

analysis_options.yaml

@@ -9,6 +9,11 @@
 # packages, and plugins designed to encourage good coding practices.
 include: package:flutter_lints/flutter.yaml
 
+analyzer:
+  exclude:
+    # Design-Mockups, kein Produktionscode — nicht analysieren.
+    - mockup/**
+
 linter:
   # The lint rules applied to this project can be customized in the
   # section below to disable rules from the `package:flutter_lints/flutter.yaml`

android/app/build.gradle.kts

@@ -1,8 +1,19 @@
+import java.util.Properties
+
 plugins {
     id("com.android.application")
     id("kotlin-android")
     // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
     id("dev.flutter.flutter-gradle-plugin")
+    id("com.google.gms.google-services")
+}
+
+// Release signing is configured via android/key.properties (gitignored).
+// The keystore lives outside the repo; see key.properties for the path.
+val keystoreProperties = Properties()
+val keystorePropertiesFile = rootProject.file("key.properties")
+if (keystorePropertiesFile.exists()) {
+    keystorePropertiesFile.inputStream().use { keystoreProperties.load(it) }
 }
 
 android {
@@ -11,6 +22,7 @@ android {
     ndkVersion = flutter.ndkVersion
 
     compileOptions {
+        isCoreLibraryDesugaringEnabled = true
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
@@ -30,13 +42,42 @@ android {
         versionName = flutter.versionName
     }
 
-    buildTypes {
-        release {
-            // TODO: Add your own signing config for the release build.
-            // Signing with the debug keys for now, so `flutter run --release` works.
-            signingConfig = signingConfigs.getByName("debug")
+    signingConfigs {
+        if (keystorePropertiesFile.exists()) {
+            create("release") {
+                keyAlias = keystoreProperties["keyAlias"] as String
+                keyPassword = keystoreProperties["keyPassword"] as String
+                storeFile = file(keystoreProperties["storeFile"] as String)
+                storePassword = keystoreProperties["storePassword"] as String
+            }
         }
     }
+
+    buildTypes {
+        release {
+            // Falls back to debug signing on machines without key.properties
+            // so `flutter run --release` still works there.
+            signingConfig = if (keystorePropertiesFile.exists()) {
+                signingConfigs.getByName("release")
+            } else {
+                signingConfigs.getByName("debug")
+            }
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+        }
+    }
+}
+
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
+    // Required to compile PushService.kt which extends FirebaseMessagingService directly.
+    // Version must stay in sync with FirebaseSDKVersion in firebase_core's gradle.properties.
+    implementation(platform("com.google.firebase:firebase-bom:33.16.0"))
+    implementation("com.google.firebase:firebase-messaging-ktx")
 }
 
 flutter {

android/app/google-services.json

@@ -0,0 +1,29 @@
+{
+  "project_info": {
+    "project_number": "858748942228",
+    "project_id": "chat-pyramid",
+    "storage_bucket": "chat-pyramid.firebasestorage.app"
+  },
+  "client": [
+    {
+      "client_info": {
+        "mobilesdk_app_id": "1:858748942228:android:661405508fbb2f40d30181",
+        "android_client_info": {
+          "package_name": "chat.pyramid.pyramid"
+        }
+      },
+      "oauth_client": [],
+      "api_key": [
+        {
+          "current_key": "AIzaSyDbqLHYFHqUdPOAexDFTpMvQVkQHY6chFE"
+        }
+      ],
+      "services": {
+        "appinvite_service": {
+          "other_platform_oauth_client": []
+        }
+      }
+    }
+  ],
+  "configuration_version": "1"
+}

android/app/proguard-rules.pro

@@ -0,0 +1,18 @@
+# Flutter's own keep rules are added automatically by the Flutter Gradle plugin.
+
+# WebRTC / LiveKit: native code calls Java classes via JNI by name,
+# so nothing under org.webrtc may be stripped or renamed.
+-keep class org.webrtc.** { *; }
+-dontwarn org.webrtc.**
+-keep class livekit.org.webrtc.** { *; }
+-dontwarn livekit.org.webrtc.**
+
+# flutter_local_notifications deserializes scheduled notifications with Gson
+# using reflection; stripped type adapters crash on the next reboot/schedule.
+-keep class com.dexterous.flutterlocalnotifications.** { *; }
+-keepattributes Signature
+-keepattributes *Annotation*
+
+# Flutter references Play Core for deferred components, which this app
+# doesn't ship — silence the missing-class errors from R8.
+-dontwarn com.google.android.play.core.**

android/app/src/debug/AndroidManifest.xml

@@ -4,4 +4,10 @@
          to allow setting breakpoints, to provide hot reload, etc.
     -->
     <uses-permission android:name="android.permission.INTERNET"/>
+    <application>
+        <!-- NUR Debug: Benachrichtigungen per adb auslösen (DebugNotifyReceiver.kt). -->
+        <receiver
+            android:name=".DebugNotifyReceiver"
+            android:exported="true" />
+    </application>
 </manifest>

android/app/src/debug/kotlin/chat/pyramid/pyramid/DebugNotifyReceiver.kt

@@ -0,0 +1,55 @@
+package chat.pyramid.pyramid
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import java.io.File
+
+/**
+ * NUR IM DEBUG-BUILD (src/debug): löst Nachrichten-Benachrichtigungen per adb
+ * aus, um NotificationHelper ohne Login/Push auf dem Emulator zu prüfen.
+ * Ist nicht im Release-APK enthalten.
+ *
+ *   adb shell am broadcast -n chat.pyramid.pyramid/.DebugNotifyReceiver \
+ *     --es sender Uta --es body "Hallo" [--es roomName Familie] \
+ *     [--es event e1] [--ez image true] [--ez avatar true] [--es room !r:x]
+ */
+class DebugNotifyReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val roomId = intent.getStringExtra("room") ?: "!debug:pyramid.local"
+        val sender = intent.getStringExtra("sender") ?: "Testnutzer"
+        val roomName = intent.getStringExtra("roomName")
+        val eventId = intent.getStringExtra("event") ?: "\$debug${System.nanoTime()}"
+        val args = mapOf(
+            "roomId" to roomId,
+            "notifId" to NotificationHelper.stableId(roomId),
+            "eventId" to eventId,
+            "senderId" to "@${sender.lowercase()}:pyramid.local",
+            "senderName" to sender,
+            "roomName" to roomName,
+            "isGroup" to (roomName != null),
+            "body" to (intent.getStringExtra("body") ?: NotificationHelper.PLACEHOLDER_BODY),
+            "timestamp" to System.currentTimeMillis(),
+            "imagePath" to if (intent.getBooleanExtra("image", false)) testImage(context, "img_debug", 960, 640) else null,
+            "avatarPath" to if (intent.getBooleanExtra("avatar", false)) testImage(context, "avatar_$sender", 256, 256) else null,
+        )
+        NotificationHelper.showFromArgs(context, args)
+    }
+
+    /** Erzeugt ein buntes Testbild unter cache/downloads/notif/ (FileProvider-Pfad). */
+    private fun testImage(context: Context, name: String, w: Int, h: Int): String {
+        val dir = File(context.cacheDir, "downloads/notif").apply { mkdirs() }
+        val file = File(dir, name)
+        val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+        val c = Canvas(bmp)
+        c.drawColor(Color.rgb(0x3B, 0x6D, 0x11))
+        val p = Paint().apply { color = Color.rgb(0xF5, 0xA6, 0x14); isAntiAlias = true }
+        c.drawCircle(w * 0.5f, h * 0.5f, minOf(w, h) * 0.3f, p)
+        file.outputStream().use { bmp.compress(Bitmap.CompressFormat.JPEG, 90, it) }
+        return file.absolutePath
+    }
+}

android/app/src/main/AndroidManifest.xml

@@ -1,4 +1,6 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.RECORD_AUDIO"/>
     <uses-permission android:name="android.permission.CAMERA"/>
@@ -7,18 +9,33 @@
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+    <uses-permission android:name="android.permission.VIBRATE"/>
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES"/>
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
 
+    <!-- Kein Backup/Umzug der App-Daten: siehe res/xml/data_extraction_rules.xml
+         (verschlüsselte DB ohne Keystore-Schlüssel = App startet nicht). -->
     <application
-        android:label="pyramid"
+        android:label="Pyramid"
         android:name="${applicationName}"
-        android:icon="@mipmap/ic_launcher">
+        android:icon="@mipmap/ic_launcher"
+        android:allowBackup="false"
+        android:fullBackupContent="false"
+        android:dataExtractionRules="@xml/data_extraction_rules">
+        <!-- Laufender Anruf: hält das Mikrofon im Hintergrund am Leben und
+             ist Pflicht für Bildschirmübertragung ab Android 14 (CallService.kt).
+             Der frühere Eintrag com.cloudwebrtc...FlutterForegroundService
+             verwies auf eine Klasse, die flutter_webrtc 1.x nicht mehr hat. -->
         <service
-            android:name="com.cloudwebrtc.webrtc.FlutterForegroundService"
+            android:name=".CallService"
             android:enabled="true"
             android:exported="false"
-            android:foregroundServiceType="mediaProjection" />
+            android:foregroundServiceType="microphone|mediaProjection" />
         <activity
             android:name=".MainActivity"
             android:exported="true"
@@ -40,6 +57,28 @@
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
+            <!-- Share-Target: "Teilen nach Pyramid" aus anderen Apps -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEND"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:mimeType="text/plain"/>
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.SEND"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:mimeType="image/*"/>
+                <data android:mimeType="video/*"/>
+                <data android:mimeType="audio/*"/>
+                <data android:mimeType="application/*"/>
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.SEND_MULTIPLE"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:mimeType="image/*"/>
+                <data android:mimeType="video/*"/>
+                <data android:mimeType="audio/*"/>
+                <data android:mimeType="application/*"/>
+            </intent-filter>
         </activity>
         <!-- FileProvider for APK installs (update downloader) -->
         <provider
@@ -51,6 +90,42 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_paths"/>
         </provider>
+        <!-- FCM: default channel + icon so system-generated notifications work -->
+        <meta-data
+            android:name="com.google.firebase.messaging.default_notification_channel_id"
+            android:value="pyramid_messages"/>
+        <meta-data
+            android:name="com.google.firebase.messaging.default_notification_icon"
+            android:value="@drawable/ic_notification"/>
+        <!-- Disable the Flutter Firebase plugin's FCM service — PushService.kt
+             handles FCM directly in native Kotlin, which is far more reliable on
+             Samsung/OEM devices where the Dart VM start is blocked by battery
+             optimisation when the app is killed. -->
+        <service
+            android:name="io.flutter.plugins.firebase.messaging.FlutterFirebaseMessagingService"
+            tools:node="remove"/>
+        <!-- Also remove the legacy C2DM broadcast receiver so Samsung cannot
+             start a second Dart background isolate via the old GCM/C2DM path. -->
+        <receiver
+            android:name="io.flutter.plugins.firebase.messaging.FlutterFirebaseMessagingReceiver"
+            tools:node="remove"/>
+        <!-- Native FCM handler — receives messages even when the app is killed. -->
+        <service
+            android:name=".PushService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="com.google.firebase.MESSAGING_EVENT"/>
+            </intent-filter>
+        </service>
+        <!-- Handles inline reply and dismiss actions without opening an Activity. -->
+        <receiver
+            android:name=".ReplyReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="chat.pyramid.pyramid.REPLY"/>
+                <action android:name="chat.pyramid.pyramid.DISMISS"/>
+            </intent-filter>
+        </receiver>
         <!-- Don't delete the meta-data below.
              This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
         <meta-data
@@ -63,6 +138,15 @@
 
          In particular, this is used by the Flutter engine in io.flutter.plugin.text.ProcessTextPlugin. -->
     <queries>
+        <!-- url_launcher: required on Android 11+ for canLaunchUrl to work -->
+        <intent>
+            <action android:name="android.intent.action.VIEW"/>
+            <data android:scheme="https"/>
+        </intent>
+        <intent>
+            <action android:name="android.intent.action.VIEW"/>
+            <data android:scheme="http"/>
+        </intent>
         <intent>
             <action android:name="android.intent.action.PROCESS_TEXT"/>
             <data android:mimeType="text/plain"/>

android/app/src/main/kotlin/chat/pyramid/pyramid/BgEngine.kt

@@ -0,0 +1,146 @@
+package chat.pyramid.pyramid
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import io.flutter.FlutterInjector
+import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.dart.DartExecutor
+import io.flutter.plugin.common.MethodChannel
+import io.flutter.view.FlutterCallbackInformation
+
+/**
+ * Bootstraps a headless Flutter background engine running the
+ * `notificationEngineMain` Dart entrypoint and forwards work items
+ * (decrypt-and-show, send-reply) to it via a MethodChannel.
+ *
+ * Only used when the app is KILLED (no main FlutterEngine). The Dart side builds
+ * a short-lived Matrix client against the same DB to decrypt / send. This is safe
+ * because callers gate on the main app being dead — never two clients at once.
+ */
+object BgEngine {
+    private const val TAG = "PYRAMID-BGENGINE"
+    private const val CHANNEL = "chat.pyramid.pyramid/bg_engine"
+
+    private var engine: FlutterEngine? = null
+    private var channel: MethodChannel? = null
+    private var ready = false
+    private var appContext: Context? = null
+    // Tasks queued until the Dart handler signals readiness.
+    private val pending = mutableListOf<Pair<String, Map<String, Any?>>>()
+    // Pending "Neue Nachricht" fallback placeholders, keyed by notifId. Shown
+    // only if decryption doesn't replace them in time; cancelled by showDecrypted.
+    private val fallbackHandler = Handler(Looper.getMainLooper())
+    private val fallbacks = mutableMapOf<Int, Runnable>()
+
+    /** Schedule a placeholder shown after [delayMs] unless decryption beats it. */
+    fun scheduleFallback(
+        context: Context, meta: PushService.PushMeta, roomId: String, notifId: Int,
+        eventId: String?, delayMs: Long,
+    ) {
+        val ctx = context.applicationContext
+        appContext = ctx
+        fallbackHandler.post {
+            cancelFallback(notifId)
+            val r = Runnable {
+                fallbacks.remove(notifId)
+                meta.showPlaceholder(ctx, roomId, notifId, eventId)
+                Log.d(TAG, "fallback placeholder shown for $roomId (decrypt too slow)")
+            }
+            fallbacks[notifId] = r
+            fallbackHandler.postDelayed(r, delayMs)
+        }
+    }
+
+    private fun cancelFallback(notifId: Int) {
+        fallbacks.remove(notifId)?.let { fallbackHandler.removeCallbacks(it) }
+    }
+
+    /** Enqueue a task; boots the engine on first use. Must run on the main thread. */
+    fun run(context: Context, method: String, args: Map<String, Any?>) {
+        appContext = context.applicationContext
+        Handler(Looper.getMainLooper()).post {
+            try {
+                ensureEngine(context.applicationContext)
+                if (ready) {
+                    channel?.invokeMethod(method, args)
+                } else {
+                    pending.add(method to args)
+                }
+            } catch (e: Exception) {
+                Log.w(TAG, "run failed: ${e.message}")
+            }
+        }
+    }
+
+    private fun ensureEngine(context: Context) {
+        if (engine != null) return
+
+        val prefs = context.getSharedPreferences("FlutterSharedPreferences", Context.MODE_PRIVATE)
+        val handle = try {
+            prefs.getLong("flutter.bg_engine_handle", 0L)
+        } catch (_: Exception) {
+            0L
+        }
+        if (handle == 0L) {
+            Log.w(TAG, "no bg_engine_handle stored — cannot start background engine")
+            return
+        }
+
+        // The Flutter native library must be loaded BEFORE looking up the
+        // callback — nativeLookupCallbackInformation is a native method and
+        // throws UnsatisfiedLinkError otherwise.
+        val loader = FlutterInjector.instance().flutterLoader()
+        loader.startInitialization(context)
+        loader.ensureInitializationComplete(context, null)
+
+        val cbInfo = FlutterCallbackInformation.lookupCallbackInformation(handle)
+        if (cbInfo == null) {
+            Log.w(TAG, "callback info not found for handle $handle")
+            return
+        }
+
+        val eng = FlutterEngine(context)
+        engine = eng
+
+        val ch = MethodChannel(eng.dartExecutor.binaryMessenger, CHANNEL)
+        channel = ch
+        ch.setMethodCallHandler { call, result ->
+            when (call.method) {
+                "bgEngineReady" -> {
+                    ready = true
+                    Log.d(TAG, "Dart background engine ready — flushing ${pending.size} task(s)")
+                    pending.forEach { (m, a) -> ch.invokeMethod(m, a) }
+                    pending.clear()
+                    result.success(null)
+                }
+                // Dart finished decrypting — show the real content using the SAME
+                // native notification (keeps the reliable MainActivity reply action).
+                // May arrive twice per event: first the text, then silently
+                // the same event with avatar/image (NotificationHelper merges).
+                "showDecrypted" -> {
+                    @Suppress("UNCHECKED_CAST")
+                    val args = (call.arguments as? Map<String, Any?>) ?: emptyMap()
+                    val roomId = (args["roomId"] ?: args["room_id"]) as? String ?: ""
+                    val notifId = ((args["notifId"] ?: args["notif_id"]) as? Number)?.toInt()
+                        ?: NotificationHelper.stableId(roomId)
+                    val ctx = appContext
+                    if (ctx != null && roomId.isNotEmpty()) {
+                        // Beat the fallback placeholder to it — show decrypted directly.
+                        cancelFallback(notifId)
+                        NotificationHelper.showFromArgs(ctx, args)
+                        Log.d(TAG, "showDecrypted → shown decrypted notification for $roomId")
+                    }
+                    result.success(null)
+                }
+                else -> result.notImplemented()
+            }
+        }
+
+        eng.dartExecutor.executeDartCallback(
+            DartExecutor.DartCallback(context.assets, loader.findAppBundlePath(), cbInfo)
+        )
+        Log.d(TAG, "background engine started")
+    }
+}

android/app/src/main/kotlin/chat/pyramid/pyramid/CallService.kt

@@ -0,0 +1,143 @@
+package chat.pyramid.pyramid
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.Manifest
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+
+/**
+ * Vordergrunddienst für laufende Anrufe (1:1 und Sprachkanäle).
+ *
+ * Warum: Android schaltet das Mikrofon einer App im Hintergrund stumm, und
+ * seit Android 14 stürzt jede Bildschirmübertragung ab, wenn vorher kein
+ * Dienst vom Typ „mediaProjection“ läuft (flutter_webrtc startet keinen).
+ * Genau das war Bernds Fehlerbild 2026-10-07: Teilen gestartet → App weg →
+ * beim Öffnen kein Anruf mehr.
+ *
+ * Typen: immer „microphone“ (ab Android 11), bei laufender Übertragung
+ * zusätzlich „mediaProjection“. Der Dienst darf mit mediaProjection erst
+ * NACH der Zustimmung des Nutzers gestartet werden – das stellt die
+ * Dart-Seite sicher (lib/core/call_foreground.dart).
+ */
+class CallService : Service() {
+    companion object {
+        private const val TAG = "PYRAMID-CALL"
+        private const val CHANNEL_ID = "pyramid_call"
+        private const val NOTIF_ID = 7301
+        private const val EXTRA_TITLE = "title"
+        private const val EXTRA_SCREEN = "screen"
+
+        // Wer auf den tatsächlichen startForeground wartet (Hauptthread).
+        // Die Bildschirmübertragung darf erst danach beginnen.
+        private val waiters = mutableListOf<(Boolean) -> Unit>()
+
+        fun whenStarted(callback: (Boolean) -> Unit) {
+            waiters.add(callback)
+        }
+
+        private fun notifyWaiters(ok: Boolean) {
+            val list = waiters.toList()
+            waiters.clear()
+            list.forEach { it(ok) }
+        }
+
+        fun start(ctx: Context, title: String, screen: Boolean) {
+            val intent = Intent(ctx, CallService::class.java)
+                .putExtra(EXTRA_TITLE, title)
+                .putExtra(EXTRA_SCREEN, screen)
+            ContextCompat.startForegroundService(ctx, intent)
+        }
+
+        fun stop(ctx: Context) {
+            ctx.stopService(Intent(ctx, CallService::class.java))
+        }
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val title = intent?.getStringExtra(EXTRA_TITLE) ?: "Pyramid"
+        val screen = intent?.getBooleanExtra(EXTRA_SCREEN, false) ?: false
+        ensureChannel()
+
+        val launch = packageManager.getLaunchIntentForPackage(packageName)?.apply {
+            addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)
+        }
+        val open = launch?.let {
+            PendingIntent.getActivity(
+                this, 0, it,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+        }
+        val notification = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setContentTitle(if (screen) "Bildschirm wird übertragen" else "Anruf läuft")
+            .setContentText("$title – tippen, um zurückzukehren")
+            .setOngoing(true)
+            .setOnlyAlertOnce(true)
+            .setSilent(true)
+            .setCategory(NotificationCompat.CATEGORY_CALL)
+            .setContentIntent(open)
+            .build()
+
+        // Typ „microphone“ nur mit Mikrofon-Berechtigung (sonst verweigert
+        // Android den GANZEN Dienst – auch den für die Übertragung).
+        val micAllowed = ContextCompat.checkSelfPermission(
+            this, Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+        val candidates = mutableListOf<Int>()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val mic = ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+            val proj = ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION
+            if (screen) {
+                if (micAllowed) candidates.add(mic or proj)
+                candidates.add(proj)
+            } else if (micAllowed) {
+                candidates.add(mic)
+            }
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            candidates.add(if (screen) ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION else 0)
+        } else {
+            candidates.add(-1) // ohne Typ
+        }
+
+        var ok = false
+        for (type in candidates) {
+            try {
+                if (type == -1) startForeground(NOTIF_ID, notification)
+                else startForeground(NOTIF_ID, notification, type)
+                ok = true
+                break
+            } catch (e: Exception) {
+                // Nächste, schmalere Variante versuchen – lieber ohne Dienst
+                // weiter als die App abstürzen zu lassen.
+                Log.e(TAG, "startForeground fehlgeschlagen (screen=$screen, type=$type): ${e.message}")
+            }
+        }
+        if (!ok) stopSelf()
+        notifyWaiters(ok)
+        return START_NOT_STICKY
+    }
+
+    private fun ensureChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val nm = getSystemService(NotificationManager::class.java)
+        if (nm.getNotificationChannel(CHANNEL_ID) != null) return
+        nm.createNotificationChannel(
+            NotificationChannel(CHANNEL_ID, "Laufende Anrufe", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Zeigt an, dass ein Anruf oder eine Bildschirmübertragung läuft."
+                setShowBadge(false)
+            }
+        )
+    }
+}

android/app/src/main/kotlin/chat/pyramid/pyramid/MainActivity.kt

@@ -3,49 +3,302 @@ package chat.pyramid.pyramid
 import android.content.Intent
 import android.net.Uri
 import android.os.Build
+import android.os.Bundle
+import android.provider.Settings
+import android.util.Log
+import androidx.core.app.RemoteInput
 import androidx.core.content.FileProvider
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.FlutterEngineCache
 import io.flutter.plugin.common.MethodChannel
 import java.io.File
 
 class MainActivity : FlutterActivity() {
     private val channel = "chat.pyramid.pyramid/install"
 
+    // ── Share-Target (Teilen nach Pyramid) ────────────────────────────────────
+    // Extracts shared text/streams from SEND/SEND_MULTIPLE intents. Streams are
+    // copied into cacheDir because Flutter cannot read content:// URIs directly.
+    private fun extractShare(intent: Intent?): Map<String, Any?>? {
+        if (intent == null) return null
+        val action = intent.action
+        if (action != Intent.ACTION_SEND && action != Intent.ACTION_SEND_MULTIPLE) return null
+        val text = intent.getStringExtra(Intent.EXTRA_TEXT)
+        val uris = mutableListOf<Uri>()
+        if (action == Intent.ACTION_SEND) {
+            val u: Uri? = if (Build.VERSION.SDK_INT >= 33)
+                intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+            else @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_STREAM)
+            if (u != null) uris.add(u)
+        } else {
+            val list: ArrayList<Uri>? = if (Build.VERSION.SDK_INT >= 33)
+                intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM, Uri::class.java)
+            else @Suppress("DEPRECATION") intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM)
+            if (list != null) uris.addAll(list)
+        }
+        if (text.isNullOrEmpty() && uris.isEmpty()) return null
+        val paths = uris.mapNotNull { copyShareToCache(it) }
+        return mapOf("text" to text, "paths" to paths)
+    }
+
+    private fun copyShareToCache(uri: Uri): String? {
+        return try {
+            val name = contentResolver.query(uri, null, null, null, null)?.use { c ->
+                val idx = c.getColumnIndex(android.provider.OpenableColumns.DISPLAY_NAME)
+                if (idx >= 0 && c.moveToFirst()) c.getString(idx) else null
+            } ?: "shared_${System.currentTimeMillis()}"
+            val safe = name.replace(Regex("[^A-Za-z0-9._-]"), "_")
+            val outFile = File(cacheDir, "share_${System.currentTimeMillis()}_$safe")
+            val stream = contentResolver.openInputStream(uri) ?: return null
+            stream.use { input ->
+                outFile.outputStream().use { input.copyTo(it) }
+            }
+            outFile.absolutePath
+        } catch (e: Exception) {
+            Log.e("PYRAMID-SHARE", "copyShareToCache failed: ${e.message}")
+            null
+        }
+    }
+
+    // Extract reply text from an intent using all known key patterns.
+    private fun extractReply(intent: Intent?): Pair<String?, String?> {
+        if (intent == null) return Pair(null, null)
+        // Only treat intents with our REPLY action as reply intents.
+        if (intent.action != ReplyReceiver.ACTION_REPLY) return Pair(null, null)
+        val remoteInputResults = RemoteInput.getResultsFromIntent(intent)
+        val replyText: String? =
+            remoteInputResults?.let { bundle ->
+                // Primary key must match RemoteInput.Builder key in NotificationHelper.
+                bundle.getCharSequence(ReplyReceiver.REMOTE_INPUT_KEY)?.toString()?.trim()
+                    ?: bundle.keySet()?.firstOrNull()?.let { bundle.getCharSequence(it)?.toString()?.trim() }
+            }
+            ?: intent.getStringExtra(ReplyReceiver.REMOTE_INPUT_KEY)
+            ?: intent.getStringExtra("input")
+        val payload = intent.getStringExtra(ReplyReceiver.EXTRA_ROOM_ID)
+            ?: intent.getStringExtra("payload")
+        return Pair(replyText, payload)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        // If this Activity was launched to handle a notification reply (cold start),
+        // apply a fully transparent theme BEFORE super.onCreate so no UI is ever
+        // drawn. The Flutter engine still initialises (needed for E2EE send via SDK)
+        // but the window remains invisible.
+        val (replyText, _) = extractReply(intent)
+        if (!replyText.isNullOrEmpty()) {
+            setTheme(R.style.ReplyHandlerTheme)
+            Log.e("PYRAMID-INTENT", "onCreate: reply launch detected — transparent theme applied")
+        }
+        super.onCreate(savedInstanceState)
+    }
+
     override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
         super.configureFlutterEngine(flutterEngine)
+        // Cache so ReplyReceiver can call back into Dart without starting a new engine.
+        FlutterEngineCache.getInstance().put("main", flutterEngine)
+        // Anruf-Vordergrunddienst (lib/core/call_foreground.dart ↔ CallService.kt).
+        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "chat.pyramid.pyramid/call")
+            .setMethodCallHandler { call, result ->
+                when (call.method) {
+                    "start" -> {
+                        // Erst antworten, wenn der Dienst wirklich im Vordergrund
+                        // läuft (oder nach 3 s aufgeben) – eine Übertragung vor
+                        // dem startForeground würde die App abstürzen lassen.
+                        val done = java.util.concurrent.atomic.AtomicBoolean(false)
+                        val reply = { ok: Boolean ->
+                            if (done.compareAndSet(false, true)) result.success(ok)
+                        }
+                        try {
+                            CallService.whenStarted(reply)
+                            CallService.start(
+                                this,
+                                call.argument<String>("title") ?: "Pyramid",
+                                call.argument<Boolean>("screen") ?: false,
+                            )
+                            android.os.Handler(mainLooper).postDelayed({ reply(false) }, 3000)
+                        } catch (e: Exception) {
+                            // z. B. Start aus dem Hintergrund verboten (Android 12+).
+                            Log.e("PYRAMID-CALL", "CallService-Start abgelehnt: ${e.message}")
+                            reply(false)
+                        }
+                    }
+                    "stop" -> {
+                        CallService.stop(this)
+                        result.success(true)
+                    }
+                    else -> result.notImplemented()
+                }
+            }
         MethodChannel(flutterEngine.dartExecutor.binaryMessenger, channel)
             .setMethodCallHandler { call, result ->
-                if (call.method == "installApk") {
-                    val path = call.argument<String>("path")
-                    if (path == null) {
-                        result.error("INVALID_ARG", "path is null", null)
-                        return@setMethodCallHandler
+                when (call.method) {
+                    // Flutter asks for the room_id embedded in the launch intent (cold-start tap).
+                    "getInitialRoomId" -> {
+                        result.success(intent?.getStringExtra("room_id"))
                     }
-                    try {
-                        val file = File(path)
-                        val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                            FileProvider.getUriForFile(
-                                this,
-                                "${applicationContext.packageName}.fileprovider",
-                                file
-                            )
+                    // Cold-start share: app was launched via "Teilen nach Pyramid".
+                    "getInitialShare" -> {
+                        val share = extractShare(intent)
+                        if (share != null) {
+                            result.success(share)
+                            intent = Intent() // clear so it's delivered only once
                         } else {
-                            Uri.fromFile(file)
+                            result.success(null)
                         }
-                        val intent = Intent(Intent.ACTION_VIEW).apply {
-                            setDataAndType(uri, "application/vnd.android.package-archive")
-                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    }
+                    // Flutter asks for any inline reply that arrived on cold-start.
+                    // When the app is killed and the user presses Reply, Android calls
+                    // onCreate (not onNewIntent), so the reply text is in the launch intent.
+                    "getInitialReply" -> {
+                        val (replyText, payload) = extractReply(intent)
+                        Log.e("PYRAMID-INTENT", "getInitialReply: replyText=${replyText?.take(20)} payload=$payload")
+                        if (!replyText.isNullOrEmpty() && !payload.isNullOrEmpty()) {
+                            result.success(mapOf("room_id" to payload, "text" to replyText))
+                            // Clear the launch intent so a second getInitialReply call returns null.
+                            intent = Intent()
+                        } else {
+                            result.success(null)
                         }
+                    }
+                    // Supported CPU ABIs in preference order, so the updater can
+                    // pick the matching split APK from a release.
+                    "getAbis" -> {
+                        result.success(Build.SUPPORTED_ABIS.toList())
+                    }
+                    "installApk" -> {
+                        val path = call.argument<String>("path")
+                        if (path == null) {
+                            result.error("INVALID_ARG", "path is null", null)
+                            return@setMethodCallHandler
+                        }
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+                            !packageManager.canRequestPackageInstalls()) {
+                            val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                                data = Uri.parse("package:$packageName")
+                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            }
+                            startActivity(intent)
+                            result.error("PERMISSION_REQUIRED", "install_permission", null)
+                            return@setMethodCallHandler
+                        }
+                        try {
+                            val file = File(path)
+                            val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                                FileProvider.getUriForFile(
+                                    this,
+                                    "${applicationContext.packageName}.fileprovider",
+                                    file
+                                )
+                            } else {
+                                Uri.fromFile(file)
+                            }
+                            val intent = Intent(Intent.ACTION_VIEW).apply {
+                                setDataAndType(uri, "application/vnd.android.package-archive")
+                                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            }
+                            startActivity(intent)
+                            result.success(null)
+                        } catch (e: Exception) {
+                            result.error("INSTALL_ERROR", e.message, null)
+                        }
+                    }
+                    "openNotificationSettings" -> {
+                        val intent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                            Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+                                putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
+                            }
+                        } else {
+                            Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                                data = Uri.fromParts("package", packageName, null)
+                            }
+                        }
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                         startActivity(intent)
                         result.success(null)
-                    } catch (e: Exception) {
-                        result.error("INSTALL_ERROR", e.message, null)
                     }
-                } else {
-                    result.notImplemented()
+                    "openBatterySettings" -> {
+                        val intent = Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                            data = Uri.parse("package:$packageName")
+                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                        }
+                        try {
+                            startActivity(intent)
+                        } catch (e: Exception) {
+                            val fallback = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                                data = Uri.fromParts("package", packageName, null)
+                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            }
+                            startActivity(fallback)
+                        }
+                        result.success(null)
+                    }
+                    "minimizeApp" -> {
+                        moveTaskToBack(true)
+                        result.success(null)
+                    }
+                    "showNativeNotification" -> {
+                        @Suppress("UNCHECKED_CAST")
+                        val args = (call.arguments as? Map<String, Any?>) ?: emptyMap()
+                        val roomId = args["roomId"] as? String ?: ""
+                        if (roomId.isNotEmpty()) {
+                            NotificationHelper.showFromArgs(this, args)
+                            result.success(null)
+                        } else {
+                            result.error("INVALID_ARG", "roomId missing", null)
+                        }
+                    }
+                    else -> result.notImplemented()
                 }
             }
     }
+
+    // Called when the app is already running (background) and a notification action
+    // fires — reply and tap both arrive here via onNewIntent (singleTop + SINGLE_TOP flag).
+    override fun onNewIntent(intent: Intent) {
+        // Zero-duration transition for all notification-driven intents.
+        overridePendingTransition(0, 0)
+
+        super.onNewIntent(intent)
+        setIntent(intent)
+
+        Log.e("PYRAMID-INTENT", "onNewIntent action=${intent.action}")
+
+        // ── Reply action ──────────────────────────────────────────────────────
+        if (intent.action == ReplyReceiver.ACTION_REPLY) {
+            val (replyText, payload) = extractReply(intent)
+            Log.e("PYRAMID-INTENT", "reply: replyText=${replyText?.take(20)} payload=$payload")
+            if (!replyText.isNullOrEmpty() && !payload.isNullOrEmpty()) {
+                flutterEngine?.dartExecutor?.binaryMessenger?.let { messenger ->
+                    MethodChannel(messenger, channel).invokeMethod(
+                        "replyFromNotification",
+                        mapOf("room_id" to payload, "text" to replyText),
+                    )
+                }
+            }
+            // Always send back immediately — never show the app UI for a reply.
+            moveTaskToBack(true)
+            overridePendingTransition(0, 0)
+            return
+        }
+
+        // ── Share action — app already running, user shared from another app ──
+        val share = extractShare(intent)
+        if (share != null) {
+            flutterEngine?.dartExecutor?.binaryMessenger?.let { messenger ->
+                MethodChannel(messenger, channel).invokeMethod("sharedContent", share)
+            }
+            return
+        }
+
+        // ── Tap action — open the room ────────────────────────────────────────
+        val roomId = intent.getStringExtra("room_id") ?: return
+        flutterEngine?.dartExecutor?.binaryMessenger?.let { messenger ->
+            MethodChannel(messenger, channel).invokeMethod(
+                "openRoom",
+                mapOf("room_id" to roomId),
+            )
+        }
+    }
 }

android/app/src/main/kotlin/chat/pyramid/pyramid/NotificationHelper.kt

@@ -0,0 +1,382 @@
+package chat.pyramid.pyramid
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.Person
+import androidx.core.app.RemoteInput
+import androidx.core.content.FileProvider
+import androidx.core.graphics.drawable.IconCompat
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Native Nachrichten-Benachrichtigungen (alle Pfade: Platzhalter aus
+ * PushService, Klartext aus der Haupt-Engine oder dem BgEngine-Isolate).
+ *
+ * Pro Raum gibt es EINE Benachrichtigung (notifId = stableId(roomId)), die als
+ * Chat-Verlauf (MessagingStyle) die letzten [MAX_MESSAGES] Nachrichten zeigt –
+ * wie WhatsApp/Element. Der Verlauf liegt in SharedPreferences, weil bei
+ * beendeter App jeder Push in einem neuen Prozess ankommt. Er wird nur
+ * fortgeführt, solange die Benachrichtigung noch sichtbar ist: hat der Nutzer
+ * sie weggewischt oder den Raum in der App geöffnet (Dart cancelt), beginnt
+ * der nächste Push mit einem leeren Verlauf.
+ *
+ * Gleiche eventId = Aktualisierung (Platzhalter → Klartext, Text → Text+Bild):
+ * die Nachricht wird ersetzt statt doppelt angehängt, und es klingelt nicht
+ * erneut. Nur eine wirklich neue Nachricht alarmiert.
+ */
+object NotificationHelper {
+    const val CHANNEL_ID = "pyramid_messages"
+    const val PLACEHOLDER_BODY = "Neue Nachricht"
+    private const val TAG = "PYRAMID-NOTIF"
+    private const val STORE = "pyramid_notif_history"
+    private const val MAX_MESSAGES = 8
+    private const val SYSTEM_UI = "com.android.systemui"
+
+    /** Eine Nachricht im Verlauf einer Raum-Benachrichtigung. */
+    data class Msg(
+        val eventId: String?,
+        val senderKey: String,
+        val senderName: String,
+        val body: String,
+        val timestamp: Long,
+        val imagePath: String? = null,
+        val avatarPath: String? = null,
+    ) {
+        val isPlaceholder get() = body == PLACEHOLDER_BODY
+
+        fun toJson(): JSONObject = JSONObject().apply {
+            put("eventId", eventId ?: JSONObject.NULL)
+            put("senderKey", senderKey)
+            put("senderName", senderName)
+            put("body", body)
+            put("timestamp", timestamp)
+            put("imagePath", imagePath ?: JSONObject.NULL)
+            put("avatarPath", avatarPath ?: JSONObject.NULL)
+        }
+
+        companion object {
+            fun fromJson(o: JSONObject) = Msg(
+                eventId = o.optStringOrNull("eventId"),
+                senderKey = o.optString("senderKey"),
+                senderName = o.optString("senderName"),
+                body = o.optString("body"),
+                timestamp = o.optLong("timestamp"),
+                imagePath = o.optStringOrNull("imagePath"),
+                avatarPath = o.optStringOrNull("avatarPath"),
+            )
+        }
+    }
+
+    /** Deterministic notification ID — same algorithm as Dart's _stableRoomId. */
+    fun stableId(roomId: String): Int {
+        var h = 0
+        for (c in roomId) h = ((h * 31) + c.code) and 0x7FFFFFFF
+        return if (h == 0) 1 else h
+    }
+
+    fun ensureChannel(context: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID, "Nachrichten", NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                description = "Neue Nachrichten"
+                enableVibration(true)
+            }
+            nm(context).createNotificationChannel(channel)
+        }
+    }
+
+    /**
+     * Platzhalter/Alt-Aufrufer mit fertigem Titel „Absender · Raum“ (bzw. nur
+     * „Absender“ bei Direktnachrichten).
+     */
+    fun show(
+        context: Context,
+        title: String,
+        body: String,
+        roomId: String,
+        notifId: Int,
+        eventId: String? = null,
+    ) {
+        val parts = title.split(" · ", limit = 2)
+        val sender = parts[0].ifBlank { "Pyramid" }
+        val roomName = parts.getOrNull(1)?.takeIf { it.isNotBlank() }
+        showMessage(
+            context, roomId, notifId, roomName, isGroup = roomName != null,
+            msg = Msg(eventId, sender, sender, body, System.currentTimeMillis()),
+        )
+    }
+
+    /** Strukturierter Aufruf aus Dart (`toNativeArgs` in notification_content.dart). */
+    fun showFromArgs(context: Context, args: Map<String, Any?>) {
+        val roomId = (args["roomId"] ?: args["room_id"]) as? String ?: return
+        if (roomId.isEmpty()) return
+        val notifId = ((args["notifId"] ?: args["notif_id"]) as? Number)?.toInt()
+            ?: stableId(roomId)
+        val senderName = args["senderName"] as? String
+        if (senderName == null) {
+            // Alter Aufrufer ohne strukturierte Felder.
+            show(
+                context, args["title"] as? String ?: "",
+                args["body"] as? String ?: PLACEHOLDER_BODY,
+                roomId, notifId, args["eventId"] as? String,
+            )
+            return
+        }
+        val roomName = (args["roomName"] as? String)?.takeIf { it.isNotBlank() }
+        showMessage(
+            context, roomId, notifId, roomName,
+            isGroup = (args["isGroup"] as? Boolean) ?: (roomName != null),
+            msg = Msg(
+                eventId = args["eventId"] as? String,
+                senderKey = args["senderId"] as? String ?: senderName,
+                senderName = senderName,
+                body = args["body"] as? String ?: PLACEHOLDER_BODY,
+                timestamp = (args["timestamp"] as? Number)?.toLong() ?: System.currentTimeMillis(),
+                imagePath = args["imagePath"] as? String,
+                avatarPath = args["avatarPath"] as? String,
+            ),
+        )
+    }
+
+    /** Fügt [msg] dem Verlauf des Raums hinzu (oder aktualisiert sie) und zeigt ihn. */
+    fun showMessage(
+        context: Context,
+        roomId: String,
+        notifId: Int,
+        roomName: String?,
+        isGroup: Boolean,
+        msg: Msg,
+    ) {
+        ensureChannel(context)
+        val (history, isNew) = mergeIntoHistory(context, roomId, notifId, msg)
+        val latest = history.last()
+
+        val style = NotificationCompat.MessagingStyle(
+            Person.Builder().setName("Du").setKey("me").build()
+        )
+        if (isGroup && roomName != null) {
+            style.conversationTitle = roomName
+            style.isGroupConversation = true
+        }
+        for (m in history) {
+            val person = Person.Builder()
+                .setName(m.senderName)
+                .setKey(m.senderKey)
+                .apply {
+                    contentUri(context, m.avatarPath)?.let { setIcon(IconCompat.createWithContentUri(it)) }
+                }
+                .build()
+            val message = NotificationCompat.MessagingStyle.Message(m.body, m.timestamp, person)
+            contentUri(context, m.imagePath)?.let { message.setData("image/jpeg", it) }
+            style.addMessage(message)
+        }
+
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_notification)
+            .setColor(Color.rgb(0x7B, 0x61, 0xFF))
+            .setStyle(style)
+            // Fallback-Texte für Geräte/Ansichten ohne MessagingStyle.
+            .setContentTitle(if (isGroup && roomName != null) roomName else latest.senderName)
+            .setContentText(latest.body)
+            .setWhen(latest.timestamp)
+            .setShowWhen(true)
+            .setNumber(history.size)
+            .setCategory(NotificationCompat.CATEGORY_MESSAGE)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            // Nur eine wirklich neue Nachricht klingelt; Aktualisierungen
+            // (Platzhalter → Klartext, Bild nachgeladen) ersetzen still.
+            .setOnlyAlertOnce(!isNew)
+            .setContentIntent(tapIntent(context, roomId, notifId))
+            .setAutoCancel(true)
+            .addAction(replyAction(context, roomId, notifId))
+            .addAction(markReadAction(context, roomId, notifId, latest.eventId))
+            .setGroup(CHANNEL_ID)
+        if (!isGroup) {
+            avatarBitmap(latest.avatarPath)?.let { builder.setLargeIcon(it) }
+        }
+
+        try {
+            nm(context).notify(notifId, builder.build())
+        } catch (e: Exception) {
+            // Sicherheitsnetz: lieber ohne Bilder/Avatare als gar nicht.
+            Log.w(TAG, "notify failed (${e.message}) — retrying as plain text")
+            builder.setLargeIcon(null as Bitmap?)
+                .setStyle(NotificationCompat.BigTextStyle().bigText(latest.body))
+            nm(context).notify(notifId, builder.build())
+        }
+    }
+
+    /** Vergisst den Verlauf eines Raums (nach Antworten/„Gelesen“). */
+    @Synchronized
+    fun clearHistory(context: Context, roomId: String) {
+        prefs(context).edit().remove(roomId).apply()
+    }
+
+    @Synchronized
+    private fun mergeIntoHistory(
+        context: Context, roomId: String, notifId: Int, msg: Msg,
+    ): Pair<List<Msg>, Boolean> {
+        val prefs = prefs(context)
+        val list = if (isActive(context, notifId)) load(prefs.getString(roomId, null)) else mutableListOf()
+        val index = msg.eventId?.let { id -> list.indexOfFirst { it.eventId == id } } ?: -1
+        val isNew = index < 0
+        if (isNew) {
+            list.add(msg)
+        } else {
+            val old = list[index]
+            // Ein später eintreffender Platzhalter überschreibt nie echten Text.
+            val keepOld = msg.isPlaceholder && !old.isPlaceholder
+            list[index] = Msg(
+                eventId = old.eventId,
+                senderKey = if (keepOld) old.senderKey else msg.senderKey,
+                senderName = if (keepOld) old.senderName else msg.senderName,
+                body = if (keepOld) old.body else msg.body,
+                timestamp = if (old.isPlaceholder) msg.timestamp else old.timestamp,
+                imagePath = msg.imagePath ?: old.imagePath,
+                avatarPath = msg.avatarPath ?: old.avatarPath,
+            )
+        }
+        list.sortBy { it.timestamp }
+        while (list.size > MAX_MESSAGES) list.removeAt(0)
+        prefs.edit().putString(roomId, JSONArray(list.map { it.toJson() }).toString()).apply()
+        return list to isNew
+    }
+
+    private fun load(json: String?): MutableList<Msg> {
+        if (json == null) return mutableListOf()
+        return try {
+            val arr = JSONArray(json)
+            MutableList(arr.length()) { Msg.fromJson(arr.getJSONObject(it)) }
+        } catch (_: Exception) {
+            mutableListOf()
+        }
+    }
+
+    /** Ist die Benachrichtigung noch sichtbar? (Sonst beginnt ein neuer Verlauf.) */
+    private fun isActive(context: Context, notifId: Int): Boolean {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) return true
+        return try {
+            nm(context).activeNotifications.any { it.id == notifId }
+        } catch (_: Exception) {
+            true
+        }
+    }
+
+    /**
+     * content://-URI für eine Datei unter cache/downloads/ (FileProvider). Die
+     * System-UI zeichnet die Benachrichtigung und braucht dafür Leserecht.
+     */
+    private fun contentUri(context: Context, path: String?): Uri? {
+        if (path.isNullOrEmpty()) return null
+        val file = File(path)
+        if (!file.exists()) return null
+        return try {
+            val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+            context.grantUriPermission(SYSTEM_UI, uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            uri
+        } catch (e: Exception) {
+            Log.w(TAG, "contentUri failed for $path: ${e.message}")
+            null
+        }
+    }
+
+    /** Kleines Avatar-Bitmap (≈192 px) für das große Icon bei Direktnachrichten. */
+    private fun avatarBitmap(path: String?): Bitmap? {
+        if (path.isNullOrEmpty() || !File(path).exists()) return null
+        return try {
+            val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            BitmapFactory.decodeFile(path, bounds)
+            var sample = 1
+            while (bounds.outWidth / (sample * 2) >= 192 && bounds.outHeight / (sample * 2) >= 192) {
+                sample *= 2
+            }
+            BitmapFactory.decodeFile(path, BitmapFactory.Options().apply { inSampleSize = sample })
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    // ── Aktionen ──────────────────────────────────────────────────────────────
+
+    private fun mutableFlag() =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) PendingIntent.FLAG_MUTABLE else 0
+
+    // Reply action — BroadcastReceiver so replying NEVER opens the app.
+    // ReplyReceiver decrypts/sends via the background engine when killed.
+    // (ReplyReceiver has multiple RemoteInput key fallbacks for OEM quirks.)
+    private fun replyAction(context: Context, roomId: String, notifId: Int): NotificationCompat.Action {
+        val replyInput = RemoteInput.Builder(ReplyReceiver.REMOTE_INPUT_KEY)
+            .setLabel("Antworten…").build()
+        val replyIntent = Intent(context, ReplyReceiver::class.java).apply {
+            action = ReplyReceiver.ACTION_REPLY
+            putExtra(ReplyReceiver.EXTRA_ROOM_ID, roomId)
+            putExtra(ReplyReceiver.EXTRA_NOTIF_ID, notifId)
+        }
+        val replyPi = PendingIntent.getBroadcast(
+            context, notifId, replyIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or mutableFlag(),
+        )
+        return NotificationCompat.Action.Builder(0, "Antworten", replyPi)
+            .addRemoteInput(replyInput)
+            .setSemanticAction(NotificationCompat.Action.SEMANTIC_ACTION_REPLY)
+            .setShowsUserInterface(false)
+            .build()
+    }
+
+    // „Gelesen“ — schließt die Benachrichtigung UND setzt die Lesebestätigung
+    // bis zur neuesten Nachricht (ReplyReceiver → Haupt-Engine bzw. BgEngine).
+    private fun markReadAction(
+        context: Context, roomId: String, notifId: Int, eventId: String?,
+    ): NotificationCompat.Action {
+        val intent = Intent(context, ReplyReceiver::class.java).apply {
+            action = ReplyReceiver.ACTION_DISMISS
+            putExtra(ReplyReceiver.EXTRA_ROOM_ID, roomId)
+            putExtra(ReplyReceiver.EXTRA_NOTIF_ID, notifId)
+            putExtra(ReplyReceiver.EXTRA_EVENT_ID, eventId)
+        }
+        val pi = PendingIntent.getBroadcast(
+            context, notifId + 1_000_000, intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        return NotificationCompat.Action.Builder(0, "Gelesen", pi)
+            .setSemanticAction(NotificationCompat.Action.SEMANTIC_ACTION_MARK_AS_READ)
+            .setShowsUserInterface(false)
+            .build()
+    }
+
+    // Tap action — opens MainActivity to the right room.
+    private fun tapIntent(context: Context, roomId: String, notifId: Int): PendingIntent {
+        val tapIntent = Intent(context, MainActivity::class.java).apply {
+            action = Intent.ACTION_MAIN
+            addCategory(Intent.CATEGORY_LAUNCHER)
+            putExtra("room_id", roomId)
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP
+        }
+        return PendingIntent.getActivity(
+            context, notifId + 2_000_000, tapIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or mutableFlag(),
+        )
+    }
+
+    private fun prefs(context: Context) =
+        context.getSharedPreferences(STORE, Context.MODE_PRIVATE)
+
+    private fun nm(context: Context) =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+}
+
+private fun JSONObject.optStringOrNull(key: String): String? =
+    if (!has(key) || isNull(key)) null else optString(key).takeIf { it.isNotEmpty() }

android/app/src/main/kotlin/chat/pyramid/pyramid/PushService.kt

@@ -0,0 +1,183 @@
+package chat.pyramid.pyramid
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+import io.flutter.embedding.engine.FlutterEngineCache
+import io.flutter.plugin.common.MethodChannel
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+class PushService : FirebaseMessagingService() {
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        val data   = message.data
+        val roomId = data["room_id"] ?: run {
+            Log.d(TAG, "no room_id in payload, skipping")
+            return
+        }
+
+        val prefs = getSharedPreferences("FlutterSharedPreferences", MODE_PRIVATE)
+
+        // Skip if the Dart app is actively syncing (wrote a heartbeat < 20 s ago).
+        val heartbeat = try {
+            prefs.getLong("flutter.notif_app_heartbeat", 0L)
+                .takeIf { it > 0L }
+                ?: prefs.getInt("flutter.notif_app_heartbeat", 0).toLong()
+        } catch (_: Exception) { 0L }
+        if (System.currentTimeMillis() - heartbeat < 20_000L) {
+            Log.d(TAG, "app heartbeat fresh, skipping FCM notification")
+            return
+        }
+
+        val eventId = data["event_id"]
+        val notifId = NotificationHelper.stableId(roomId)
+        val hs      = (prefs.getString("flutter.notif_homeserver",   "") ?: "").trimEnd('/')
+        val token   = (prefs.getString("flutter.notif_access_token", "") ?: "")
+
+        // Fetch sender + room name on a background thread (main thread forbids I/O).
+        var meta = PushMeta()
+        if (hs.isNotEmpty() && token.isNotEmpty() && eventId != null) {
+            val latch = CountDownLatch(1)
+            Thread {
+                try { meta = fetchMeta(hs, token, roomId, eventId) ?: PushMeta() }
+                finally { latch.countDown() }
+            }.start()
+            latch.await(12L, TimeUnit.SECONDS)
+        }
+
+        Log.d(TAG, "handling push: sender=${meta.senderName} room=${meta.roomName} roomId=$roomId")
+
+        val engine = FlutterEngineCache.getInstance().get("main")
+        if (engine != null) {
+            // App backgrounded but alive — show placeholder immediately, then the
+            // warm main client decrypts and updates it (fast, barely visible).
+            meta.showPlaceholder(this, roomId, notifId, eventId)
+            if (eventId != null) {
+                val capturedRoomId  = roomId
+                val capturedEventId = eventId
+                val capturedNotifId = notifId
+                Handler(Looper.getMainLooper()).post {
+                    try {
+                        MethodChannel(engine.dartExecutor.binaryMessenger,
+                                      "chat.pyramid.pyramid/install")
+                            .invokeMethod("decryptAndUpdateNotification", mapOf(
+                                "room_id"  to capturedRoomId,
+                                "event_id" to capturedEventId,
+                                "notif_id" to capturedNotifId,
+                            ))
+                        Log.d(TAG, "decryptAndUpdateNotification invoked (main engine) for $capturedRoomId")
+                    } catch (e: Exception) {
+                        Log.w(TAG, "decryptAndUpdateNotification failed: ${e.message}")
+                    }
+                }
+            }
+        } else if (eventId != null) {
+            // App killed — decrypt FIRST via the background engine, then show the
+            // real content directly. The "Neue Nachricht" placeholder is only a
+            // fallback if decryption takes too long or fails.
+            Log.d(TAG, "main engine gone — decrypt-first via background engine for $roomId")
+            BgEngine.scheduleFallback(this, meta, roomId, notifId, eventId, 6_000L)
+            BgEngine.run(this, "decryptAndShow", mapOf(
+                "room_id"  to roomId,
+                "event_id" to eventId,
+                "notif_id" to notifId,
+            ))
+        } else {
+            // No event id to decrypt — just show the placeholder.
+            meta.showPlaceholder(this, roomId, notifId, null)
+        }
+    }
+
+    override fun onNewToken(token: String) {
+        Log.d(TAG, "FCM token refreshed — storing for Dart to re-register pusher")
+        getSharedPreferences("FlutterSharedPreferences", MODE_PRIVATE)
+            .edit()
+            .putString("flutter.fcm_pending_token", token)
+            .apply()
+    }
+
+    /** Absender + Raumname aus unverschlüsselten Room-States (für den Platzhalter). */
+    data class PushMeta(
+        val senderId: String = "",
+        val senderName: String = "Pyramid",
+        val roomName: String? = null,
+    ) {
+        fun showPlaceholder(context: android.content.Context, roomId: String, notifId: Int, eventId: String?) {
+            NotificationHelper.showMessage(
+                context, roomId, notifId, roomName, isGroup = roomName != null,
+                msg = NotificationHelper.Msg(
+                    eventId = eventId,
+                    senderKey = senderId.ifEmpty { senderName },
+                    senderName = senderName,
+                    body = NotificationHelper.PLACEHOLDER_BODY,
+                    timestamp = System.currentTimeMillis(),
+                ),
+            )
+        }
+    }
+
+    // ─── HTTP helpers ─────────────────────────────────────────────────────────
+
+    private fun fetchMeta(
+        hs: String, token: String, roomId: String, eventId: String
+    ): PushMeta? {
+        return try {
+            val encRoom  = java.net.URLEncoder.encode(roomId,  "UTF-8")
+            val encEvent = java.net.URLEncoder.encode(eventId, "UTF-8")
+
+            val event = httpGet("$hs/_matrix/client/v3/rooms/$encRoom/event/$encEvent", token)
+                ?: return null
+
+            val senderId  = event.optString("sender")
+            var senderName = senderId.split(":").firstOrNull()?.removePrefix("@") ?: ""
+
+            if (senderId.isNotEmpty()) {
+                val encSender = java.net.URLEncoder.encode(senderId, "UTF-8")
+                val member = httpGet(
+                    "$hs/_matrix/client/v3/rooms/$encRoom/state/m.room.member/$encSender", token)
+                val name = member?.optString("displayname")
+                if (!name.isNullOrEmpty()) senderName = name
+            }
+
+            val nameState = httpGet("$hs/_matrix/client/v3/rooms/$encRoom/state/m.room.name", token)
+            val roomName  = nameState?.optString("name")
+
+            return PushMeta(
+                senderId = senderId,
+                senderName = senderName.ifEmpty { "Pyramid" },
+                roomName = roomName?.takeIf { it.isNotEmpty() },
+            )
+        } catch (e: Exception) {
+            Log.w(TAG, "fetchTitle failed: ${e.message}")
+            null
+        }
+    }
+
+    private fun httpGet(url: String, token: String): JSONObject? {
+        var conn: HttpURLConnection? = null
+        return try {
+            conn = (URL(url).openConnection() as HttpURLConnection).apply {
+                requestMethod = "GET"
+                setRequestProperty("Authorization", "Bearer $token")
+                connectTimeout = 8_000
+                readTimeout    = 8_000
+            }
+            if (conn.responseCode != 200) return null
+            JSONObject(conn.inputStream.bufferedReader().readText())
+        } catch (_: Exception) {
+            null
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    companion object {
+        private const val TAG = "PYRAMID-PUSH"
+    }
+}

android/app/src/main/kotlin/chat/pyramid/pyramid/ReplyReceiver.kt

@@ -0,0 +1,112 @@
+package chat.pyramid.pyramid
+
+import android.app.NotificationManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import androidx.core.app.RemoteInput
+import io.flutter.embedding.engine.FlutterEngineCache
+import io.flutter.plugin.common.MethodChannel
+
+class ReplyReceiver : BroadcastReceiver() {
+
+    companion object {
+        const val ACTION_REPLY   = "chat.pyramid.pyramid.REPLY"
+        const val ACTION_DISMISS = "chat.pyramid.pyramid.DISMISS"
+        const val EXTRA_ROOM_ID  = "room_id"
+        const val EXTRA_NOTIF_ID = "notif_id"
+        const val EXTRA_EVENT_ID = "event_id"
+        const val REMOTE_INPUT_KEY = "reply_text"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val roomId  = intent.getStringExtra(EXTRA_ROOM_ID) ?: return
+        val notifId = intent.getIntExtra(EXTRA_NOTIF_ID, 0)
+
+        // Dismiss the notification immediately; its message history goes too.
+        (context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager)
+            .cancel(notifId)
+        NotificationHelper.clearHistory(context, roomId)
+
+        if (intent.action == ACTION_DISMISS) {
+            markRead(context, roomId, intent.getStringExtra(EXTRA_EVENT_ID))
+            return
+        }
+
+        // Extract inline reply text.  Some Samsung/MIUI/OEM devices drop the
+        // RemoteInput bundle or use a different key — try multiple fallbacks.
+        val remoteInput = RemoteInput.getResultsFromIntent(intent)
+        val replyText = remoteInput?.let { bundle ->
+            bundle.getCharSequence(REMOTE_INPUT_KEY)?.toString()?.trim()
+                ?: bundle.keySet()?.firstOrNull()?.let { bundle.getCharSequence(it)?.toString()?.trim() }
+        } ?: intent.getStringExtra(REMOTE_INPUT_KEY)
+          ?: intent.getStringExtra("input")
+          ?: intent.getStringExtra("notification_action_input")
+          ?: intent.getStringExtra("reply_text")
+        Log.d("PYRAMID-REPLY", "extracted replyText=${replyText?.take(20)} (remoteInput=${remoteInput != null})")
+        if (replyText.isNullOrEmpty()) {
+            Log.w("PYRAMID-REPLY", "reply text empty after all fallbacks, aborting")
+            return
+        }
+
+        Log.d("PYRAMID-REPLY", "reply received: room=$roomId text=$replyText")
+
+        // Fast path: Flutter engine is alive — forward directly via MethodChannel.
+        val engine = FlutterEngineCache.getInstance().get("main")
+        if (engine != null) {
+            Log.d("PYRAMID-REPLY", "Flutter engine alive → MethodChannel")
+            try {
+                MethodChannel(engine.dartExecutor.binaryMessenger, "chat.pyramid.pyramid/install")
+                    .invokeMethod("replyFromNotification",
+                        mapOf("room_id" to roomId, "text" to replyText))
+                return
+            } catch (e: Exception) {
+                Log.w("PYRAMID-REPLY", "MethodChannel failed: ${e.message}, falling back to prefs")
+            }
+        }
+
+        // Slow path: app killed — send the encrypted reply via the background
+        // engine (no Activity, fully silent). _bgSendReply falls back to the
+        // prefs queue itself if it can't send, so nothing is lost.
+        // goAsync() keeps this BroadcastReceiver's process alive while the engine
+        // boots + sends (otherwise it could be killed right after onReceive).
+        Log.d("PYRAMID-REPLY", "Flutter engine not running → background engine send")
+        val pending = goAsync()
+        BgEngine.run(context, "sendReply", mapOf(
+            "room_id" to roomId,
+            "text"    to replyText,
+        ))
+        // Release after a window long enough for sync + encrypted send (~4 s seen
+        // in logs; 15 s gives margin). The engine completes independently.
+        android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            try { pending.finish() } catch (_: Exception) {}
+        }, 15_000L)
+    }
+
+    /**
+     * „Gelesen“: Lesebestätigung bis [eventId] setzen – über die laufende
+     * Haupt-Engine oder (App beendet) still über die BgEngine. Ohne eventId
+     * (alter Platzhalter) bleibt es beim Schließen.
+     */
+    private fun markRead(context: Context, roomId: String, eventId: String?) {
+        Log.d("PYRAMID-REPLY", "mark-read action for room $roomId event=$eventId")
+        if (eventId.isNullOrEmpty()) return
+        val args = mapOf("room_id" to roomId, "event_id" to eventId)
+        val engine = FlutterEngineCache.getInstance().get("main")
+        if (engine != null) {
+            try {
+                MethodChannel(engine.dartExecutor.binaryMessenger, "chat.pyramid.pyramid/install")
+                    .invokeMethod("markReadFromNotification", args)
+                return
+            } catch (e: Exception) {
+                Log.w("PYRAMID-REPLY", "markRead via main engine failed: ${e.message}")
+            }
+        }
+        val pending = goAsync()
+        BgEngine.run(context, "markRead", args)
+        android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            try { pending.finish() } catch (_: Exception) {}
+        }, 10_000L)
+    }
+}

android/app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Adaptive icon foreground — 108×108dp canvas.
+  Safe zone: inner 66dp (21–87). Pyramid fills ~56% of visible 72dp circle.
+  Derived from assets/logo.svg (48×48 viewBox, scale=1.1, centered at (54,54)).
+  Draw order matches SVG: right face behind, left face in front, then strokes on top.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+
+    <!-- Right face — pyr-side, diagonal gradient 85%→25% opacity -->
+    <path android:pathData="M54,35 L74,73 L54,66 Z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:type="linear"
+                android:startX="54" android:startY="35"
+                android:endX="74"   android:endY="73">
+                <item android:offset="0" android:color="#D9F5A524"/>
+                <item android:offset="1" android:color="#40F5A524"/>
+            </gradient>
+        </aapt:attr>
+    </path>
+
+    <!-- Left face — pyr-face, vertical gradient 100%→55% opacity -->
+    <path android:pathData="M54,35 L34,73 L54,66 Z">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:type="linear"
+                android:startX="54" android:startY="35"
+                android:endX="54"   android:endY="73">
+                <item android:offset="0" android:color="#FFF5A524"/>
+                <item android:offset="1" android:color="#8CF5A524"/>
+            </gradient>
+        </aapt:attr>
+    </path>
+
+    <!-- Base outline — stroke 40% opacity, width 1.1dp, linejoin round -->
+    <path android:pathData="M34,73 L54,66 L74,73"
+        android:fillColor="#00000000"
+        android:strokeColor="#66F5A524"
+        android:strokeWidth="1.1"
+        android:strokeLineJoin="round"/>
+
+    <!-- Edge highlight / center spine — stroke 90% opacity, width 0.88dp -->
+    <path android:pathData="M54,35 L54,66"
+        android:fillColor="#00000000"
+        android:strokeColor="#E6F5A524"
+        android:strokeWidth="0.9"/>
+
+</vector>

android/app/src/main/res/drawable/ic_notification.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="48"
+    android:viewportHeight="48">
+    <!-- Pyramid shape: left face -->
+    <path
+        android:pathData="M24,6 L6,40 L24,34 Z"
+        android:fillColor="#FFFFFF"/>
+    <!-- Pyramid shape: right face -->
+    <path
+        android:pathData="M24,6 L42,40 L24,34 Z"
+        android:fillColor="#CCFFFFFF"/>
+</vector>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

android/app/src/main/res/values-night/styles.xml

@@ -15,4 +15,10 @@
     <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
         <item name="android:windowBackground">?android:colorBackground</item>
     </style>
+    <style name="ReplyHandlerTheme" parent="@android:style/Theme.Translucent.NoTitleBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:backgroundDimEnabled">false</item>
+    </style>
 </resources>

android/app/src/main/res/values/colors.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#1A1B1E</color>
+</resources>

android/app/src/main/res/values/styles.xml

@@ -15,4 +15,12 @@
     <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
         <item name="android:windowBackground">?android:colorBackground</item>
     </style>
+    <!-- Used when the activity is launched solely to handle a notification reply.
+         The window is fully transparent so the user never sees the UI open. -->
+    <style name="ReplyHandlerTheme" parent="@android:style/Theme.Translucent.NoTitleBar">
+        <item name="android:windowIsTranslucent">true</item>
+        <item name="android:windowBackground">@android:color/transparent</item>
+        <item name="android:windowContentOverlay">@null</item>
+        <item name="android:backgroundDimEnabled">false</item>
+    </style>
 </resources>

android/app/src/main/res/xml/data_extraction_rules.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Kein Cloud-Backup und keine Gerät-zu-Gerät-Übertragung der App-Daten
+  (Android 12+). Grund: Die lokale Datenbank ist mit SQLCipher verschlüsselt,
+  ihr Schlüssel liegt im Android-Keystore und zieht NICHT mit um – eine
+  übertragene Datenbank ließe sich auf dem neuen Gerät nicht öffnen
+  (AppDatabase bricht dann bewusst ab, statt Daten zu überschreiben).
+  Außerdem enthalten die SharedPreferences den Zugangsschlüssel für den
+  Push-Dienst. Matrix-Weg auf neuem Gerät: neu anmelden + Schlüssel mit dem
+  Wiederherstellungsschlüssel aus dem Server-Backup holen.
+-->
+<data-extraction-rules>
+    <cloud-backup>
+        <exclude domain="root" path="." />
+        <exclude domain="file" path="." />
+        <exclude domain="database" path="." />
+        <exclude domain="sharedpref" path="." />
+        <exclude domain="external" path="." />
+    </cloud-backup>
+    <device-transfer>
+        <exclude domain="root" path="." />
+        <exclude domain="file" path="." />
+        <exclude domain="database" path="." />
+        <exclude domain="sharedpref" path="." />
+        <exclude domain="external" path="." />
+    </device-transfer>
+</data-extraction-rules>

android/gradle.properties

@@ -1,2 +1,6 @@
 org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
+# This builtInKotlin flag was added automatically by Flutter migrator
+android.builtInKotlin=false
+# This newDsl flag was added automatically by Flutter migrator
+android.newDsl=false

android/gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-all.zip

android/settings.gradle.kts

@@ -21,6 +21,7 @@ plugins {
     id("dev.flutter.flutter-plugin-loader") version "1.0.0"
     id("com.android.application") version "8.11.1" apply false
     id("org.jetbrains.kotlin.android") version "2.2.20" apply false
+    id("com.google.gms.google-services") version "4.4.4" apply false
 }
 
 include(":app")

assets/logo.svg

@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" fill="none">
+  <defs>
+    <linearGradient id="pyr-face" x1="0" x2="0" y1="0" y2="1">
+      <stop offset="0" stop-color="#F5A524" stop-opacity="1" />
+      <stop offset="1" stop-color="#F5A524" stop-opacity="0.55" />
+    </linearGradient>
+    <linearGradient id="pyr-side" x1="0" x2="1" y1="0" y2="1">
+      <stop offset="0" stop-color="#F5A524" stop-opacity="0.85" />
+      <stop offset="1" stop-color="#F5A524" stop-opacity="0.25" />
+    </linearGradient>
+  </defs>
+  <!-- right face -->
+  <path d="M24 6 L42 40 L24 34 Z" fill="url(#pyr-side)" />
+  <!-- left face (front) -->
+  <path d="M24 6 L6 40 L24 34 Z" fill="url(#pyr-face)" />
+  <!-- base outline -->
+  <path d="M6 40 L24 34 L42 40" stroke="#F5A524" stroke-opacity="0.4" stroke-width="1" fill="none" stroke-linejoin="round" />
+  <!-- edge highlight -->
+  <path d="M24 6 L24 34" stroke="#F5A524" stroke-opacity="0.9" stroke-width="0.8" />
+</svg>

assets/pyramid-loader.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200">
+  <path d="M100 30 L175 160 L25 150 Z" fill="currentColor" />
+  <path d="M100 30 L110 160 L100 150 Z" fill="white" opacity="0.2" />
+</svg>

autopilot.ps1

@@ -0,0 +1,25 @@
+# Pyramid-Autopilot: startet Claude-Sessions in Endlosschleife.
+# Läuft eine Session ins 5h-Limit, wird alle 20 Minuten ein Neustart versucht,
+# bis das Kontingent wieder da ist. Stoppen: Strg+C oder Fenster schließen.
+#
+# Start:  Rechtsklick → "Mit PowerShell ausführen"
+#   oder: pwsh -File autopilot.ps1
+
+Set-Location $PSScriptRoot
+
+$prompt = "Lies CLAUDE.md und arbeite ROADMAP.md Punkt für Punkt weiter ab. " +
+          "Halte dich strikt an den Arbeitszyklus (PROGRESS.md pflegen, kleine Commits + Push). " +
+          "Arbeite so viele Punkte ab wie möglich."
+
+while ($true) {
+    $ts = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    Add-Content autopilot.log "`n===== [$ts] Neue Claude-Session ====="
+    Write-Host "`n===== [$ts] Neue Claude-Session (Log: autopilot.log) =====" -ForegroundColor Cyan
+
+    claude -p $prompt --dangerously-skip-permissions 2>&1 | Tee-Object -FilePath autopilot.log -Append
+
+    $ts = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    Add-Content autopilot.log "===== [$ts] Session beendet - naechster Versuch in 20 Minuten ====="
+    Write-Host "===== [$ts] Session beendet - naechster Versuch in 20 Minuten (Strg+C zum Stoppen) =====" -ForegroundColor Yellow
+    Start-Sleep -Seconds 1200
+}

autopilot.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+# Pyramid-Autopilot (Pi/Linux): startet Claude-Sessions in Endlosschleife.
+# Laeuft eine Session ins Limit, wird alle 20 Minuten neu versucht.
+# Start (am besten in tmux):  tmux new -d -s pyramid ./autopilot.sh
+# Wieder reinschauen:         tmux attach -t pyramid   (verlassen: Strg+B, dann D)
+# PAUSIEREN:                  touch ~/pyramid/PAUSE    (greift vor der naechsten Session)
+# FORTSETZEN:                 rm ~/pyramid/PAUSE
+# GANZ STOPPEN:               tmux kill-session -t pyramid
+cd "$(dirname "$0")"
+export PATH="$HOME/.local/bin:$HOME/flutter/bin:$PATH"
+
+# --- NUR EIN Konto: das nordmann-Konto (Profil ~/.claude = Standard-Profil) ---
+# Bewusst KEINE Konto-Rotation (Bernd, 2026-07-06): der Pyramid-Autopilot arbeitet
+# ausschliesslich mit dem nordmann-Konto. Das Standard-Profil liegt unter
+# ~/.claude / ~/.claude.json -> CLAUDE_CONFIG_DIR NICHT setzen (sonst sucht Claude
+# die Config faelschlich unter ~/.claude/.claude.json).
+# (Die E-Mail-Adresse des Kontos steht absichtlich NICHT hier: das Gitea-Repo
+# ist oeffentlich, PII gehoert nicht hinein.)
+apply_account() { unset CLAUDE_CONFIG_DIR; }
+ACCOUNT_NAME="nordmann"
+
+# --- Matrix-Statusberichte (Raum "🔺 Pyramid Autopilot", Token vom Gatus-Bot) ---
+MATRIX_URL="http://127.0.0.1:6167"
+MATRIX_ROOM="!sYfOwD4Dw4jBDTlNmL:steggi-matrix.work"
+MATRIX_TOKEN="$(grep -s '^MATRIX_TOKEN=' "$HOME/gatus/.env" | cut -d= -f2-)"
+
+notify_matrix() {
+  [ -z "$MATRIX_TOKEN" ] && return 0
+  local body
+  body=$(python3 -c 'import json,sys; print(json.dumps({"msgtype":"m.text","body":sys.stdin.read().strip()}))' <<< "$1")
+  curl -s -m 10 -X PUT \
+    "$MATRIX_URL/_matrix/client/v3/rooms/$MATRIX_ROOM/send/m.room.message/autopilot$(date +%s%N)" \
+    -H "Authorization: Bearer $MATRIX_TOKEN" -H "Content-Type: application/json" \
+    -d "$body" > /dev/null || true
+}
+
+PROMPT="Lies CLAUDE.md. Arbeite in dieser Reihenfolge:  (1) Review-Pass: Gehe die in ROADMAP.md/PROGRESS.md als erledigt markierten Punkte durch,  prüfe den zugehörigen Code kritisch und überarbeite/verbessere ihn, wo nötig.  Führe in PROGRESS.md einen Abschnitt 'Fable-5-Review' und hake dort jeden geprüften Punkt ab,  damit bereits reviewte Punkte nicht erneut geprüft werden.  (2) Wenn alle erledigten Punkte reviewt sind, arbeite ROADMAP.md Punkt für Punkt weiter ab.  Halte dich strikt an den Arbeitszyklus (PROGRESS.md pflegen, kleine Commits + Push).  Arbeite so viel ab wie möglich."
+
+while true; do
+  if [ -f PAUSE ]; then
+    echo "===== $(date '+%F %T') PAUSE aktiv (rm PAUSE zum Fortsetzen) - pruefe wieder in 10 Minuten ====="
+    sleep 600
+    continue
+  fi
+  apply_account
+  echo "===== $(date '+%F %T') Neue Claude-Session (Konto $ACCOUNT_NAME) =====" | tee -a autopilot.log
+  BEFORE=$(git rev-parse HEAD 2>/dev/null)
+  SESSION_OUT=$(mktemp)
+  claude -p "$PROMPT" --model claude-fable-5 --dangerously-skip-permissions 2>&1 | tee -a autopilot.log "$SESSION_OUT"
+  AFTER=$(git rev-parse HEAD 2>/dev/null)
+  if [ -n "$BEFORE" ] && [ "$BEFORE" != "$AFTER" ]; then
+    COMMITS=$(git log --oneline --no-decorate "$BEFORE..$AFTER" | head -15)
+    NEXT=$(grep -m1 -A3 "Offen/Nächster Schritt" PROGRESS.md)
+    notify_matrix "🔺 Pyramid-Autopilot $(date '+%H:%M') – Session fertig.
+
+Neue Commits:
+$COMMITS
+
+$NEXT"
+  fi
+  # Limit erkannt? -> 20 Minuten warten (KEINE Konto-Rotation mehr)
+  if grep -qiE "hit your.*limit|usage limit|session limit" "$SESSION_OUT"; then
+    rm -f "$SESSION_OUT"
+    echo "===== $(date '+%F %T') nordmann-Konto am Limit - naechster Versuch in 20 Minuten =====" | tee -a autopilot.log
+    sleep 1200
+    continue
+  fi
+  rm -f "$SESSION_OUT"
+
+  echo "===== $(date '+%F %T') Session beendet - Neustart in 20 Minuten (Strg+C zum Stoppen) =====" | tee -a autopilot.log
+  sleep 1200
+done

benchmark/baseline/db.json

@@ -0,0 +1,151 @@
+{
+  "suite": "db",
+  "timestamp": "2026-10-07T11:35:13.322832",
+  "git": "b2413ef",
+  "host": {
+    "os": "\"Windows 11 Home\" 10.0 (Build 26200)",
+    "cpus": 12
+  },
+  "params": {
+    "rooms": 20,
+    "eventsPerRoom": 500
+  },
+  "metrics": {
+    "klartext.write_total_ms": {
+      "label": "[klartext] Sync-Schreiben, 10000 Nachrichten",
+      "unit": "ms",
+      "value": 2513.443,
+      "min": 2469.054,
+      "runs": 2,
+      "compare": true
+    },
+    "klartext.write_per_event_us": {
+      "label": "[klartext] Sync-Schreiben je Nachricht",
+      "unit": "µs",
+      "value": 251.344,
+      "runs": 1,
+      "compare": true
+    },
+    "klartext.startup_ms": {
+      "label": "[klartext] App-Start: DB + Raumliste",
+      "unit": "ms",
+      "value": 4.121,
+      "min": 3.254,
+      "runs": 6,
+      "compare": true
+    },
+    "klartext.open_chat_ms": {
+      "label": "[klartext] Chat öffnen (50 Nachr.)",
+      "unit": "ms",
+      "value": 0.328,
+      "min": 0.286,
+      "runs": 6,
+      "compare": true
+    },
+    "klartext.search_miss_ms": {
+      "label": "[klartext] Suche ohne Treffer (Worst Case)",
+      "unit": "ms",
+      "value": 63.897,
+      "min": 63.716,
+      "runs": 4,
+      "compare": true
+    },
+    "klartext.search_hit_ms": {
+      "label": "[klartext] Suche mit Treffern",
+      "unit": "ms",
+      "value": 31.777,
+      "min": 31.202,
+      "runs": 4,
+      "compare": true
+    },
+    "klartext.size_mb": {
+      "label": "[klartext] DB-Größe inkl. WAL",
+      "unit": "MB",
+      "value": 4.008,
+      "runs": 1,
+      "compare": false
+    },
+    "sqlcipher.write_total_ms": {
+      "label": "[sqlcipher] Sync-Schreiben, 10000 Nachrichten",
+      "unit": "ms",
+      "value": 2615.633,
+      "min": 2456.356,
+      "runs": 2,
+      "compare": true
+    },
+    "sqlcipher.write_per_event_us": {
+      "label": "[sqlcipher] Sync-Schreiben je Nachricht",
+      "unit": "µs",
+      "value": 261.563,
+      "runs": 1,
+      "compare": true
+    },
+    "sqlcipher.startup_ms": {
+      "label": "[sqlcipher] App-Start: DB + Raumliste",
+      "unit": "ms",
+      "value": 4.313,
+      "min": 3.718,
+      "runs": 6,
+      "compare": true
+    },
+    "sqlcipher.open_chat_ms": {
+      "label": "[sqlcipher] Chat öffnen (50 Nachr.)",
+      "unit": "ms",
+      "value": 0.323,
+      "min": 0.309,
+      "runs": 6,
+      "compare": true
+    },
+    "sqlcipher.search_miss_ms": {
+      "label": "[sqlcipher] Suche ohne Treffer (Worst Case)",
+      "unit": "ms",
+      "value": 63.748,
+      "min": 62.8,
+      "runs": 4,
+      "compare": true
+    },
+    "sqlcipher.search_hit_ms": {
+      "label": "[sqlcipher] Suche mit Treffern",
+      "unit": "ms",
+      "value": 31.676,
+      "min": 31.296,
+      "runs": 4,
+      "compare": true
+    },
+    "sqlcipher.size_mb": {
+      "label": "[sqlcipher] DB-Größe inkl. WAL",
+      "unit": "MB",
+      "value": 4.098,
+      "runs": 1,
+      "compare": false
+    },
+    "cipher_overhead.write_total_ms": {
+      "label": "Aufschlag Verschlüsselung: Sync-Schreiben",
+      "unit": "%",
+      "value": 4.066,
+      "runs": 1,
+      "compare": false
+    },
+    "cipher_overhead.startup_ms": {
+      "label": "Aufschlag Verschlüsselung: App-Start",
+      "unit": "%",
+      "value": 4.634,
+      "runs": 1,
+      "compare": false
+    },
+    "cipher_overhead.open_chat_ms": {
+      "label": "Aufschlag Verschlüsselung: Chat öffnen",
+      "unit": "%",
+      "value": -1.388,
+      "runs": 1,
+      "compare": false
+    },
+    "cipher_overhead.search_miss_ms": {
+      "label": "Aufschlag Verschlüsselung: Suche ohne Treffer",
+      "unit": "%",
+      "value": -0.233,
+      "runs": 1,
+      "compare": false
+    }
+  }
+}

benchmark/baseline/migration.json

@@ -0,0 +1,37 @@
+{
+  "suite": "migration",
+  "timestamp": "2026-10-07T11:35:21.106818",
+  "git": "b2413ef",
+  "host": {
+    "os": "\"Windows 11 Home\" 10.0 (Build 26200)",
+    "cpus": 12
+  },
+  "params": {
+    "rooms": 20,
+    "eventsPerRoom": 1000
+  },
+  "metrics": {
+    "db_size_mb": {
+      "label": "DB-Größe vor Migration",
+      "unit": "MB",
+      "value": 7.793,
+      "runs": 1,
+      "compare": false
+    },
+    "migrate_ms": {
+      "label": "Migration gesamt",
+      "unit": "ms",
+      "value": 325.058,
+      "min": 322.058,
+      "runs": 3,
+      "compare": true
+    },
+    "migrate_ms_per_mb": {
+      "label": "Migration je MB",
+      "unit": "ms/MB",
+      "value": 41.712,
+      "runs": 1,
+      "compare": true
+    }
+  }
+}

benchmark/db_benchmark_test.dart

@@ -0,0 +1,257 @@
+// Benchmarks sind Test-Code, liegen aber bewusst außerhalb von test/ (sie
+// sollen in einem normalen `flutter test` NICHT mitlaufen) – deshalb kennt
+// der Analyzer sie nicht als Tests.
+// ignore_for_file: invalid_use_of_visible_for_testing_member
+@TestOn('windows')
+library;
+
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:matrix/matrix.dart';
+import 'package:path/path.dart' as p;
+import 'package:pyramid/core/app_database.dart';
+import 'package:pyramid/features/search/local_message_search.dart';
+import 'package:sqflite_common_ffi/sqflite_ffi.dart';
+
+import '../test/support/synthetic_matrix_data.dart';
+import 'support/bench.dart';
+
+/// Datenbank-Benchmark: Was kostet die SQLCipher-Verschlüsselung im Alltag?
+///
+/// Misst – jeweils für eine Klartext-DB und eine SQLCipher-DB mit DERSELBEN
+/// Bibliothek aus dem App-Build – die vier Wege, auf denen Nutzer die DB
+/// spüren:
+///  1. Sync-Schreiben (Nachrichten landen in Transaktionen wie beim Sync),
+///  2. App-Start (DB öffnen + SDK-Schema + Raumliste laden),
+///  3. Chat öffnen (50 neueste Nachrichten eines Raums),
+///  4. lokale Suche (Strg+K) – ohne Treffer = Worst Case, scannt alles.
+///
+/// Daten sind synthetisch (`test/support/synthetic_matrix_data.dart`), laufen
+/// aber über die echte SDK-Speicherschicht. Lauf:
+///   flutter test benchmark/db_benchmark_test.dart
+/// oder alles zusammen über `scripts/test.ps1 -Bench`.
+
+const _modes = ['klartext', 'sqlcipher'];
+
+const _benchKey =
+    '0b1e2c3d4f5a6b7c8d9e0f1a2b3c4d5e6f708192a3b4c5d6e7f8091a2b3c4d5e';
+
+void main() {
+  final skip = findCipherDll() == null
+      ? 'SQLCipher-DLL fehlt – erst "flutter build windows" ausführen'
+      : null;
+
+  test(
+    'DB: Klartext vs. SQLCipher',
+    () async {
+      final rooms = scaled(20);
+      final eventsPerRoom = scaled(500);
+      final totalEvents = rooms * eventsPerRoom;
+      final report = BenchReport(
+        'db',
+        params: {'rooms': rooms, 'eventsPerRoom': eventsPerRoom},
+      );
+      final factory = cipherFactory();
+      final tempDir = await Directory.systemTemp.createTemp('pyramid_bench_db');
+
+      Future<Database> openBenchDb(String mode, String path) async {
+        final db = mode == 'sqlcipher'
+            ? await AppDatabase.openEncrypted(factory, path, _benchKey)
+            : await factory.openDatabase(path);
+        await applyAppPragmas(db);
+        return db;
+      }
+
+      try {
+        // Ungemessener Aufwärm-Durchlauf (JIT, DB-Isolate, SQLCipher-Init).
+        // Bewusst mit voller Raumgröße: Der JIT optimiert die SDK-Pfade erst
+        // nach vielen Aufrufen mit wachsender Fragment-Liste – mit einem
+        // Mini-Durchlauf war die erste Messrunde noch ~45 % langsamer.
+        for (final mode in _modes) {
+          final path = p.join(tempDir.path, 'warmup_$mode.sqlite');
+          final client = await SyntheticMatrixData.openClient(
+            await openBenchDb(mode, path),
+          );
+          await SyntheticMatrixData.populate(
+            client,
+            rooms: (rooms ~/ 4).clamp(1, rooms),
+            eventsPerRoom: eventsPerRoom,
+          );
+          await SyntheticMatrixData.loadRooms(client);
+          await localMessageSearch(client, 'aufwärmen');
+          await client.dispose(closeDatabase: true);
+        }
+
+        // Gemessen wird abwechselnd A-B-B-A: Die Schreibkosten sind von
+        // Dart-Code (SDK-JSON) dominiert, und der JIT wird während des Laufs
+        // weiter schneller. Ohne das Muster gewinnt einfach der später
+        // gemessene Modus (2026-10-07 nachgemessen: ±20 % je nach Reihenfolge).
+        const order = ['klartext', 'sqlcipher', 'sqlcipher', 'klartext'];
+        final timings = {
+          for (final mode in _modes) mode: <String, List<double>>{},
+        };
+        void record(String mode, String metric, Iterable<double> values) =>
+            timings[mode]!.putIfAbsent(metric, () => []).addAll(values);
+
+        // 1. Sync-Schreiben – je Runde eine frische DB.
+        final paths = <String, String>{};
+        for (var round = 0; round < order.length; round++) {
+          final mode = order[round];
+          final path = p.join(tempDir.path, '${mode}_$round.sqlite');
+          final client = await SyntheticMatrixData.openClient(
+            await openBenchDb(mode, path),
+          );
+          final watch = Stopwatch()..start();
+          await SyntheticMatrixData.populate(
+            client,
+            rooms: rooms,
+            eventsPerRoom: eventsPerRoom,
+            needleEvery: 97,
+          );
+          watch.stop();
+          await client.dispose(closeDatabase: true);
+          record(mode, 'write', [watch.elapsedMicroseconds / 1000]);
+          paths[mode] = path;
+        }
+
+        // 2. App-Start: DB öffnen + SDK-Schema + Raumliste, danach wieder
+        //    schließen – wie ein Neustart. Eigene Runde VOR den Lese-Messungen:
+        //    sqflite liefert für denselben Pfad dieselbe Verbindung zurück,
+        //    ein Schließen hier würde sonst deren offene Verbindung kappen.
+        for (final mode in order) {
+          record(
+            mode,
+            'startup',
+            await sample(() async {
+              final c = await SyntheticMatrixData.openClient(
+                await openBenchDb(mode, paths[mode]!),
+              );
+              await SyntheticMatrixData.loadRooms(c);
+              await c.dispose(closeDatabase: true);
+            }, runs: 3),
+          );
+        }
+
+        // 3.–4. Lesen auf der jeweils zuletzt geschriebenen DB.
+        final clients = <String, Client>{};
+        final roomLists = <String, List<Room>>{};
+        for (final mode in _modes) {
+          final client = await SyntheticMatrixData.openClient(
+            await openBenchDb(mode, paths[mode]!),
+          );
+          clients[mode] = client;
+          roomLists[mode] = await SyntheticMatrixData.loadRooms(client);
+          expect(
+            roomLists[mode],
+            hasLength(rooms),
+            reason: 'Raumliste vollständig ($mode)',
+          );
+        }
+        for (final mode in order) {
+          final client = clients[mode]!;
+          record(
+            mode,
+            'open_chat',
+            (await sample(() async {
+              for (final room in roomLists[mode]!) {
+                final page = await client.database.getEventList(
+                  room,
+                  limit: 50,
+                );
+                if (page.length != 50) throw StateError('Seite unvollständig');
+              }
+            }, runs: 3)).map((t) => t / rooms),
+          );
+          record(
+            mode,
+            'search_miss',
+            await sample(
+              () => localMessageSearch(client, 'gibtsnichtwort'),
+              runs: 2,
+            ),
+          );
+          record(
+            mode,
+            'search_hit',
+            await sample(
+              () => localMessageSearch(client, 'nadelwort'),
+              runs: 2,
+            ),
+          );
+        }
+        for (final client in clients.values) {
+          await client.dispose(closeDatabase: true);
+        }
+
+        for (final mode in _modes) {
+          final t = timings[mode]!;
+          final writeMs = median(t['write']!);
+          report.addTimings(
+            '$mode.write_total_ms',
+            '[$mode] Sync-Schreiben, $totalEvents Nachrichten',
+            t['write']!,
+          );
+          report.addValue(
+            '$mode.write_per_event_us',
+            '[$mode] Sync-Schreiben je Nachricht',
+            writeMs * 1000 / totalEvents,
+            'µs',
+            compare: true,
+          );
+          report.addTimings(
+            '$mode.startup_ms',
+            '[$mode] App-Start: DB + Raumliste',
+            t['startup']!,
+          );
+          report.addTimings(
+            '$mode.open_chat_ms',
+            '[$mode] Chat öffnen (50 Nachr.)',
+            t['open_chat']!,
+          );
+          report.addTimings(
+            '$mode.search_miss_ms',
+            '[$mode] Suche ohne Treffer (Worst Case)',
+            t['search_miss']!,
+          );
+          report.addTimings(
+            '$mode.search_hit_ms',
+            '[$mode] Suche mit Treffern',
+            t['search_hit']!,
+          );
+          report.addValue(
+            '$mode.size_mb',
+            '[$mode] DB-Größe inkl. WAL',
+            dbSizeMb(paths[mode]!),
+            'MB',
+          );
+        }
+
+        for (final (id, label) in [
+          ('write_total_ms', 'Sync-Schreiben'),
+          ('startup_ms', 'App-Start'),
+          ('open_chat_ms', 'Chat öffnen'),
+          ('search_miss_ms', 'Suche ohne Treffer'),
+        ]) {
+          final plain = report.valueOf('klartext.$id');
+          final enc = report.valueOf('sqlcipher.$id');
+          report.addValue(
+            'cipher_overhead.$id',
+            'Aufschlag Verschlüsselung: $label',
+            (enc / plain - 1) * 100,
+            '%',
+          );
+        }
+
+        final regressions = await report.finish();
+        if (strictBench) expect(regressions, isEmpty);
+      } finally {
+        try {
+          await tempDir.delete(recursive: true);
+        } catch (_) {}
+      }
+    },
+    skip: skip,
+    timeout: const Timeout(Duration(minutes: 20)),
+  );
+}

benchmark/migration_benchmark_test.dart

@@ -0,0 +1,124 @@
+// Benchmarks sind Test-Code, liegen aber bewusst außerhalb von test/ (sie
+// sollen in einem normalen `flutter test` NICHT mitlaufen) – deshalb kennt
+// der Analyzer sie nicht als Tests.
+// ignore_for_file: invalid_use_of_visible_for_testing_member
+@TestOn('windows')
+library;
+
+import 'dart:io';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:path/path.dart' as p;
+import 'package:pyramid/core/app_database.dart';
+
+import '../test/support/synthetic_matrix_data.dart';
+import 'support/bench.dart';
+
+/// Migrations-Benchmark: Wie lange dauert die einmalige Umstellung
+/// Klartext → SQLCipher beim ersten Start nach dem Update (Utas Fall)?
+///
+/// Baut eine Klartext-DB über die echte SDK-Speicherschicht, kopiert sie vor
+/// jedem Durchlauf frisch und misst `AppDatabase.migratePlaintextToEncrypted`
+/// (exakt der App-Codepfad: Checkpoint, Backup, Export, Verifikation, Tausch).
+/// Danach wird geprüft, dass die Raumliste aus der verschlüsselten DB wieder
+/// vollständig lädt. Ergebnis zusätzlich als ms pro MB – damit lässt sich die
+/// Dauer für eine echte DB-Größe hochrechnen.
+
+const _benchKey =
+    '5e4d3c2b1a0f9e8d7c6b5a4f3e2d1c0b5e4d3c2b1a0f9e8d7c6b5a4f3e2d1c0b';
+
+void main() {
+  final skip = findCipherDll() == null
+      ? 'SQLCipher-DLL fehlt – erst "flutter build windows" ausführen'
+      : null;
+
+  test(
+    'Migration Klartext → SQLCipher',
+    () async {
+      final rooms = scaled(20);
+      final eventsPerRoom = scaled(1000);
+      final report = BenchReport(
+        'migration',
+        params: {'rooms': rooms, 'eventsPerRoom': eventsPerRoom},
+      );
+      final factory = cipherFactory();
+      final tempDir = await Directory.systemTemp.createTemp(
+        'pyramid_bench_migration',
+      );
+
+      try {
+        // Vorlage: Klartext-DB wie vor der SQLCipher-Einführung.
+        final templatePath = p.join(tempDir.path, 'template.sqlite');
+        var db = await factory.openDatabase(templatePath);
+        await applyAppPragmas(db);
+        var client = await SyntheticMatrixData.openClient(db);
+        await SyntheticMatrixData.populate(
+          client,
+          rooms: rooms,
+          eventsPerRoom: eventsPerRoom,
+        );
+        await client.dispose(closeDatabase: true);
+        // WAL in die Hauptdatei schreiben, damit die Kopie vollständig ist.
+        db = await factory.openDatabase(templatePath);
+        await db.rawQuery('PRAGMA wal_checkpoint(TRUNCATE)');
+        await db.close();
+        final sizeMb = dbSizeMb(templatePath);
+
+        final workPath = p.join(tempDir.path, 'pyramid.sqlite');
+        Future<void> freshCopy() async {
+          for (final suffix in ['', '-wal', '-shm', '.enc', '.premigration']) {
+            final f = File('$workPath$suffix');
+            if (f.existsSync()) f.deleteSync();
+          }
+          await File(templatePath).copy(workPath);
+        }
+
+        final times = await sample(
+          () async {
+            final ok = await AppDatabase.migratePlaintextToEncrypted(
+              factory: factory,
+              dbPath: workPath,
+              hexKey: _benchKey,
+            );
+            if (!ok) throw StateError('Migration fehlgeschlagen');
+          },
+          setup: freshCopy,
+          warmup: 0,
+          runs: 3,
+        );
+
+        // Ergebnis der letzten Migration prüfen: verschlüsselt + vollständig.
+        expect(await AppDatabase.isPlaintextSqlite(File(workPath)), isFalse);
+        db = await AppDatabase.openEncrypted(factory, workPath, _benchKey);
+        client = await SyntheticMatrixData.openClient(db);
+        final loaded = await SyntheticMatrixData.loadRooms(client);
+        final firstPage = await client.database.getEventList(
+          loaded.first,
+          limit: 50,
+        );
+        await client.dispose(closeDatabase: true);
+        expect(loaded, hasLength(rooms));
+        expect(firstPage, hasLength(50));
+
+        report.addValue('db_size_mb', 'DB-Größe vor Migration', sizeMb, 'MB');
+        report.addTimings('migrate_ms', 'Migration gesamt', times);
+        report.addValue(
+          'migrate_ms_per_mb',
+          'Migration je MB',
+          median(times) / sizeMb,
+          'ms/MB',
+          compare: true,
+        );
+
+        final regressions = await report.finish();
+        if (strictBench) expect(regressions, isEmpty);
+      } finally {
+        try {
+          await tempDir.delete(recursive: true);
+        } catch (_) {}
+      }
+    },
+    skip: skip,
+    timeout: const Timeout(Duration(minutes: 20)),
+  );
+}

benchmark/support/bench.dart

@@ -0,0 +1,271 @@
+import 'dart:convert';
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:sqflite_common_ffi/sqflite_ffi.dart';
+import 'package:sqlite3/open.dart';
+
+/// Kleines Benchmark-Gerüst für `benchmark/` (bewusst ohne Zusatzpaket).
+///
+/// Jede Suite sammelt Messwerte in einem [BenchReport]. Am Ende:
+///  * Tabelle in der Konsole (inkl. Vergleich mit der Baseline),
+///  * JSON nach `build/benchmarks/<suite>.json` (für spätere Vergleiche),
+///  * Vergleich mit `benchmark/baseline/<suite>.json`, falls vorhanden.
+///
+/// Umgebungsvariablen:
+///  * `PYRAMID_BENCH_UPDATE_BASELINE=1` – aktuelle Werte als neue Baseline
+///    speichern (nach einer bewussten Änderung / auf neuer Hardware).
+///  * `PYRAMID_BENCH_STRICT=1` – Regressionen lassen den Lauf scheitern
+///    (sonst nur Warnung, weil Messrauschen normal ist).
+///  * `PYRAMID_BENCH_SCALE` – Datenmenge skalieren (Standard 1.0;
+///    z. B. 0.2 für einen schnellen Probelauf, 3 für „Power-User").
+
+/// Ab so viel Prozent langsamer als die Baseline gilt ein Wert als Regression.
+const regressionThresholdPercent = 25.0;
+
+/// Unterhalb dieser absoluten Differenz (ms) wird nie gewarnt – bei sehr
+/// kleinen Werten ist das reines Rauschen.
+const regressionFloorMs = 2.0;
+
+double get benchScale =>
+    double.tryParse(Platform.environment['PYRAMID_BENCH_SCALE'] ?? '') ?? 1.0;
+
+int scaled(int value) => (value * benchScale).round().clamp(1, 1 << 30);
+
+/// Führt [body] erst [warmup]-mal ungemessen, dann [runs]-mal gemessen aus
+/// und liefert die Laufzeiten in Millisekunden. [setup] läuft vor JEDEM
+/// Durchlauf und wird nicht mitgemessen.
+Future<List<double>> sample(
+  Future<void> Function() body, {
+  int warmup = 1,
+  int runs = 5,
+  Future<void> Function()? setup,
+}) async {
+  for (var i = 0; i < warmup; i++) {
+    if (setup != null) await setup();
+    await body();
+  }
+  final out = <double>[];
+  for (var i = 0; i < runs; i++) {
+    if (setup != null) await setup();
+    final sw = Stopwatch()..start();
+    await body();
+    sw.stop();
+    out.add(sw.elapsedMicroseconds / 1000.0);
+  }
+  return out;
+}
+
+double median(List<double> values) {
+  final sorted = [...values]..sort();
+  final mid = sorted.length ~/ 2;
+  return sorted.length.isOdd
+      ? sorted[mid]
+      : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+
+class BenchMetric {
+  BenchMetric({
+    required this.id,
+    required this.label,
+    required this.unit,
+    required this.value,
+    this.min,
+    this.runs = 1,
+    this.compare = true,
+  });
+
+  final String id;
+  final String label;
+  final String unit;
+
+  /// Median (bzw. Einzelwert) – der Wert, der verglichen wird.
+  final double value;
+  final double? min;
+  final int runs;
+
+  /// `false` für reine Info-Werte (z. B. Dateigröße), die nicht als
+  /// Regression gewertet werden.
+  final bool compare;
+
+  Map<String, Object?> toJson() => {
+    'label': label,
+    'unit': unit,
+    'value': double.parse(value.toStringAsFixed(3)),
+    if (min != null) 'min': double.parse(min!.toStringAsFixed(3)),
+    'runs': runs,
+    'compare': compare,
+  };
+}
+
+class BenchReport {
+  BenchReport(this.suite, {this.params = const {}});
+
+  final String suite;
+  final Map<String, Object?> params;
+  final _metrics = <BenchMetric>[];
+
+  /// Laufzeit-Messreihe (ms) als Metrik ablegen.
+  void addTimings(String id, String label, List<double> timingsMs) {
+    _metrics.add(
+      BenchMetric(
+        id: id,
+        label: label,
+        unit: 'ms',
+        value: median(timingsMs),
+        min: timingsMs.reduce((a, b) => a < b ? a : b),
+        runs: timingsMs.length,
+      ),
+    );
+  }
+
+  void addValue(
+    String id,
+    String label,
+    double value,
+    String unit, {
+    bool compare = false,
+  }) {
+    _metrics.add(
+      BenchMetric(
+        id: id,
+        label: label,
+        unit: unit,
+        value: value,
+        compare: compare,
+      ),
+    );
+  }
+
+  double valueOf(String id) => _metrics.firstWhere((m) => m.id == id).value;
+
+  /// Schreibt Bericht + ggf. Baseline und liefert die Liste der Regressionen
+  /// (leer = alles im Rahmen).
+  Future<List<String>> finish() async {
+    final baselineFile = File('benchmark/baseline/$suite.json');
+    Map<String, Object?>? baseline;
+    if (baselineFile.existsSync()) {
+      final json =
+          jsonDecode(baselineFile.readAsStringSync()) as Map<String, Object?>;
+      baseline = (json['metrics'] as Map).cast<String, Object?>();
+    }
+
+    final regressions = <String>[];
+    final buf = StringBuffer()
+      ..writeln()
+      ..writeln(
+        '══ Benchmark "$suite" '
+        '${params.isEmpty ? '' : params.entries.map((e) => '${e.key}=${e.value}').join(', ')}',
+      )
+      ..writeln(
+        '${'Messung'.padRight(52)}${'Wert'.padLeft(12)}  ${'Baseline'.padLeft(10)}  Δ',
+      );
+    for (final m in _metrics) {
+      final base = (baseline?[m.id] as Map?)?['value'] as num?;
+      var delta = '';
+      // Für Prozent-Werte (z. B. Verschlüsselungs-Aufschlag) wäre ein
+      // relatives Δ irreführend (4 % → 11 % = „+150 %“) – dort nur die Werte.
+      if (base != null && base > 0 && m.unit != '%') {
+        final pct = (m.value - base) / base * 100;
+        delta = '${pct >= 0 ? '+' : ''}${pct.toStringAsFixed(0)} %';
+        if (m.compare &&
+            pct > regressionThresholdPercent &&
+            (m.unit != 'ms' || m.value - base > regressionFloorMs)) {
+          delta += '  ⚠ LANGSAMER';
+          regressions.add(
+            '${m.label}: ${_fmt(m.value)} ${m.unit} '
+            '(Baseline ${_fmt(base.toDouble())} ${m.unit}, $delta)',
+          );
+        }
+      }
+      buf.writeln(
+        '${m.label.padRight(52)}'
+        '${'${_fmt(m.value)} ${m.unit}'.padLeft(12)}  '
+        '${base == null ? '–'.padLeft(10) : _fmt(base.toDouble()).padLeft(10)}  $delta',
+      );
+    }
+    // ignore: avoid_print
+    print(buf);
+
+    final report = {
+      'suite': suite,
+      'timestamp': DateTime.now().toIso8601String(),
+      'git': await _gitRevision(),
+      'host': {
+        'os': Platform.operatingSystemVersion,
+        'cpus': Platform.numberOfProcessors,
+      },
+      'params': params,
+      'metrics': {for (final m in _metrics) m.id: m.toJson()},
+    };
+    const encoder = JsonEncoder.withIndent('  ');
+    final outFile = File('build/benchmarks/$suite.json');
+    outFile.parent.createSync(recursive: true);
+    outFile.writeAsStringSync(encoder.convert(report));
+
+    if (Platform.environment['PYRAMID_BENCH_UPDATE_BASELINE'] == '1') {
+      baselineFile.parent.createSync(recursive: true);
+      baselineFile.writeAsStringSync('${encoder.convert(report)}\n');
+      // ignore: avoid_print
+      print('Baseline aktualisiert: ${baselineFile.path}');
+    }
+    return regressions;
+  }
+
+  static String _fmt(double v) =>
+      v >= 100 ? v.toStringAsFixed(0) : v.toStringAsFixed(v >= 10 ? 1 : 2);
+
+  static Future<String?> _gitRevision() async {
+    try {
+      final r = await Process.run('git', ['rev-parse', '--short', 'HEAD']);
+      return r.exitCode == 0 ? (r.stdout as String).trim() : null;
+    } catch (_) {
+      return null;
+    }
+  }
+}
+
+bool get strictBench => Platform.environment['PYRAMID_BENCH_STRICT'] == '1';
+
+// ── SQLCipher aus dem App-Build ────────────────────────────────────────────
+
+/// Die vom sqlcipher_flutter_libs-Plugin gebaute `sqlite3.dll` – dieselbe
+/// Bibliothek, die die App benutzt. `null`, wenn noch nie gebaut wurde.
+String? findCipherDll() {
+  for (final config in ['Release', 'Profile', 'Debug']) {
+    final file = File('build/windows/x64/runner/$config/sqlite3.dll');
+    if (file.existsSync()) return file.absolute.path;
+  }
+  return null;
+}
+
+/// Läuft (wie in der App) im Hintergrund-Isolate von sqflite_common_ffi –
+/// deshalb top-level und ohne eingefangene Variablen.
+void cipherFfiInit() {
+  final dll = findCipherDll();
+  if (dll == null) throw StateError('SQLCipher-DLL fehlt');
+  open.overrideFor(OperatingSystem.windows, () => DynamicLibrary.open(dll));
+}
+
+/// Factory wie in der App: eigenes DB-Isolate, SQLCipher-Bibliothek.
+/// Ohne `PRAGMA key` verhält sich SQLCipher wie normales SQLite – so laufen
+/// Klartext- und verschlüsselte Messung mit DERSELBEN Bibliothek und sind
+/// fair vergleichbar.
+DatabaseFactory cipherFactory() =>
+    createDatabaseFactoryFfi(ffiInit: cipherFfiInit);
+
+/// Dieselben PRAGMAs wie `AppDatabase._applyPragmas` (dort privat).
+Future<void> applyAppPragmas(Database db) async {
+  await db.execute('PRAGMA journal_mode=WAL');
+  await db.execute('PRAGMA busy_timeout = 5000');
+}
+
+/// Gesamtgröße der DB inkl. WAL-Sidecar in MB.
+double dbSizeMb(String path) {
+  var bytes = 0;
+  for (final suffix in ['', '-wal']) {
+    final f = File('$path$suffix');
+    if (f.existsSync()) bytes += f.lengthSync();
+  }
+  return bytes / (1024 * 1024);
+}

docs/DASHBOARD_AUTH_HARDENING.md

@@ -0,0 +1,177 @@
+# Dashboard-Server absichern: Admin-Endpoints haben KEINE Authentifizierung
+
+**Status (ABGESCHLOSSEN 2026-07-05): Das Loch ist mit dem Heimnetz-Gate
+(„Weg C", siehe unten) geschlossen, und Bernd hat entschieden
+(`ANTWORTEN_BERND.md` Nr. 3): KEIN Fernzugriff – das Gate ist der ENDZUSTAND.**
+Die fünf Admin-Endpoints akzeptieren nur noch Anfragen aus dem
+Heimnetz/localhost; alles, was über den Cloudflare-Tunnel kommt, bekommt 403 mit
+einer Erklärung (die das Dashboard per `alert()` anzeigt). Bernds Dashboard
+funktioniert im Heimnetz unverändert unter
+`http://192.168.178.71:8080/stats.html`; unterwegs kommt Bernd per WireGuard ins
+Heimnetz. Die A/B-Frage (Cloudflare Access vs. `DASH_TOKEN`) ist damit
+GESCHLOSSEN – die Optionen unten bleiben nur als Archiv stehen, falls sich der
+Bedarf je ändert. Die unten dokumentierten Restrisiken des Gates sind bewusst
+akzeptiert. **Nicht weiter an diesem Thema arbeiten.**
+
+## Heimnetz-Gate („Weg C", aktiv seit 2026-07-04, seit 2026-07-05 Endzustand)
+
+In `server.py` (Konstante `ADMIN_PATHS` + Helfer `lan_denied_reason`): eine
+Admin-POST-Anfrage wird nur angenommen, wenn (1) **kein** `Cf-Connecting-Ip`/
+`Cf-Ray`-Header vorhanden ist (= sie kam nicht durch den Cloudflare-Tunnel) und
+(2) die **Socket-Absender-IP** (nicht spoofbar) `127.0.0.1`/`::1`/`192.168.*`
+ist. Abgelehnte Versuche landen größenbegrenzt (5 MB-Deckel) in
+`security_alerts.log` und damit in der Dashboard-Anzeige. Headless verifiziert:
+öffentliche URL → 403 (ban/toggle), Heimnetz-IP und localhost → App-Validierung
+erreicht (400 bei leerem Nutzer), gespoofter Cf-Header aus dem LAN → 403,
+`GET /` öffentlich → 200, `/api/livekit-token` (401 bei ungültigem Token) und
+`/api/e2ee-diagnostics` (403 bei falschem Token) unverändert öffentlich
+erreichbar (die App braucht sie, eigene Auth vorhanden).
+
+**Bekannte Restrisiken des Gates (Bernd bekannt und bewusst akzeptiert,
+Entscheidung 2026-07-05):**
+- Die **öffentliche Ansicht bleibt offen** und zeigt Nutzerliste + Präsenz
+  (Informations-Preisgabe). Weg A würde auch das schließen.
+- **CSRF aus dem Heimnetz:** Eine bösartige Webseite in Bernds Browser könnte
+  theoretisch POSTs an `http://192.168.178.71:8080` schicken (moderne
+  Chrome-Versionen blocken Public→Private-Requests, Firefox nicht vollständig).
+  Erst ein Token/Access-Login (Weg A/B) schließt das sauber.
+- Wer **im Heimnetz** ist, kann weiterhin ohne Anmeldung administrieren.
+
+## Problem (belegt, nicht vermutet)
+
+Der Dashboard-Server `/home/steggi/matrix/server.py` (läuft als
+`matrix-stats.service` auf `0.0.0.0:8080`) ist über Cloudflare unter
+`https://dashboard.steggi-matrix.work` **öffentlich aus dem Internet erreichbar**.
+Getestet: `GET /` liefert 200 (stats.html), und die **zustandsändernden POST-Endpoints
+antworten mit der App-eigenen Validierung – ohne jede Authentifizierung**:
+
+```
+$ curl -X POST https://dashboard.steggi-matrix.work/api/ban -d '{"user":""}'
+{"error": "Kein Nutzer angegeben"}        # HTTP 400 – App-Antwort, KEIN Login davor
+```
+
+Damit kann **jeder Fremde im Internet**, der den Hostnamen kennt, ohne Anmeldung:
+
+- `/api/ban` / `/api/unban` – **jeden Matrix-Nutzer sperren/entsperren** (auch Uta!)
+  → Aussperrung / Denial-of-Service gegen echte Nutzer.
+- `/api/toggle-registration` und `/api/create-invite` – **offene Registrierung am
+  Homeserver aktivieren** (setzt `allow_registration = true` +
+  `yes_i_am_very_very_sure…`) → der Homeserver wird zur Spam-/Missbrauchsschleuder.
+- `/api/run-stats` – Stats-Skript auslösen (harmlos, aber ebenfalls ungeschützt).
+
+**Der Hostname ist nicht wirklich geheim:** Cloudflare stellt TLS-Zertifikate aus,
+die in den öffentlichen Certificate-Transparency-Logs landen – jede Subdomain von
+`steggi-matrix.work` ist per CT-Log-Scan auffindbar. Die bisherige „Sicherheit"
+beruht also allein auf Verborgenheit eines Namens, der praktisch entdeckbar ist.
+
+Bereits **korrekt abgesichert** (zum Vergleich, nicht betroffen):
+- `/api/e2ee-diagnostics` – eigener `DIAG_TOKEN` (Bearer).
+- `/api/livekit-token` – Matrix-Access-Token per `whoami` gegen Continuwuity.
+
+Nur die vier Admin-/Stats-Endpoints oben sind offen.
+
+## Wie das Dashboard heute aufruft
+
+`stats.html` ruft alle Aktionen als **Same-Origin-`fetch` ohne Auth-Header** auf
+(`toggleRegistration`, `createInvite`, `refreshStats`, `doUserAction` →
+`/api/ban` /`/api/unban`). Es gibt keine Session, kein Cookie, keinen Token –
+deshalb bricht **jede** hinzugefügte Authentifizierung das Dashboard so lange,
+bis `stats.html` den Token mitschickt. Genau darum ist das eine Bernd-Entscheidung
+und kein stiller Fix.
+
+## Option A (empfohlen, robust): Cloudflare Access vor die Subdomain
+
+Am saubersten wird das Dashboard **komplett** durch Cloudflare Access geschützt
+(Zero-Trust-Login vor der Subdomain), statt in `server.py` Auth nachzubauen:
+
+1. Im Cloudflare-Zero-Trust-Dashboard eine **Access-Application** für
+   `dashboard.steggi-matrix.work` anlegen.
+2. Policy: nur Bernds E-Mail (`[email protected]`) per One-Time-PIN
+   oder Google-Login zulassen.
+3. Fertig – `server.py` und `stats.html` bleiben **unverändert**, das Dashboard
+   funktioniert für Bernd wie bisher (nach dem Access-Login), aber Fremde kommen
+   gar nicht erst an die Endpoints.
+
+Vorteil: kein Secret im Code, kein Umbau der HTML-Fetches, kein Aussperr-Risiko
+durch vergessene Tokens. Nachteil: Bernd muss die Access-App einmal im
+Cloudflare-Panel klicken (kein Code, aber sein Konto nötig). **Das ist der
+Königsweg – Option B nur, falls Access nicht gewünscht ist.**
+
+## Option B (Fallback, rein in server.py): eigener Dashboard-Token
+
+Wenn Access nicht gewünscht ist, ein **neuer, zufälliger `DASH_TOKEN`** (getrennt
+vom geleakten Admin-Token `J5lax…` und vom `DIAG_TOKEN`!), den die vier
+Admin-/Stats-Endpoints als `Authorization: Bearer <DASH_TOKEN>` verlangen:
+
+```python
+# server.py, zu den anderen Token-Konstanten:
+DASH_TOKEN = "<neu erzeugen: python3 -c 'import secrets;print(\"dash-\"+secrets.token_urlsafe(24))'>"
+
+def _dash_authed(self):
+    return self.headers.get("Authorization", "") == "Bearer " + DASH_TOKEN
+```
+
+In `do_POST` **vor** der Behandlung von `/api/ban`, `/api/unban`,
+`/api/toggle-registration`, `/api/create-invite`, `/api/run-stats` einfügen:
+
+```python
+if self.path in ("/api/ban", "/api/unban", "/api/toggle-registration",
+                 "/api/create-invite", "/api/run-stats") and not self._dash_authed():
+    self.send_error(403)
+    return
+```
+
+`GET /` und `/api/registration-status` bleiben öffentlich (nur Lesen), damit die
+Stats-Seite ohne Token sichtbar bleibt.
+
+**`stats.html`** darf den Token **NIEMALS fest eingebettet** ausliefern (die Seite
+ist öffentlich – der Token läge sonst für jeden offen). Stattdessen einmal im
+Browser abfragen und in `localStorage` halten:
+
+```javascript
+function dashToken() {
+  var t = localStorage.getItem('dashToken');
+  if (!t) { t = prompt('Dashboard-Token:'); if (t) localStorage.setItem('dashToken', t); }
+  return t || '';
+}
+// und bei JEDEM Aktions-fetch:
+fetch('/api/ban', { method:'POST',
+  headers: {'Content-Type':'application/json', 'Authorization':'Bearer ' + dashToken()},
+  body: JSON.stringify({user:u}) })
+```
+
+(betrifft `toggleRegistration`, `createInvite`, `refreshStats`, `doUserAction`).
+Bei 403 den gecachten Token verwerfen (`localStorage.removeItem('dashToken')`) und
+neu fragen. Bernd gibt den Token so genau **einmal pro Browser** ein.
+
+## Rollout / Testplan
+
+**Option A:** Access-App klicken → von einem fremden Netz/Inkognito prüfen, dass
+`https://dashboard.steggi-matrix.work/` zum Access-Login umleitet statt die Seite
+zu zeigen; dann als Bernd einloggen und alle Buttons testen. Kein Code-Deploy.
+
+**Option B (headless auf dem Pi verifizierbar):**
+1. `server.py` + `stats.html` ändern, Dienst-Neustart (Prozess killen,
+   `Restart=always` lädt neu – siehe PROGRESS 2026-07-04 zur polkit-Falle).
+2. `curl -X POST .../api/ban -d '{"user":"x"}'` **ohne** Bearer → **403** erwartet.
+3. Mit `Authorization: Bearer <DASH_TOKEN>` + leerem Nutzer → 400 (App-Validierung
+   erreicht) → beweist: Token akzeptiert, Auth greift.
+4. Im Browser: Dashboard öffnen, Token eingeben, je ein Button testen
+   (Registrierung toggeln + sofort zurück, Stats aktualisieren; Ban/Unban an
+   einem **Test-Nutzer**, nicht an Uta).
+
+## Warum erst nur der Plan kam – und dann doch das Interims-Gate
+
+Eine Token-/Access-Absicherung (A/B) macht die Dashboard-Buttons überall
+funktionslos, bis Bernd aktiv etwas tut (Token eingeben bzw. Access-App
+einrichten) – das mitten in einer autonomen Session zu deployen verletzt die
+CLAUDE.md-Leitplanke „kein Aussperren". Das *Wie* der Anmeldung bleibt deshalb
+Bernds Richtungsentscheidung. Das später ergänzte Interims-Gate umgeht dieses
+Dilemma: Es braucht keinerlei Aktion von Bernd (Heimnetz-Nutzung läuft
+unverändert weiter, inkl. spontanem Spam-Bann von zu Hause), sperrt aber
+Fremde aus dem Internet sofort aus. Einzige Einschränkung: Admin-Buttons über
+die öffentliche URL gehen nicht – die 403-Meldung im Dashboard erklärt das und
+nennt die Heimnetz-URL. Mit Bernds Entscheidung vom 2026-07-05 (Heimnetz-only,
+unterwegs WireGuard) ist genau dieser Zustand der gewollte Endzustand. Rückbau
+(falls je nötig) = die Gate-Zeilen in `server.py` entfernen
+(Backup: `server.py.bak-20260704-dashgate`).

docs/LIVEKIT_TOKEN_MIGRATION.md

@@ -0,0 +1,166 @@
+# LiveKit-Token server-seitig minten (apiSecret aus dem Client entfernen)
+
+**Status (2026-10-07):** Server-Route UND Client umgestellt.
+
+- Server: `POST /api/livekit-token` im Dashboard-Server auf dem Pi
+  (`/home/steggi/matrix/server.py`) – whoami-Prüfung, Identität = geprüfte
+  Matrix-ID, Secret aus `livekit.yaml`. Geprüft: ungültiger Token → 401
+  (öffentlich über `dashboard.steggi-matrix.work`), gültiger Token → JWT mit
+  `sub` = Matrix-ID und denselben Grants wie früher.
+- Client: `lib/core/livekit_token.dart` holt das Token per
+  `LiveKitTokenService.fetch` (kein Secret, kein JWT-Signieren mehr in der App);
+  `livekit_call_manager.dart` nutzt es für alle LiveKit-Beitritte. Fehler
+  (offline, 401, Serverfehler) erscheinen als lesbare Meldung im Anruf.
+- Tests: `test/livekit_token_test.dart` (Anfrage, Fehlerpfade, kein Secret im
+  Code) und `integration_test/livekit_token_connect_test.dart` (ECHTER
+  LiveKit-Beitritt mit Server-Token, Testkonto pyramidtest1, Wegwerf-Raum) –
+  grün am 2026-10-07.
+
+**Offen:**
+1. Anruf/Sprachkanal auf dem echten Handy prüfen (Ton, Video, Bildschirm
+   teilen, zweiter Teilnehmer, Verlassen/Wiederbeitreten).
+2. Erst wenn ALLE genutzten Geräte (Bernd + Uta) die neue Version haben:
+   Secret rotieren (siehe „Rotation“ unten) – das macht Bernd, nicht Claude.
+   Bis dahin funktionieren alte und neue App-Versionen parallel.
+3. Neue Abhängigkeit beachten: Anrufe brauchen jetzt zusätzlich den
+   Dashboard-Server (`matrix-stats.service`). Ist er aus, meldet die App
+   „Anrufserver nicht erreichbar“.
+
+Die ursprüngliche Planung (2026-07-04) folgt unverändert.
+
+## Problem
+
+`lib/core/livekit_token.dart` mintet die LiveKit-JWTs **im Client**. Dafür muss das
+LiveKit-`apiSecret` im App-Code liegen (`livekit_token.dart:6`) – d. h. jeder
+App-Nutzer (auch Uta) trägt das SFU-Secret im Gerät. Wer es hat, kann sich für
+**jeden** Raum und **jede** Identität ein Beitritts-Token ausstellen. Das ist ein
+Architekturproblem, kein bloßer Repo-Leak: Selbst nach einem History-Rewrite bliebe
+das Secret im ausgelieferten Binary.
+
+Aktueller Fluss (`lib/core/livekit_call_manager.dart:154`):
+
+```dart
+final token = LiveKitTokenGenerator.generate(
+  roomName: roomName,
+  identity: identity,
+  displayName: identity,
+  ttlSeconds: 21600,   // 6 h
+);
+```
+
+Erzeugtes JWT (HS256, `livekit_token.dart:14-33`): Grants `video` mit
+`roomJoin/room/canPublish/canSubscribe/canPublishData`, `metadata` = Anzeigename,
+`iss` = apiKey (`LKMatrixPi`), `sub` = identity, `exp` = jetzt+ttl.
+
+## Ziel
+
+Das `apiSecret` liegt **nur noch auf dem Pi**. Der Client holt sich für einen
+konkreten Raum ein fertiges JWT von einem kleinen Token-Endpoint und übergibt es
+unverändert an `Room.connect`.
+
+## Server-Seite (Pi)
+
+Es gibt bereits einen schlanken Dashboard-Server ohne Fremd-Abhängigkeiten:
+`/home/steggi/matrix/server.py` (stdlib `http.server`, läuft als
+`matrix-stats.service` auf `0.0.0.0:8080`, nach außen `dashboard.steggi-matrix.work`).
+Der Token-Endpoint kann dort als weitere Route `POST /api/livekit-token` andocken –
+kein neuer Dienst nötig. Das LiveKit-`apiSecret` steht schon auf dem Pi in
+`/home/steggi/matrix/livekit.yaml` (`keys: LKMatrixPi: <secret>`); der Server liest
+es von dort, statt es erneut zu hinterlegen (eine Quelle der Wahrheit).
+
+**Wichtig – Authentifizierung:** Der Endpoint darf NICHT anonym Tokens ausstellen
+(sonst ist nichts gewonnen). Der Client schickt seinen **Matrix-Access-Token** mit;
+der Server prüft ihn gegen Continuwuity und leitet daraus die Identität ab:
+
+1. `POST /api/livekit-token`, Body `{ "room": "<roomName>", "matrix_token": "<access_token>" }`.
+2. Server ruft `GET http://127.0.0.1:6167/_matrix/client/v3/account/whoami`
+   mit `Authorization: Bearer <matrix_token>` auf → liefert `user_id`
+   (401 → Endpoint gibt 401 zurück, kein Token).
+3. `identity` = `user_id` (NICHT vom Client wählbar – verhindert Identitäts-Spoofing).
+4. Optional, aber empfohlen: Raummitgliedschaft prüfen (`/_matrix/client/v3/rooms/
+   {roomId}/joined_members` oder der Matrix-Raum, zu dem der Voice-Channel gehört) –
+   nur ausstellen, wenn der Nutzer wirklich Mitglied ist. Für Phase 1 reicht die
+   whoami-Authentifizierung; Mitgliedschaftsprüfung als Härtung nachziehen.
+5. Server mintet das LiveKit-JWT **mit denselben Grants wie heute** und gibt
+   `{ "token": "<jwt>", "url": "wss://livekit.steggi-matrix.work" }` zurück.
+
+**JWT-Minting ohne Fremd-Paket (stdlib genügt):** LiveKit-Tokens sind HS256-JWTs.
+Mit `hmac`/`hashlib`/`base64`/`json` aus der stdlib:
+
+```python
+import base64, hmac, hashlib, json, time
+
+def _b64url(b): return base64.urlsafe_b64encode(b).rstrip(b"=")
+
+def mint_livekit(api_key, api_secret, identity, room, name, ttl=21600):
+    now = int(time.time())
+    header  = {"alg": "HS256", "typ": "JWT"}
+    payload = {
+        "iss": api_key, "sub": identity, "name": name,
+        "nbf": now, "exp": now + ttl, "metadata": name,
+        "video": {"roomJoin": True, "room": room,
+                  "canPublish": True, "canSubscribe": True,
+                  "canPublishData": True},
+    }
+    segs = [_b64url(json.dumps(header,  separators=(",", ":")).encode()),
+            _b64url(json.dumps(payload, separators=(",", ":")).encode())]
+    signing_input = b".".join(segs)
+    sig = hmac.new(api_secret.encode(), signing_input, hashlib.sha256).digest()
+    return (signing_input + b"." + _b64url(sig)).decode()
+```
+
+Verifikation lokal auf dem Pi (kein Gerät nötig): geminetes Token gegen den
+laufenden LiveKit prüfen, z. B. per LiveKit-CLI `lk` oder indem man das JWT auf
+jwt.io-Art dekodiert und Claims/Signatur vergleicht. Zusätzlich Gegentest mit dem
+**alten** Client-Pfad: dasselbe Token muss `Room.connect` akzeptieren.
+
+## Client-Seite
+
+- `lib/core/livekit_token.dart`: `apiKey`/`apiSecret` **entfernen**. Die Klasse wird
+  entweder gelöscht oder zu einem dünnen HTTP-Client
+  `Future<String> fetchLiveKitToken({required String room, required String matrixToken})`,
+  der `POST https://dashboard.steggi-matrix.work/api/livekit-token` aufruft und das
+  `token`-Feld zurückgibt. `http`-Paket ist schon Abhängigkeit (siehe
+  `update_checker.dart`).
+- `lib/core/livekit_call_manager.dart:154`: `LiveKitTokenGenerator.generate(...)`
+  → `await fetchLiveKitToken(room: roomName, matrixToken: matrixClient.accessToken)`.
+  Der Manager hat den Matrix-Client bereits (`_matrixClient`, Zeile 149) – der
+  Access-Token ist also verfügbar. `identity`/`displayName` werden nicht mehr vom
+  Client bestimmt (Server leitet Identität aus whoami ab); den bisherigen
+  `identity`-Parameter entsprechend zurückbauen.
+- Fehlerpfade: Netzfehler / 401 / 403 sauber als Call-Fehler anzeigen
+  (`error = ...; notifyListeners()`), NICHT still schlucken – sonst „Call verbindet
+  nicht" ohne Hinweis. TTL bleibt 21600 s (6 h), Erneuerung wie bisher beim
+  Neu-Beitreten.
+
+## Rotation (Pflicht, danach)
+
+Das alte `apiSecret` `rYUT2PRa…` ist geleakt (Client + Git-History). Nach der
+Umstellung:
+
+1. Neues `apiSecret` in `/home/steggi/matrix/livekit.yaml` (`keys:`) setzen.
+2. LiveKit-Container neu starten
+   (`docker compose -f /home/steggi/matrix/docker-compose.yml restart livekit`).
+3. `server.py` liest das Secret aus `livekit.yaml` – kein zweiter Ort zu pflegen.
+4. Alte Clients (Utas installierte APK) minten mit dem alten Secret → deren
+   selbst-gemintete Tokens werden nach der Rotation abgelehnt. Deshalb Rotation
+   **zusammen mit einem neuen Release** ausrollen, das den neuen Fetch-Pfad nutzt.
+
+## Reihenfolge / Testplan (PC + Gerät)
+
+1. `server.py`-Route bauen, lokal auf dem Pi verifizieren (whoami-Auth greift,
+   geminetes Token dekodiert korrekt, `Room.connect` akzeptiert es).
+2. Client umstellen, `flutter analyze` sauber, `flutter test` grün.
+3. **Auf echtem Gerät** (Calls heilig, kein Headless-Test möglich): Voice-Channel
+   beitreten, Audio/Video/Screenshare, Verlassen/Wieder-Beitreten, zweiter
+   Teilnehmer. Erst wenn das steht: Secret rotieren + Release.
+4. Danach ROADMAP-M0-Punkt „LiveKit-Token server-seitig minten" abhaken und den
+   Rotations-Teil des Secret-Punkts als erledigt markieren.
+
+## Warum nicht jetzt (auf dem Pi) gemacht
+
+Die Server-Route ließe sich hier bauen und headless testen – aber der zugehörige
+Client-Umbau tauscht den **heiligen Call-Pfad** aus und ist auf diesem Pi ohne
+GUI/Gerät nicht praktisch prüfbar. Einen halben, nicht end-to-end verifizierbaren
+Umbau am Call-Pfad zu stapeln verbietet die CLAUDE.md-Leitplanke („keine
+Verhaltensänderung ohne Not", Calls heilig). Deshalb hier nur der fertige Plan.

docs/M2_MODULE_SCHNITT.md

@@ -0,0 +1,192 @@
+# M2 – Modul-Schnitt (Entwurf)
+
+> **STATUS 2026-07-06: Pilot (Schritt 1) UMGESETZT.** Die Module
+> `call_signaling` (`lib/features/call_signaling/`: `CallSignalingService`
+> + `callSignalingProvider` + Implementierung `voip_manager.dart`) und
+> `voice_channel` (`lib/features/voice_channel/`: `VoiceChannelService` +
+> `voiceChannelProvider` + Implementierung `livekit_call_manager.dart`)
+> existieren; ALLE Konsumenten (Shell, Call-UI, Rooms-Panel, Chat-Header,
+> Settings) gehen nur noch über die Provider/Interfaces, kein direkter
+> Implementierungs-Import mehr (einzige dokumentierte Ausnahme:
+> Kompositions-Punkt `matrix_client.dart`). Bewusste Abweichungen vom
+> Entwurf unten (Verhaltensgleichheit vor Schönheit, heiliger Call-Pfad):
+> ChangeNotifier statt Streams, Methodennamen wie im Bestand
+> (`startCall`/`hangUp` statt `join`/`leave`), `CallSession`/LiveKit-`Room`
+> bleiben in den Schnittstellen sichtbar, weil die UI direkt rendert.
+> Echter Call-/Voice-Channel-Test steht aus (Gerät bzw. Klick-Test) –
+> siehe PROGRESS.md 2026-07-06. Schritte 2–5 unten sind weiter offen.
+>
+> **Nachtrag 2026-07-06 (zweite PC-Session):** `call_ui` ist jetzt ein
+> eigenes Modul (`lib/features/call_ui/`, reine Umbenennung von
+> `features/call/`; konsumiert weiterhin nur die zwei Service-Interfaces).
+> Außerdem ist der storage-Teilschritt für die Call-Module erledigt: die
+> voice_*-Prefs (Geräte + Ausgabelautstärke) laufen über die neue
+> `VoicePrefs`-Kapsel in `core/settings_prefs.dart` (Punkt 6 unten) –
+> kein direkter SharedPreferences-Zugriff mehr in `voip_manager.dart`/
+> `livekit_call_manager.dart`/`settings_voice.dart`, Keys unverändert.
+> „UI-State aus den Managern herauslösen" wartet bewusst auf Bernds
+> Klick-Test des Piloten (heiliger Call-Pfad).
+
+Stand: 2026-07-03. Reine Schnittstellen-Planung, noch kein Umbau. Grundlage:
+Ist-Analyse in `PROGRESS.md` (Eintrag „M2: Ist-Analyse der Architektur
+geschrieben"). Leitprinzip (Bernd, `CLAUDE.md`): jedes Modul muss sich in
+einem Jahr komplett neu schreiben lassen, ohne andere Module anzufassen.
+Andere Module dürfen daher nur die hier genannte öffentliche Schnittstelle
+importieren, nie interne Dateien.
+
+Korrektur zur Ist-Analyse: der Import von `rooms_provider.dart` in
+`app_state.dart` ist **kein** toter Altlast-Import, wie dort vermutet –
+`voiceParticipantsProvider` (Zeile 160) nutzt `roomListProvider` daraus, um
+bei jedem Sync neu zu bauen. Der Eintrag in PROGRESS.md wird beim nächsten
+Durchgang korrigiert.
+
+## Wichtige Erkenntnis vor dem Schnitt: „Calls" ist eigentlich ZWEI Features
+
+Beim genaueren Lesen von `voip_manager.dart` und `livekit_call_manager.dart`
+zeigt sich: das sind keine zwei Hälften derselben Sache, sondern zwei
+unabhängige Call-Mechanismen, die zufällig beide „Call" heißen:
+
+- **`PyramidVoipManager`** – natives Matrix-VoIP (`m.call.*`-Events über das
+  matrix-SDK, direkte 1:1-WebRTC-Peer-Connection, kein SFU). Vermutlich für
+  spontane 1:1-Anrufe gedacht.
+- **`LiveKitCallManager`** – SFU-basierte, dauerhafte Voice-Channels (LiveKit-
+  Server-Raum, Presence über Matrix-State-Events, Screensharing, Mehrpersonen).
+  Das ist der Discord-artige Voice-Channel aus M3/M4.
+
+Beide Module sollten **getrennt** bleiben, nicht zu einem „calls"-Modul
+verschmolzen werden. Nur die UI (`call_ui`) darf beide kennen, falls sie
+gemeinsam dargestellt werden müssen (z. B. „du bist in einem Voice-Channel,
+jemand ruft dich per 1:1-VoIP an").
+
+## Modul-Liste mit öffentlicher Schnittstelle (Entwurf)
+
+### 1. `call_signaling` (Matrix-1:1-VoIP)
+**Ersetzt:** `core/voip_manager.dart`
+**Öffentliche Schnittstelle (Ausschnitt):**
+```dart
+abstract class CallSignalingService {
+  Stream<CallSession?> get currentCallStream;
+  bool get isMicMuted;
+  bool get isCameraMuted;
+  Future<void> startCall(String roomId, {bool video});
+  Future<void> hangup();
+  Future<void> toggleMic();
+  Future<void> toggleCamera();
+  Future<void> toggleScreenSharing(BuildContext? context);
+  RTCVideoRenderer get localRenderer;   // bleibt vorerst WebRTC-typisiert,
+  RTCVideoRenderer get remoteRenderer;  // da UI direkt rendert
+}
+```
+Interna (ICE-Server-Merge, `MediaDevicesWrapper`, Geräte-Prefs aus
+`SharedPreferences`) bleiben privat im Modul. Geräte-Prefs sollten künftig
+über die `storage`-Fassade laufen statt direktem `SharedPreferences`-Zugriff
+(aktuell Zeile 260, 447).
+
+### 2. `voice_channel` (LiveKit-SFU, Discord-artige Kanäle)
+**Ersetzt:** `core/livekit_call_manager.dart`
+**Öffentliche Schnittstelle (Ausschnitt):**
+```dart
+abstract class VoiceChannelService {
+  Stream<VoiceChannelState> get stateStream; // isActive, isMuted, participants…
+  Future<void> join({required String roomName, required String matrixRoomId, ...});
+  Future<void> leave();
+  Future<void> toggleMute();
+  Future<void> toggleDeafen();
+  Future<void> toggleCamera();
+  Future<void> toggleScreenShare();
+  Future<void> setPublishQuality(String key);   // Streamer-Seite (M4)
+  Future<void> setSubscribeQuality(String key); // Empfänger-Seite (M4)
+  Future<void> setOutputVolume(double v);
+}
+```
+Presence-Writing (`_writePresence`, Matrix-State-Event
+`io.pyramid.voice.presence`) bleibt intern, aber nutzt eine injizierte
+`Client`-Referenz statt globalem Singleton-Zugriff – macht das Modul für
+Tests austauschbar.
+
+### 3. `call_ui`
+**Ersetzt:** `features/call/voice_channel.dart`, `features/call/mini_call_widget.dart`
+Konsumiert ausschließlich `CallSignalingService` + `VoiceChannelService` über
+Riverpod-Provider (`callSignalingProvider`, `voiceChannelProvider`). Keine
+direkten Importe von `core/voip_manager.dart`/`core/livekit_call_manager.dart`
+mehr – heute importieren `chat_view.dart`, `matrix_client.dart` und
+`settings_modal.dart` diese Dateien direkt, das entfällt.
+
+### 4. `settings` (aufgesplittet)
+Kein eigenes fachliches Modul, sondern reine Aggregations-UI. Jede Sektion
+wird eine eigene Datei/Klasse mit einer schmalen `Widget build(...)`-Fläche,
+die ihrerseits nur die Provider ihres Fachmoduls konsumiert (z. B.
+`_VoiceSection` nutzt künftig `voiceChannelProvider`/`callSignalingProvider`
+statt der Manager direkt). Vorschlag für Dateien:
+`settings/profile_section.dart`, `settings/notifications_section.dart`,
+`settings/appearance_section.dart`, `settings/sessions_section.dart`,
+`settings/account_section.dart`, `settings/voice_section.dart`,
+`settings/about_section.dart`.
+
+### 5. `verification` (neu, aus Settings herausgelöst)
+**Quelle:** `widgets/settings_modal.dart` Zeile 2921–4545 (SAS-Dialog,
+QR-Anzeige, Emoji-Vergleich, Recovery-Key-Flow).
+```dart
+abstract class VerificationService {
+  Future<void> startSasVerification(DeviceKeys device);
+  Future<void> confirmSas();
+  Future<void> declineSas();
+  Stream<VerificationStep> get stepStream;
+}
+```
+Eigenständig, weil SAS/QR-Verifikation künftig auch außerhalb der Settings
+gebraucht werden könnte (z. B. beim Login auf einem neuen Gerät –
+`bootstrap_dialog.dart` macht heute schon etwas Ähnliches separat).
+
+### 6. `storage` (Fassade, kein Rewrite)
+**Ausbau von:** `core/settings_prefs.dart`
+```dart
+abstract class Prefs {
+  Future<bool> getBool(String key, {bool fallback});
+  Future<void> setBool(String key, bool value);
+  // … String, double, StringSet analog zu BoolPref/StringSetPref
+}
+```
+Ziel ist NICHT, `SharedPreferences` zu ersetzen, sondern die bereits
+vorhandene `BoolPref`/`StringSetPref`-Abstraktion zur Pflicht zu machen.
+Die 12 identifizierten Direktzugriffsstellen (u. a. `voip_manager.dart:260`,
+`livekit_call_manager.dart:246`, `settings_modal.dart:1804/1860/1870`) werden
+schrittweise umgestellt – **nicht** in diesem Schritt, sondern sobald das
+jeweilige Modul (z. B. `call_signaling`) ohnehin angefasst wird.
+Krypto-/Access-Token-Speicherung (`flutter_secure_storage`,
+`matrix_client.dart`) bleibt bewusst außen vor – hängt an der noch offenen
+SQLCipher-Frage (M1) und wird dort separat behandelt, nicht hier.
+
+### 7. `auth`
+**Dateien:** `features/auth/login_notifier.dart`, `login_page.dart`,
+`server_page.dart`, `bootstrap_dialog.dart` (Bootstrap-Teil, Verifikations-Teil
+wandert ggf. zu `verification`, s. o.). Schnittstelle bleibt der bereits
+vorhandene `matrixClientProvider`/`login_notifier`-Zustandsautomat – heute
+schon relativ sauber gekapselt, kein akuter Handlungsbedarf.
+
+### 8. `push`
+**Dateien:** `core/background_push.dart`, `core/fcm_push_service.dart`,
+`core/notification_service.dart`. Bereits über eigene Dateien getrennt
+(nativ vs. Flutter-Engine, siehe Memory „Pyramid Push"). Einzige Lücke:
+eigener `sqflite`-Zugriff in `background_push.dart` statt gemeinsamer
+DB-Schicht – bewusst so gewollt (Background-Isolate-Zwang), daher **kein**
+Refactoring-Kandidat, nur dokumentieren.
+
+### 9. `chat_timeline` / `rooms`
+Niedrigste Priorität für den Pilot-Umbau, da laut Ist-Analyse strukturell
+am wenigsten verwoben (Hauptproblem dort ist Dateigröße + Duplikate, nicht
+Modul-Kopplung). Wird nach dem Call-Pilot angegangen.
+
+## Reihenfolge-Vorschlag für die Umsetzung
+
+1. **Pilot: `call_signaling` + `voice_channel` + `call_ui`** (Punkt „Call-Schicht
+   entwirren" in ROADMAP.md) – kleinster klar abgegrenzter Schnitt, deckt
+   gleich zwei ROADMAP-Punkte ab (Modul-Schnitt beweisen + Call-Entwirrung).
+2. `settings_modal.dart` aufsplitten (reine Datei-Teilung, geringes Risiko,
+   keine Verhaltensänderung).
+3. `verification` aus Settings herauslösen.
+4. `storage`-Fassade schrittweise erzwingen, immer im Zuge anderer Umbauten.
+5. `chat_timeline`/`rooms` zuletzt.
+
+**Bernd-Entscheidung nötig:** siehe Frage in PROGRESS.md – ob Punkt 1
+(Call-Pilot) so wie hier vorgeschlagen als Nächstes umgesetzt werden soll.

docs/M2_STATE_MANAGEMENT.md

@@ -0,0 +1,95 @@
+# M2 – Einheitliches State-Management: Ist-Analyse + Umbauplan
+
+> **STATUS 2026-07-06: reine Analyse, noch KEIN Umbau.** Grundlage für den
+> ROADMAP-M2-Punkt „Einheitliches State-Management (Riverpod konsequent,
+> keine Misch-Patterns)". Die Schritte 1–2 unten betreffen den heiligen
+> Call-Pfad und sind GESPERRT, bis Bernds Klick-Test des Call-Piloten
+> (`docs/PC_TESTPLAN.md` Abschnitt 8) grün ist – vorher nur Schritt 3.
+
+## Ist-Stand (repo-weit erhoben, 2026-07-06)
+
+Riverpod ist bereits das dominante Muster: rund 50 Provider –
+`StateProvider` für UI-Zustand, `StreamProvider` auf `client.onSync`,
+`FutureProvider` (Client, Update-Info), `StateNotifierProvider` für die
+Prefs-Notifier (`BoolPref`/`StringSetPref` in `core/settings_prefs.dart`).
+`ValueNotifier`/eigene `StreamController` gibt es NICHT. Lokales
+`setState` in Widgets für rein ephemeren Zustand (Hover, Dialog-Schritte,
+Textfelder) ist normales Flutter und zählt hier bewusst NICHT als
+Misch-Pattern.
+
+Gefundene Misch-Patterns, nach Gewicht:
+
+1. **Call-Schicht: Singletons + ChangeNotifier hinter den Fassaden.**
+   `LiveKitCallManager.instance` (static final Singleton,
+   `features/voice_channel/livekit_call_manager.dart:17`) und
+   `PyramidVoipManager._instance` (nullable static,
+   `features/call_signaling/voip_manager.dart:17`; konstruiert im
+   Kompositions-Punkt `core/matrix_client.dart:66–71`). Die Modul-Provider
+   (`voiceChannelProvider`/`callSignalingProvider`) geben nur die
+   Singletons zurück. Das ist die im Pilot BEWUSST gewählte Zwischenform
+   (Verhaltensgleichheit vor Schönheit). Eigentliches Problem: UI-Zustand
+   (Mute-Flags, Teilnehmer, Renderer, Qualitätswahl) lebt mutierbar IN den
+   Managern und wird per `notifyListeners()` grob-granular publiziert.
+2. **Voice-UI-Zustand außerhalb des Moduls:** `activeVoiceRoomIdProvider`
+   und `voiceParticipantsProvider` liegen in `core/app_state.dart`
+   (Kopplungspunkt laut Ist-Analyse), werden aber von Rooms-Panel und
+   Mini-Call-Widget gesetzt/gelesen und gehören fachlich ins
+   `voice_channel`-Modul (Join-Zustand + Presence sind Modulsache).
+3. **`MediaCache.instance`** (`core/media_cache.dart:19`): reines
+   Singleton, kein UI-Zustand, nur Cache. Nutzer sind `widgets/mxc_image.dart`
+   (7 Stellen, Widgets – leicht umstellbar) UND
+   `features/chat/message/message_media.dart` (7 Stellen, darunter der
+   statische Wrapper `_DocBytesCache` für Dokument-Vorschauen, dessen
+   Aufrufer keinen `ref`-Zugang haben). Eine Umstellung müsste `ref`/die
+   Cache-Instanz durch die statischen Helfer der Chat-Timeline fädeln –
+   und genau dieser Code (Download-/Entschlüsselungs-Fehlerpfade) ist
+   laut PC_TESTPLAN Abschnitt 3 der am wenigsten geprüfte Teil der App.
+4. **Push/Notifications:** modul-globale Mutable-Zustände in
+   `core/notification_service.dart` (`_windowsNotifs`-Map, Plugin-Globals)
+   und direkte `SharedPreferences`-Zugriffe in `background_push.dart`/
+   `fcm_push_service.dart`. Das ist dem Background-Isolate-Zwang
+   geschuldet (siehe Schnitt-Doc Punkt 8 + Memory „Pyramid Push") –
+   **bewusst KEIN Umbau-Kandidat**, nur hier dokumentiert.
+
+Bereits erledigt im Zuge dieser Analyse: der seit dem Call-Piloten tote
+`incomingCallProvider` ist aus `app_state.dart` entfernt (41bcaf2).
+
+## Zielbild
+
+- `core/app_state.dart` enthält nur noch ECHTEN App-weiten UI-Zustand
+  (Theme, Layout/Panels, Navigation, Toast, Space-Auswahl) – kein
+  Feature-Fachzustand.
+- Feature-Zustand lebt im jeweiligen Modul hinter dessen Provider;
+  andere Module lesen ihn NUR über die öffentliche Schnittstelle.
+- Kein `.instance`-Zugriff über Modulgrenzen; Konstruktion ausschließlich
+  im Kompositions-Punkt bzw. im Provider des Moduls.
+- ChangeNotifier ist als Übergangsform ok; Endzustand der Call-Module ist
+  ein immutables Zustandsobjekt (z. B. `VoiceChannelState`) pro Modul,
+  das der Provider publiziert, plus Kommando-Methoden auf dem Service
+  (entspricht dem Schnitt-Doc-Entwurf, dort als Stream skizziert).
+
+## Schrittfolge (Reihenfolge = Priorität)
+
+1. **[GESPERRT bis Klick-Test] UI-State aus den Managern herauslösen:**
+   je Call-Modul ein immutables Zustandsobjekt + `Notifier`/
+   `StateNotifier`, Manager wird interne Implementierung ohne
+   UI-Zustand. Das ist der bereits in PROGRESS.md zurückgestellte
+   Logik-Umbau – NICHT vorher anfangen (heiliger Call-Pfad, ein
+   ungetesteter Umbau liegt schon auf dem Stapel).
+2. **[GESPERRT bis Klick-Test] `activeVoiceRoomIdProvider` +
+   `voiceParticipantsProvider` ins `voice_channel`-Modul umziehen**
+   (zusammen mit `kVoicePresenceType`). Mechanisch klein, aber
+   Call-Pfad-nah – sinnvoll im selben Zug wie Schritt 1.
+3. **[ZURÜCKGESTELLT] `MediaCache` hinter `Provider<MediaCache>`:**
+   Erst als „risikoarm, jederzeit" eingestuft – das stimmte NICHT
+   (Korrektur 2026-07-06, siehe Ist-Stand Punkt 3: auch die Chat-Timeline
+   hängt dran, inkl. statischer Helfer ohne `ref`). Gehört in den Zug des
+   `chat_timeline`-Moduls (Schnitt-Doc Punkt 9) bzw. frühestens nach dem
+   Klick-Test von PC_TESTPLAN Abschnitt 3 – nicht als Lückenfüller.
+4. **[kein Umbau] Push/Notifications:** bleibt wie es ist
+   (Isolate-Zwang); nur bei ohnehin anstehenden Push-Arbeiten die
+   Prefs-Zugriffe auf die `Prefs`-Fassade ziehen (Schnitt-Doc Punkt 6).
+
+Abhak-Kriterium für den ROADMAP-Punkt: Schritte 1–3 umgesetzt und die
+Kernflows (Login, Raum, Nachricht, Voice-Join) nach jedem Schritt
+praktisch geprüft; Punkt 4 braucht nur den Doku-Vermerk (steht hiermit).

docs/NOTIFICATIONS.md

@@ -0,0 +1,170 @@
+# Push-Benachrichtigungen & E2EE im Hintergrund
+
+Stand: 2026-06-04. Dieses Dokument beschreibt, wie Pyramid auf Android
+verschlüsselte Push-Benachrichtigungen verarbeitet — inklusive Entschlüsselung
+und verschlüsseltem Antworten **bei komplett gekillter App**, ohne dass sich die
+App öffnet.
+
+## Überblick der Kette
+
+```
+Matrix-Homeserver (Continuwuity)
+        │  (event_id_only Push)
+        ▼
+Sygnal  (self-hosted: push.steggi-matrix.work)
+        ▼
+Firebase Cloud Messaging (FCM)
+        ▼
+PushService.kt  (FirebaseMessagingService, nativ)
+        ├─ App lebt im Vordergrund → App zeigt selbst, Push wird übersprungen
+        ├─ App lebt im Hintergrund → Haupt-Engine entschlüsselt (warm, schnell)
+        └─ App gekillt → BgEngine bootet ein headless Flutter-Isolate
+```
+
+Der Flutter-eigene FCM-Dienst (`FlutterFirebaseMessagingService`) ist im
+`AndroidManifest.xml` **deaktiviert** — alle Pushes laufen über `PushService.kt`.
+Push-Format ist `event_id_only` (nur die Event-ID wird übertragen, nicht der
+Inhalt — datensparsam).
+
+## Warum dieser Aufbau?
+
+Die E2EE-Schlüssel (olm/megolm) liegen **nur** im Matrix-Client (verschlüsselte
+SQLite-DB), nicht im nativen Kotlin-Code. Kotlin kann daher Sender + Raumname
+(unverschlüsselte Room-States) per HTTP holen, aber **nicht** den Nachrichtentext
+entschlüsseln. Dafür braucht es einen laufenden Matrix-Client.
+
+**Sicherheitsregel:** Niemals zwei Matrix-Clients gleichzeitig auf derselben
+olm-DB — das korrumpiert den Ratchet-State und führt zu dauerhaften
+„Unable to decrypt"-Fehlern. Deshalb läuft der Hintergrund-Client (`BgEngine`)
+**nur**, wenn die Haupt-App nachweislich tot ist (`FlutterEngineCache.get("main")
+== null`).
+
+## Die drei Zustände
+
+| Zustand | Erkennung | Pfad |
+|---|---|---|
+| Vordergrund | Heartbeat < 20s (`flutter.notif_app_heartbeat`) | Push übersprungen, App zeigt selbst |
+| Hintergrund (lebt) | `FlutterEngineCache.get("main") != null` | Platzhalter sofort → Haupt-Engine entschlüsselt + aktualisiert |
+| Gekillt | keine Haupt-Engine | `BgEngine` bootet headless Isolate, **decrypt-first** |
+
+## Gekillter Zustand im Detail (decrypt-first)
+
+1. `PushService.onMessageReceived` holt Titel (Sender · Raum) per HTTP.
+2. Statt sofort einen Platzhalter zu zeigen:
+   - `BgEngine.scheduleFallback(…, 6s)` plant einen „Neue Nachricht"-Platzhalter,
+     der **nur** erscheint, falls die Entschlüsselung > 6s dauert oder scheitert.
+   - `BgEngine.run("decryptAndShow", …)` bootet das Isolate.
+3. `BgEngine` (BgEngine.kt) startet eine headless `FlutterEngine` über den
+   gespeicherten Callback-Handle (`flutter.bg_engine_handle`) und führt das
+   Dart-Entrypoint `notificationEngineMain` (background_push.dart) aus.
+4. Dart `_bgDecryptAndShow`:
+   - `_buildClient()` öffnet **dieselbe** DB (`pyramid.sqlite`,
+     `MatrixSdkDatabase.init('pyramid')`, `NativeImplementationsDummy`).
+   - `client.getEventByPushNotification(...)` entschlüsselt mit den lokal
+     vorhandenen megolm-Schlüsseln (oneShotSync nur als Fallback).
+   - Gibt Titel + Text per MethodChannel `showDecrypted` an Native zurück.
+5. `BgEngine` zeigt via `NotificationHelper.show` die echte Nachricht und
+   bricht den Fallback-Platzhalter ab.
+
+Ergebnis: Die Benachrichtigung erscheint ~4 s nach der Nachricht **direkt mit
+echtem Text** (kein „Neue Nachricht"-Zwischenschritt). Die ~4 s sind der
+Engine-Bootstrap (~1,7 s) + Client-Init/Entschlüsselung (~2,3 s).
+
+## Darstellung: Chat-Verlauf statt Einzelnachricht (seit 2026-10-07)
+
+Auf Bernds Beta-Feedback („nur eine Nachricht, wenig Text, kein Bild“):
+
+- **Pro Raum ein Chat-Verlauf** (Android `MessagingStyle`) mit den letzten 8
+  Nachrichten, Absendername + Avatar je Nachricht, Gruppenname als Titel.
+  Der Verlauf liegt in SharedPreferences (`pyramid_notif_history`), weil bei
+  gekillter App jeder Push in einem neuen Prozess ankommt. Er wird nur
+  fortgeführt, solange die Benachrichtigung noch sichtbar ist (weggewischt
+  oder Raum geöffnet → nächster Push beginnt neu).
+- **Gleiche eventId = Aktualisierung**, nicht neue Nachricht: der
+  „Neue Nachricht“-Platzhalter wird durch den Klartext ersetzt, später kommen
+  lautlos Avatar/Bild dazu. Nur wirklich neue Nachrichten klingeln
+  (`setOnlyAlertOnce(!isNew)`).
+- **Text:** nicht mehr auf 100 Zeichen gekürzt (Deckel 1000), Antwort-Zitat
+  entfernt, Medien als „📷 Foto“/„🎤 Sprachnachricht“/„📎 datei.pdf“ usw.
+  Logik in `lib/core/notification_content.dart` (Tests:
+  `test/notification_content_test.dart`). Einstellung „Nachrichtenvorschau“
+  gilt jetzt auch bei gekillter App.
+- **Bilder/Avatare:** Dart legt sie unter `<cache>/downloads/notif/` ab
+  (Vorschaubild, bei E2EE entschlüsselt; Avatar aus dem MediaCache), native
+  reicht sie per FileProvider-URI an die System-UI weiter
+  (`grantUriPermission("com.android.systemui")`). Dateien älter als 2 Tage
+  werden aufgeräumt. Scheitert das Anzeigen mit Medien, fällt
+  `NotificationHelper` auf reinen Text zurück.
+- **„Gelesen“** setzt jetzt eine echte Lesebestätigung bis zur neuesten
+  Nachricht (Haupt-Engine `markReadFromNotification` bzw. BgEngine
+  `markRead`), statt nur zu schließen.
+- **Testen ohne Login (nur Debug-Build):** `DebugNotifyReceiver`
+  (`android/app/src/debug/`), z. B.
+  `adb shell "am broadcast -n chat.pyramid.pyramid/.DebugNotifyReceiver --es roomName Familie --es sender Uta --es event e1 --ez avatar true --es body 'Hallo'"`
+  (`--ez image true` für ein Testbild). Nicht im Release-APK.
+
+## Verschlüsselt antworten (gekillt, vollständig still)
+
+- Die Reply-Action ist ein **BroadcastReceiver** (`getBroadcast` → `ReplyReceiver`),
+  **nicht** MainActivity — die App öffnet sich also nicht.
+- `ReplyReceiver`:
+  - App lebt → MethodChannel `replyFromNotification` an die Haupt-Engine.
+  - Gekillt → `BgEngine.run("sendReply", …)` → Dart `_bgSendReply` → oneShotSync +
+    `room.sendTextEvent` (verschlüsselt). `goAsync()` + finish nach 15 s hält den
+    Receiver-Prozess am Leben, bis der Versand durch ist.
+- RemoteInput-Extraktion hat mehrere Key-Fallbacks (OEM-Eigenheiten) und
+  funktioniert auf Samsung S23 trotz der alten „getBroadcast verschluckt
+  RemoteInput"-Warnung.
+
+## Gelöste Fallstricke (NICHT wieder einbauen)
+
+1. **Loader-Reihenfolge:** `FlutterCallbackInformation.lookupCallbackInformation`
+   erst **nach** `flutterLoader.startInitialization` + `ensureInitializationComplete`
+   aufrufen — sonst `UnsatisfiedLinkError` (native Methode, libflutter.so noch
+   nicht geladen).
+2. **vodozemac doppelt:** Wenn Decrypt- und Reply-Task dasselbe wiederverwendete
+   Isolate nutzen, wirft das zweite `vod.init()` „already initialized". In
+   `_buildClient` in eigenem try/catch schlucken — sonst gibt `_buildClient`
+   still `null` zurück und die Antwort geht nicht raus.
+3. **`database_closed`-Rauschen:** Vor `client.dispose()` 2 s warten, damit der
+   asynchrone Key-Backup-Upload fertig wird.
+
+## Relevante Dateien
+
+| Datei | Rolle |
+|---|---|
+| `android/.../PushService.kt` | FCM-Empfang, Heartbeat-Check, decrypt-first-Routing |
+| `android/.../BgEngine.kt` | Headless-Engine-Bootstrap, Fallback-Platzhalter |
+| `android/.../ReplyReceiver.kt` | Stilles verschlüsseltes Antworten (Broadcast) |
+| `android/.../NotificationHelper.kt` | Native Benachrichtigung: Chat-Verlauf (MessagingStyle), Bilder, Antworten/Gelesen/Tippen |
+| `lib/core/notification_content.dart` | Inhalt einer Benachrichtigung (Text, Medien-Labels, Bild/Avatar-Dateien) |
+| `android/.../MainActivity.kt` | MethodChannel `install`, Cold-Start-Reply-Fallback |
+| `lib/core/background_push.dart` | Dart-Hintergrund-Isolate: decrypt + reply |
+| `lib/core/fcm_push_service.dart` | Pusher-Registrierung bei Sygnal |
+| `lib/core/notification_service.dart` | Vordergrund/Hintergrund-Notifs, Heartbeat |
+| `lib/main.dart` | `registerBgEngineHandle()` beim Start |
+
+## Debugging
+
+`flutter run` verliert die Verbindung, sobald die App gekillt wird — daher direkt
+`adb logcat` nutzen:
+
+```
+adb logcat -v time PYRAMID-PUSH:* PYRAMID-BGENGINE:* PYRAMID-REPLY:* PYRAMID-INTENT:* flutter:* AndroidRuntime:E *:S
+```
+
+Erwartete Log-Sequenz (gekillt, Erfolg):
+```
+PYRAMID-PUSH:     decrypt-first via background engine for <room>
+PYRAMID-BGENGINE: background engine started
+PYRAMID-BGENGINE: Dart background engine ready — flushing 1 task(s)
+PYRAMID-BGENGINE: showDecrypted → shown decrypted notification for <room>
+```
+Reply (gekillt):
+```
+PYRAMID-REPLY:    extracted replyText=… (remoteInput=true)
+PYRAMID-REPLY:    Flutter engine not running → background engine send
+PYRAMID-BGENGINE: (sendReply → sendTextEvent OK)
+```
+
+Hinweis: Kotlin lässt sich nur auf einem Rechner mit JAVA_HOME/Android-SDK bauen.

docs/PC_TESTPLAN.md

@@ -0,0 +1,178 @@
+# PC-Testplan – alle aufgelaufenen UNGETESTET(Pi)-Punkte
+
+Stand: 2026-07-03; Autopilot-Ergebnisse vom **2026-07-06** eingetragen.
+Alle Pi-Sessions seit dem 2026-07-03 konnten nur
+`flutter analyze` + automatisierte Textvergleiche fahren (kein GUI auf dem Pi).
+Dieser Plan konsolidiert JEDEN ausstehenden Praxistest aus PROGRESS.md an einer
+Stelle. Beim nächsten Windows-Lauf von oben nach unten abarbeiten, Ergebnis je
+Punkt hier eintragen (✅/❌ + Datum), Befunde als eigene PROGRESS-Einträge.
+
+Schnellster Weg: `flutter run -d windows`.
+
+> **Grenze des Autopilot-Laufs 2026-07-06:** Der Autopilot kann bauen,
+> testen und die App starten/beenden, aber NICHT in der UI klicken. Alles
+> Klick-Interaktive (Abschnitte 2–8, Logout/Re-Login in Abschnitt 1) braucht
+> Bernd am PC – die App-Starts heute liefen mit Bernds bestehender Session.
+
+## 0. Vorab (1 Minute)
+
+- [x] `flutter test` – ✅ 2026-07-06: **32 Tests grün** (24 Bestand + 5 neue
+      SQLCipher-Tests aus `test/app_database_test.dart` + 3 neue
+      VoicePrefs-Vertragstests in `test/settings_prefs_test.dart`),
+      mehrfach gelaufen (vor/nach jedem Umbau des Tages).
+
+- [x] **Seit 2026-10-07: alles Automatisierbare mit EINEM Befehl** –
+      `pwsh scripts/test.ps1 -All` (Analyse, 41 Unit-Tests, Live-Test mit
+      Test-Account, Benchmarks). Details: `docs/TESTS_UND_BENCHMARKS.md`.
+
+## 1. Härtetest Login/Krypto (M1 – PFLICHT, zuerst!)
+
+Deckt die Fixes 63e4919, 9dc83f7, 891f348 ab (Uta-Random-Logout + Guard).
+Seit 2026-07-06 zusätzlich relevant: SQLCipher-Migration ist auf diesem PC
+gelaufen – die lokale DB ist jetzt verschlüsselt (PROGRESS.md 2026-07-06).
+
+- [ ] Login mit Test-Account → Nachrichten in verschlüsseltem Raum senden/lesen
+      (Teil-Evidenz ✅ 2026-07-06: Bestands-Session blieb über 3 App-Starts
+      und die DB-Migration hinweg eingeloggt; App hat live to_device-Events
+      von @uta entschlüsselt und Room-Keys forwardet → Lesen/E2EE belegt.
+      Aktives SENDEN + frischer Login noch offen → Klick-Test Bernd)
+- [x] `auth_log.txt` (App-Support-Verzeichnis) prüfen: ✅ 2026-07-06 –
+      LoginState-Wechsel werden mitgeschrieben (je Start `loggedIn`), dazu
+      der DB-Migrations-Eintrag; keine unerwarteten Warnungen, kein
+      Soft-Logout-Eintrag.
+- [ ] Logout (Warnung bei fehlendem Key-Backup erscheint? b5762ea) – Klick-Test
+- [ ] Erneuter Login → **alte verschlüsselte Nachrichten noch lesbar?** – Klick-Test
+- [x] Mehrere Stunden laufen lassen: kein Random-Logout, kein
+      Login-Screen-Flackern (isLoggedInProvider-Änderung), `auth_log.txt`
+      zeigt ggf. „Soft-Logout durch Token-Refresh abgewendet"
+      (ERFÜLLT 2026-07-07 03:06: Fenster 22:49–03:06 = >4 h am Stück ohne
+      Logout, sechs echte Netzausfälle kumulativ überstanden; ein
+      Login-Screen-Flackern wäre als `LoginState`-Wechsel im auth_log
+      sichtbar – keiner vorhanden. Historie: Zwischenstand 2026-07-06 16:57: Der 12:43-Lauf endete
+      schon ~13:03 (letzter DB-Write; keine Absturzspur in Event-Log/WER,
+      kein Logout-Eintrag – vermutlich Fenster geschlossen). Im 20-min-
+      Fenster KEIN Random-Logout. Session überlebte danach den 4. Start
+      mit verschlüsselter DB (auth_log 16:57:46 `loggedIn`, keine erneute
+      Migration). Danach zwei geplante Neustarts für die Refactoring-
+      Praxistests (17:08 VoicePrefs/call_ui, 17:14 voice_channel-Split),
+      jeweils sauberer `loggedIn`, die Fenster dazwischen ohne Auffälligkeit
+      (16:57–17:08 ≈ 50 min sauber). **Check 17:37 (dritte PC-Session):**
+      Fenster 17:14–17:42 sauber – kein Logout-/Fehler-Eintrag, DB-Writes
+      liefen durchgehend; Lauf um 17:42 vom Autopilot beendet (Rebuild für
+      den settings_encryption-Split). Beobachtung läuft seit 17:43 mit dem
+      aktuellen Code (auth_log 17:43:14 `loggedIn`, keine Migration).
+      **Check 18:19 (vierte PC-Session), Fenster 17:43–18:19:** kein Logout,
+      und obendrauf der bisher wertvollste Positiv-Befund – ein ECHTER
+      Netzausfall 18:09:57–18:16:39 (~7 min, „Client has not connection to
+      the server" alle 3 s im auth_log) wurde sauber überstanden: kein
+      Logout, keine Eskalation, Sync erholte sich von selbst (WAL-Write
+      18:18:13 nach der letzten Fehlerzeile). Genau der Fehlerpfad, den die
+      Fixes 63e4919/9dc83f7/891f348 absichern sollen. **Check 18:29:**
+      zweiter, kurzer Netz-Blip 18:25:56 (~40 s) ebenfalls selbst erholt
+      (WAL-Write 18:28:38 danach), wieder kein Logout. Beobachtung läuft
+      weiter (Lauf seit 17:43, nächstes Fenster ab 18:29); erst nach einem
+      echten Mehr-Stunden-Fenster abhaken.
+      **Check 23:12 (Nacht-Session), Fenster 18:29–22:49:** dritter
+      Netzausfall 18:41:32–18:46:03 (~4,5 min, wieder „Client has not
+      connection") ebenfalls selbst erholt, KEIN Logout, keine Eskalation;
+      danach bis zum geplanten Stopp (Rebuild für die Nacht-Session-Fixes)
+      keine weiteren Einträge. Neustart 22:49:22 `loggedIn`, KEINE
+      Re-Migration → 8. Start in Folge mit verschlüsselter DB sauber.
+      Fenster 22:49–23:12 leer, WAL-Writes laufen (23:12:33). Beobachtung
+      läuft weiter, nächstes Fenster ab 23:12.
+      **Check 03:06 (2026-07-07, Nacht-Session 2), Fenster 23:12–03:06:**
+      DREI weitere Netz-Blips, alle selbst erholt, KEIN Logout: 01:32:17–
+      01:32:20 (~3 s), 02:01:53–02:06:36 (~4,7 min), 02:33:21–02:36:37
+      (~3,3 min; „Client has not connection" alle 3 s). WAL-Write 03:05:43
+      NACH der letzten Fehlerzeile, Prozess (PID 47412, seit 22:49) lebt.
+      Gegenprobe: die parallel laufende pyramidtest1-Instanz (profile1)
+      loggt DIESELBEN Fenster → echter Netz-/Server-Ausfall, nicht
+      app-spezifisch; auch sie ohne Logout erholt. Server beim Check
+      wieder erreichbar (HTTP 200). Beobachtung läuft weiter, nächstes
+      Fenster ab 03:06.
+      Kumulativ: 2026-07-06 12:26 – 2026-07-07 03:06 über 8 Starts, sechs
+      echte Netzausfälle (~7 min / ~40 s / ~4,5 min / ~3 s / ~4,7 min /
+      ~3,3 min) – ohne einen einzigen Random-Logout. Das aktuelle Fenster
+      22:49–03:06 ist erstmals ein echtes Mehr-Stunden-Fenster (>4 h) am
+      Stück.)
+- [ ] Ergebnis als „Härtetest"-Eintrag in PROGRESS.md dokumentieren
+      (= ROADMAP-M1-Punkt „Härtetest dokumentieren" abhaken)
+- [ ] Android: nach Neu-Login beobachten, ob Push-Inhalte wieder echt
+      entschlüsselt ankommen (statt „Neue Nachricht"-Platzhalter). Falls nicht:
+      zweite Ursache, siehe `docs/NOTIFICATIONS.md` + Memory „Pyramid Push"
+- [ ] Danach Uta: einmal aus- und wieder einloggen (erst dann hat ihre
+      Session einen Refresh-Token!)
+
+## 2. Settings-Split (5d77238, 12 Teildateien)
+
+Alle Reiter öffnen und benutzen: Profil, Benachrichtigungen, Erscheinungsbild,
+Voice, Tastaturkürzel, Privatsphäre, Sessions, Verschlüsselung, Account, Über.
+
+- [ ] Verschlüsselung (HEILIG): Recovery-Key anzeigen, Megolm-Export UND
+      -Import (Passphrase), SAS/QR-Verifizierung starten
+- [ ] Sessions: Gerät umbenennen, Einzel-Logout, Massen-Logout-Dialog
+      (Passwort-Reauth) nur bis zur Abfrage
+- [ ] Account: Passwort-ändern-Dialog öffnen, Account-löschen-Dialog öffnen
+      (NICHT bestätigen)
+- [ ] Logout-Warnungs-Text bei fehlendem Backup sichtbar (settings_about/shared)
+
+## 3. Chat-Timeline-Split (5bf45a9) + tote-Code-Bereinigung (6400fb6)
+
+Einen Chat mit allen Nachrichtentypen durchgehen:
+
+- [ ] Text mit Link-Vorschau, Bild, Video, Audio, Datei-Anhang
+- [ ] Download-/Entschlüsselungs-Fehlerpfade in `message_media.dart` gezielt
+      ansehen (am wenigsten geprüfter Teil)
+- [ ] Reaktionen setzen/entfernen, Hover-Aktionsleiste, Antworten/Zitat
+- [ ] Datums-Trenner, „Neue Nachrichten"-Divider
+- [ ] Gescheiterte Nachricht: bleibt mit Retry/Löschen stehen, Retry geht
+- [ ] Zeitanzeige bei aufeinanderfolgenden Nachrichten + Hover-Uhrzeit bei
+      Fortsetzungsnachrichten (`_formatMessageTime`-Zusammenführung)
+
+## 4. Raumlisten-Split (a863fa3) + Reorder-Fix (401bd6a)
+
+- [ ] Space wechseln, Raum beitreten/verlassen
+- [ ] **Drag&Drop-Umsortieren: landet der Raum EXAKT an der Zielposition?**
+      (onReorder→onReorderItem, Index-Korrektur jetzt im Framework – Off-by-One
+      wäre hier sichtbar; nach oben UND nach unten ziehen testen)
+- [ ] Voice-Channel-Teilnehmerliste in der Raumliste
+- [ ] Einladung annehmen/ablehnen, Ungelesen-Badge, DM-Avatare
+
+## 5. Space-Admin-Split (0c7d359)
+
+An einem TEST-Space, nicht an Utas echtem:
+
+- [ ] Übersicht: Sichtbarkeit umschalten, Banner ändern (Danger-Zone nur ansehen)
+- [ ] Mitglieder: einladen, Rolle ändern (Selbst-Aussperr-Schutz
+      `updatePowerLevelsSafely` greift?), kicken
+- [ ] Berechtigungen ändern, Kanäle: erstellen + bestehenden Raum hinzufügen
+
+## 6. Chat-View-Split (31e4001)
+
+- [ ] Chat-Header (normal + DM mit ausklappendem Header/Presence)
+- [ ] Tippanzeige, Offline-/Reconnect-Banner (Netz kurz trennen)
+- [ ] Datei per Drag&Drop in den Chat ziehen (Overlay + Senden)
+
+## 7. Dokument-Viewer-Split (daf4cf3) + Matrix4-Fix (401bd6a)
+
+- [ ] PDF inline im Chat, Vollbild-Viewer: **Zoom per Buttons/Strg+Mausrad**
+      (translateByDouble/scaleByDouble-Umbau – zoomt es zentriert wie vorher?),
+      Seiten-Navigation, Thumbnail-Leiste, Speichern-Button
+- [ ] Text/Markdown/SVG-Vorschau, Office-Text-Extraktion
+- [ ] ZIP/TAR-Archiv-Browser, PSD-Thumbnail
+- [ ] Bild im Chat öffnen (Fallback-Pfade)
+
+## 8. Kleinkram aus den Lint-Commits
+
+- [ ] Mini-Call-Widget: Buttons zeigen jetzt Hover-Farbe (9dc1175, gewollt) –
+      sieht das ok aus?
+- [ ] Anhang-Dialog + Raum-erstellen-Dialog: Switches (activeThumbColor) sehen
+      aus wie vorher
+- [ ] Voice-Channel beitreten/verlassen (Kernflow laut CLAUDE.md, von den
+      Splits nicht berührt, aber Pflicht nach jedem Refactoring)
+
+## Danach
+
+- [ ] Alle ✅ hier eintragen, PROGRESS.md-Eintrag „PC-Praxistest" schreiben,
+      erst DANN neue riskante Punkte anfangen (Call-Fassade, SQLCipher –
+      siehe `docs/SQLCIPHER_MIGRATION.md`)

docs/PROGRESS.md

@@ -0,0 +1,45 @@
+# Pyramid – Fortschritt & offene Punkte (ARCHIV, Stand 2026-06-04)
+
+> **ACHTUNG:** Dies ist ein eingefrorener Alt-Stand von vor der neuen
+> Arbeitsstruktur. Das aktuelle Arbeitsprotokoll liegt im Projekt-Root:
+> `PROGRESS.md`. Diese Datei nur als historische Referenz lesen, nie pflegen.
+
+## Erledigt
+
+### Chat / UI
+- **Reply-Zitat-Karte** im Discord/WhatsApp-Stil (kein „In reply to @user" mehr), medien-bewusste Vorschau, getönter Hintergrund bündig mit Akzent-Strich.
+- **Per-Message-Selektion & -Hover** — einzelne Nachrichten statt ganzer Sender-Gruppen werden markiert/hervorgehoben.
+- **Scroll-Stabilität** — Crash durch doppelte Keys behoben, Pagination (kein endloses „Zurückziehen", lädt aber bis zum echten Anfang), Bild-/PDF-Platz wird vorab reserviert (kein Springen beim Laden).
+- **„Neue Nachrichten"-Divider** — korrekte Position, scrollt zuverlässig hin, blendet beim Erreichen des Endes aus; erscheint nur bei echten ungelesenen Nachrichten von anderen.
+- **Composer-Höhe** bündig mit dem Profil-Block; **Verbindungs-Statusbanner** bei Sync-Verlust; **fehlgeschlagene Nachrichten** bleiben mit „Wiederholen/Löschen" stehen statt zu verschwinden.
+- **„Zuletzt online"** nutzt echten Presence-Status + Frische statt `currentlyActive` (kein falsches „online" mehr).
+- **Members-Panel** mobil schließbar + schmaler.
+
+### Medien & Dokumente
+- **Media-Cache** (LRU, byte-budgetiert, geteilt) — zuletzt betrachtete Medien sofort da, ältere automatisch verworfen.
+- **Datei-Vorschau** — höhere Auflösung (PNG statt JPEG), viele neue Text/Code/Daten-Formate, **immersiver Fullscreen-Viewer** (Pan, +/− 20%-Zoom, Ctrl+Mausrad, Seiten-Navigation, mobil-optimiert, Tap blendet UI aus).
+- **Eingebettete Link-Vorschauen** (Open-Graph-Karten) — serverseitig in Continuwuity aktiviert + Client-Karte.
+
+### Suche
+- **Lokale Suche** über entschlüsselte Events (server-seitige `/search` funktioniert nicht für E2EE) — Nachrichten, Medien (mit **Thumbnail**), Personen/Räume.
+- **Sprung zur Nachricht** aus dem Suchergebnis inkl. Cross-Chat, mit sanft ausblendendem Highlight.
+
+### Benachrichtigungen (Android)
+- Bei **gekillter App**: Hintergrund-Entschlüsselung (decrypt-first) + **verschlüsseltes Antworten** ohne App-Öffnen. Details siehe [NOTIFICATIONS.md](NOTIFICATIONS.md).
+
+### Einstellungen
+- **Mobile Settings** im Element-Stil: Kategorie-Liste → Untermenü mit Zurück-Pfeil (statt gedrängtem Icon-Block). Desktop unverändert.
+
+### Server (Pi 5, steggi@192.168.178.71)
+- rclone-Mount für Pixeldrain-Medien repariert + Boot-Reihenfolge abgesichert; Medien liegen nur auf Pixeldrain.
+- URL-Preview-Allowlist in `conduit.toml` aktiviert.
+
+### Lesebestätigungen (Element-Stil, mit Haken)
+- **✓✓** an der zuletzt gesehenen Nachricht des Gegenübers (auch dessen eigener Antwort), berechnet aus `room.receiptState`. Wandert mit, statt an der eigenen letzten Antwort zu kleben.
+- **grauer ✓** nur auf der eigenen neuesten Nachricht, solange sie noch ungelesen ist; verschwindet sobald gelesen (dann nur ✓✓).
+
+## Offen / geplant
+- **Weiterleiten** von Nachrichten (Forward) — später.
+- **Presence-Genauigkeit:** Nutzer, die den PC vor ~10 min unsauber heruntergefahren haben, werden teils noch als „online" angezeigt (Server expired Presence nicht zuverlässig). Außerdem: Online-Status im Chat-Header und in der Chat-Liste sind nicht immer konsistent — sollten dieselbe Quelle nutzen.
+- PDF-Seiten beim Upload vorrendern — bewusst zurückgestellt (geringer Mehrwert wegen Caches).
+- Selection-Menü-Politur (kein Bug, optional).

docs/SQLCIPHER_MIGRATION.md

@@ -0,0 +1,147 @@
+# SQLCipher-Migration der `pyramid.sqlite` – Umsetzungsplan (PC-Termin)
+
+> **STATUS 2026-07-06: UMGESETZT (`lib/core/app_database.dart`) und auf
+> Windows mit Bernds echter 14-MB-DB praxisgetestet** (Migration gelaufen,
+> 23 Tabellen verifiziert, Login/E2EE danach intakt, Neustart öffnet die
+> verschlüsselte DB, `flutter test` deckt Migration/Fehlpfade mit echtem
+> SQLCipher ab).
+> **Android-Emulator-Test 2026-07-06 (API 36, x86_64, Debug-APK) GRÜN:**
+> (a) frische Installation legt die DB direkt verschlüsselt an
+> (Header = Zufallsbytes, per run-as verifiziert), kein Cipher-Fallback im
+> auth_log; (b) Update-Szenario nach `pm clear` + untergeschobener
+> Klartext-DB (synthetisch, 2 Tabellen/550 Zeilen): Migration lief beim
+> ersten Start („2 Tabellen verifiziert" im auth_log), `.premigration`
+> liegt da, DB danach verschlüsselt; (c) Neustart öffnet mit dem
+> Keystore-Schlüssel OHNE Re-Migration, App rendert normal den
+> Login-Screen. Damit sind openCipherOnAndroid, sqlcipher_export und
+> flutter_secure_storage auf Android (Haupt-Isolate) real belegt.
+> **Offen bleibt (deshalb Punkt 4 NICHT voll abgehakt):** echtes
+> ARM-Gerät, Migration einer ECHTEN eingeloggten Session auf Android und
+> der Push-Test (FCM-Isolate liest verschlüsselte DB, secure_storage im
+> Background-Isolate) – braucht ein Testgerät mit eingeloggtem Account.
+> Erst danach Release und Uta. **Abweichung vom Plan unten:** Die Annahme „keine Desktop-Binaries"
+> ist seit sqlcipher_flutter_libs 0.6.x überholt – das Plugin baut SQLCipher
+> auf Windows/Linux als `sqlite3.dll`/`libsqlite3.so` mit (im Build-Output
+> verifiziert). Deshalb ist Phase 1 NICHT Android-only: Windows/Linux
+> verschlüsseln ebenfalls, ein Test-Override ist unnötig. iOS/macOS bleiben
+> Klartext (SQLCipher-Pod kollidiert mit firebase_messaging, kein Release-Ziel).
+
+## Für Bernd in einfach
+
+Die Datenbank der App (Nachrichten, Zugangs-Token, Verschlüsselungs-Schlüssel)
+liegt heute **unverschlüsselt** auf dem Gerät – geschützt nur durch die
+Android-App-Sandbox. Ein Angreifer bräuchte Root oder physischen Zugriff mit
+Entwickler-Tools, um sie zu lesen. Dieser Plan verschlüsselt die Datei selbst.
+Der riskante Teil ist nicht die Verschlüsselung, sondern die **einmalige
+Umwandlung bestehender Installationen** (Utas Handy!) – deshalb: erst am PC
+mit Testdaten, dann eigenes Gerät, dann erst Release.
+
+**Offene Entscheidung (Frage in PROGRESS.md):** Priorität vor/nach M2?
+
+## Ist-Zustand (verifiziert im Code)
+
+| Stelle | Datei | Factory heute |
+|---|---|---|
+| Haupt-App Android/iOS | `lib/core/matrix_client.dart:24` | `sqflite_native.databaseFactory` (System-SQLite, **kann kein SQLCipher**) |
+| Haupt-App Desktop | `lib/core/matrix_client.dart:27` | `databaseFactoryFfi` (gebündeltes sqlite3) |
+| Push-Isolate (nur Android) | `lib/core/background_push.dart` `_buildClient()` | `sqflite_native.databaseFactory` |
+
+- `sqlcipher_flutter_libs ^0.6.8` ist bereits in `pubspec.yaml`, wird nirgends benutzt.
+- `flutter_secure_storage ^10` ist bereits da (→ Schlüsselablage im Android Keystore).
+- Beide Prozesse öffnen **dieselbe Datei** (`pyramid.sqlite`, WAL-Modus,
+  `busy_timeout 5000`).
+
+## Zielarchitektur
+
+1. **Ein gemeinsamer DB-Öffner** `lib/core/app_database.dart` (neues Storage-Modul
+   im Sinne von M2): kapselt Factory-Wahl, PRAGMAs, Schlüsselbeschaffung und
+   Migration. `matrix_client.dart` und `background_push.dart` rufen NUR noch
+   diese Fassade – damit verschwindet auch die heutige Code-Duplikation der
+   PRAGMA-Blöcke.
+2. **Android:** nicht mehr `sqflite_native`, sondern `databaseFactoryFfi` mit
+   SQLCipher-Lib:
+   ```dart
+   import 'package:sqlite3/open.dart';
+   import 'package:sqlcipher_flutter_libs/sqlcipher_flutter_libs.dart';
+   open.overrideFor(OperatingSystem.android, openCipherOnAndroid);
+   ```
+   **Achtung Push-Isolate:** `databaseFactoryFfi` spawnt ein eigenes Isolate –
+   im Firebase-Background-Isolate ist das genau die Fallenklasse, an der schon
+   `NativeImplementationsIsolate` scheiterte (Kommentar in
+   `background_push.dart`). Dort deshalb `databaseFactoryFfiNoIsolate` benutzen.
+3. **Schlüssel:** 32 Byte kryptografisch zufällig (`Random.secure()`), hex-kodiert
+   in `flutter_secure_storage` unter `db_cipher_key`. Beide Prozesse lesen
+   denselben Eintrag. Schlüssel wird bei ERSTER Nutzung erzeugt; existiert schon
+   eine verschlüsselte DB, aber kein Schlüssel im Storage → harter Fehler mit
+   Klartext-Meldung, NIEMALS still neue DB anlegen (Datenverlust-Regel!).
+4. **Öffnen:** `PRAGMA key = "x'<hex>'"` als allererstes Statement
+   (`OpenDatabaseOptions(onConfigure: ...)`), danach wie bisher WAL + busy_timeout.
+5. **Windows/Linux-Desktop:** `sqlcipher_flutter_libs` liefert dort KEINE
+   Binaries. Phase 1 = nur Android verschlüsseln (dort liegt das echte Risiko,
+   dort sind die echten Nutzer); Desktop bleibt vorerst Klartext, klar im Code
+   kommentiert. Desktop-SQLCipher später als eigener Punkt (eigene DLL bündeln).
+
+## Migration bestehender Klartext-DBs (der heikle Teil)
+
+Reihenfolge beim App-Start, VOR `MatrixSdkDatabase.init`, VOR jedem Push-Zugriff:
+
+1. Erkennung: Datei beginnt mit `SQLite format 3\0` → Klartext → Migration nötig.
+   (Verschlüsselte SQLCipher-Dateien haben keinen lesbaren Header.)
+2. WAL eindampfen: Klartext-DB kurz normal öffnen,
+   `PRAGMA wal_checkpoint(TRUNCATE)`, schließen – sonst verlieren wir Daten,
+   die noch in `pyramid.sqlite-wal` liegen.
+3. **Backup:** `pyramid.sqlite` → `pyramid.sqlite.premigration` kopieren
+   (Bytes, nicht rename). Bleibt bis zum verifizierten Erfolg liegen.
+4. Export in NEUE Datei (Original bleibt unangetastet):
+   ```sql
+   ATTACH DATABASE 'pyramid.enc.sqlite' AS enc KEY "x'<hex>'";
+   SELECT sqlcipher_export('enc');
+   DETACH DATABASE enc;
+   ```
+   (läuft über die SQLCipher-FFI-Verbindung auf der Klartext-DB)
+5. Verifikation: `pyramid.enc.sqlite` mit Schlüssel öffnen,
+   `PRAGMA integrity_check` == ok UND Zeilenzahl einer Kerntabelle
+   (z. B. `box_inbound_group_session`, Name gegen matrix-6.2.0
+   `matrix_sdk_database.dart:139` verifiziert) identisch mit Original. Schlägt IRGENDWAS
+   fehl → `pyramid.enc.sqlite` löschen, App startet normal mit Klartext-DB
+   weiter, Fehler in `auth_log.txt`. **Kein Zustand darf die Klartext-DB
+   beschädigt zurücklassen.**
+6. Tausch: Original + `-wal`/`-shm` löschen, `pyramid.enc.sqlite` →
+   `pyramid.sqlite` (rename, gleiche Partition = atomar).
+7. `.premigration`-Backup erst nach N erfolgreichen Tagen / manuell löschen
+   (Entscheidung Bernd: sonst liegt weiter eine Klartext-Kopie herum –
+   Kompromiss: nach 7 Tagen beim Start automatisch löschen).
+
+### Race mit dem Push-Isolate
+
+Kommt ein FCM-Push, während die Haupt-App migriert, würde das Isolate die DB
+mittendrin öffnen. Lösung: Marker-Datei `pyramid.sqlite.migrating` vor Schritt 2
+anlegen, nach Schritt 6 löschen; `_buildClient()` im Push-Pfad bricht bei
+vorhandenem Marker sofort ab (Notification zeigt dann einmalig den
+„Neue Nachricht"-Platzhalter – akzeptabel). Zusätzlich erkennt das Isolate
+selbst Klartext vs. verschlüsselt am Datei-Header und wählt PRAGMA key
+entsprechend – es migriert aber NIE selbst.
+
+## Testplan (PC-Termin, in dieser Reihenfolge)
+
+1. Windows-Build mit Test-Account: Migration Klartext→SQLCipher durchlaufen
+   lassen (Desktop kriegt fürs TESTEN die FFI-SQLCipher-Variante per lokalem
+   Override, auch wenn Phase 1 sie im Release nicht aktiviert).
+2. Kernflow danach: Login erhalten? Alte verschlüsselte Nachrichten lesbar?
+   Logout → Neu-Login → immer noch lesbar? (`docs/PC_TESTPLAN.md` Abschnitt 1)
+3. Fehlerpfade erzwingen: Migration mit vollem Datenträger / Kill mitten in
+   Schritt 4 → App muss mit unversehrter Klartext-DB weiterlaufen.
+4. Android-Testgerät (eigenes, NICHT Uta): frische Installation (Neuanlage
+   verschlüsselt), dann Update-Szenario (bestehende Klartext-DB migriert),
+   dann Push-Test (Isolate liest verschlüsselte DB; secure_storage-Zugriff
+   aus dem Background-Isolate explizit verifizieren – bekanntes Risiko).
+5. Erst wenn 1–4 grün: Release, Uta informieren (ihr Gerät migriert beim
+   ersten Start automatisch; vorher ihr Key-Backup verifizieren!).
+
+## Bewusst NICHT im Scope
+
+- `auth_log.txt`, `SharedPreferences`, Media-Cache bleiben Klartext (keine
+  Geheimnisse bzw. nur Cache; einzeln bewerten, falls Bernd es wünscht).
+- Passphrase-basierter Schlüssel (Nutzer-Eingabe): bewusst nein – Schlüssel
+  liegt im Keystore, gleiche Vertrauensstufe wie der Rest der App-Daten,
+  aber Datei-Exfiltration allein reicht dann nicht mehr.

docs/STREAMING_60FPS.md

@@ -0,0 +1,50 @@
+# Streaming: hohe Auflösung + 60 FPS (M4)
+
+**Ziel (Bernd):** Bildschirm-Streams ruckeln aktuell. Es soll eine hohe Streaming-Einstellung
+geben – hohe Auflösung UND hohe FPS, idealerweise **60 FPS**, flüssig.
+
+## Ist-Zustand (im Code gefunden, 2026-07-06)
+
+Datei `lib/features/voice_channel/livekit_call_manager.dart`:
+- `qualityPresets` (~Z. 21): Auflösungs-Presets `sd`(360p) / `hd`(720p) / `fhd`(1080p) / `4k`(2160p).
+- `_screenShareEncodings` (~Z. 28): **FPS hart gedeckelt** – `sd`=10, `hd`=15, `fhd`=20, `4k`=30.
+  **Es gibt KEIN 60-FPS-Preset.** Bitraten für hohe FPS zu niedrig (fhd nur 2,5 Mbit/s @20,
+  4k nur 4 Mbit/s @30).
+- `startScreenShare` (~Z. 453): erstellt `ScreenShareCaptureOptions(maxFrameRate: …)` und
+  published mit `simulcast: true`, `degradationPreference: DegradationPreference.balanced`.
+- **`contentHint` wird NICHT gesetzt** → der Encoder weiß nicht, dass es bewegtes Video ist,
+  und priorisiert Detail/Auflösung statt Framerate → Ruckeln.
+- `_applyFpsToAllSimulcastLayers` (~Z. 485) hebt die FPS nachträglich auf allen Simulcast-Layern an.
+
+UI `lib/features/call_ui/view/quality_menu.dart` (~Z. 21): „SENDEN"-Menü listet sd/hd/fhd/4k.
+
+## Wahrscheinliche Ruckel-Ursachen
+1. `maxFramerate` hart auf 20–30 begrenzt (nie 60).
+2. Zu niedrige Bitrate für hohe FPS → Encoder verwirft/verwischt Frames.
+3. `contentHint` nicht auf `motion` → Encoder opfert FPS für Detail.
+4. `degradationPreference: balanced` → unter Last sinkt eher die FPS als die Auflösung.
+
+## Aufgabe
+1. **Neue High-FPS-Presets** für die Send-Qualität, z. B.:
+   - `hd60`  → 720p,  `VideoEncoding(maxBitrate ~4–5 Mbit/s, maxFramerate 60)`
+   - `fhd60` → 1080p, `VideoEncoding(maxBitrate ~6–8 Mbit/s, maxFramerate 60)`
+   Sowohl in `qualityPresets` (Auflösung) als auch `_screenShareEncodings` (Bitrate/FPS) eintragen
+   und im „SENDEN"-Menü in `quality_menu.dart` als „HD 60fps" / „Full HD 60fps" ergänzen.
+2. **`contentHint = 'motion'`** auf dem Screenshare-Track setzen (flutter_webrtc/LiveKit-Feld) –
+   wichtigster Einzelhebel gegen Ruckeln bei Bewegung.
+3. Für die 60-FPS-Modi **`degradationPreference: DegradationPreference.maintainFramerate`**
+   statt `balanced` (unter Last lieber Auflösung senken als FPS).
+4. Sicherstellen, dass 60 wirklich durchgereicht wird – auch in `ScreenShareCaptureOptions.maxFrameRate`
+   und `_applyFpsToAllSimulcastLayers`.
+5. Für den flüssigen 60-FPS-Modus **`simulcast: false` erwägen** (volle Bitrate auf einen Layer),
+   A/B gegen simulcast=true testen.
+
+## Testen (mit den Test-Accounts)
+- Streamen als pyramidtest1, zuschauen als pyramidtest2 (zwei Logins/Fenster).
+- Prüfen, dass `sender.parameters.encodings` real `maxFramerate == 60` und die hohe `maxBitrate` tragen.
+- Subjektiv: flüssiger? Bei Bewegung kein Ruckeln?
+- EHRLICH protokollieren, was wirklich getestet wurde. Echtes flüssiges 60-FPS-Empfinden ist ggf.
+  nur mit echtem Gerät/Netz voll beurteilbar → dann klar als UNGETESTET markieren.
+
+## Nicht vergessen
+`flutter analyze` sauber, kleiner Commit + Push, PROGRESS.md + ROADMAP (M4) pflegen.

docs/TESTS_UND_BENCHMARKS.md

@@ -0,0 +1,137 @@
+# Tests & Benchmarks
+
+Stand: 2026-10-07. Alles läuft mit **einem Befehl** aus dem Projektordner:
+
+```
+pwsh scripts/test.ps1            # Analyse + Unit-Tests (~1 min) – vor jedem Commit
+pwsh scripts/test.ps1 -Live      # + Live-Test gegen steggi-matrix.work (Test-Account)
+pwsh scripts/test.ps1 -Bench     # + Benchmarks (Datenbank/Verschlüsselung, Migration)
+pwsh scripts/test.ps1 -Ui        # + UI-Durchlauf im Handy-Format mit Screenshots
+pwsh scripts/test.ps1 -All       # alles (~4 min)
+```
+
+Am Ende steht eine Zusammenfassung mit OK/FEHLER je Schritt. Fehlt die
+SQLCipher-Bibliothek (frischer Checkout), baut das Skript einmalig
+`flutter build windows --debug`.
+
+**Für Bernd in einem Satz:** Die Tests prüfen automatisch die heiklen Stellen
+(Login-/Logout-Schutz, Verschlüsselung der Datenbank, Suche, Einstellungen),
+die Benchmarks messen, ob die App dabei langsamer wird. Was man nur mit Klicken
+oder zwei echten Geräten prüfen kann, steht weiterhin in `docs/PC_TESTPLAN.md`.
+
+## Tests (`test/`)
+
+| Datei | Prüft | Läuft wann |
+|---|---|---|
+| `app_database_test.dart` | SQLCipher: Bibliothek echt, Header-Erkennung, Klartext→verschlüsselt-Migration, falscher Schlüssel, Fehlschlag lässt Daten unangetastet | immer (braucht die DLL aus dem Windows-Build) |
+| `soft_logout_guard_test.dart` | Uta-Random-Logout-Fix: Token-Refresh-Fehler enden nie im stillen Logout | immer |
+| `auth_log_test.dart` | Login-Protokoll (Diagnose für Logout-Bugs) | immer |
+| `power_levels_safety_test.dart` | Space-Admin kann sich nicht selbst aussperren | immer |
+| `settings_prefs_test.dart` | VoicePrefs-Fassade (gespeicherte Spracheinstellungen) | immer |
+| `streaming_presets_test.dart` | 60-FPS-Streaming-Presets (Auflösung/FPS/Bitrate) | immer |
+| `local_message_search_test.dart` | Lokale Nachrichtensuche (Strg+K): Treffer, Sortierung, Groß-/Kleinschreibung inkl. Umlaute, Medien-Filter, Trefferdeckel | immer (neu 2026-10-07) |
+| `live_encryption_e2e_test.dart` | Echter Login (pyramidtest1) → Platte verschlüsselt → Neustart → Logout → Re-Login → alte Nachricht lesbar; Utas Update-Fall mit echter Session | nur mit `-Live` |
+| `live_logout_race_test.dart` | Abmelden + sofortige Neuanmeldung auf demselben Client: neue Session muss bleiben (SDK-Wettlauf, `logoutWithoutStraySync`); mit `PYRAMID_LIVE_RACE_PROOF=1` zusätzlich Nachweis mit altem Weg | nur mit `-Live` |
+| `live_ui_fixture_test.dart` | Kein Test im engeren Sinn: legt Testinhalte (DM + Gruppe mit Bildern) für den UI-Durchlauf an | nur manuell mit `PYRAMID_LIVE_TEST=1` |
+| `live_call_setup_test.dart` | Kein Test im engeren Sinn: legt den Voice-Testraum für GUI-Call-Tests mit zwei Test-Accounts an | nur manuell mit `PYRAMID_LIVE_TEST=1` |
+
+`test/support/synthetic_matrix_data.dart` erzeugt synthetische Räume und
+Nachrichten über die **echte SDK-Speicherschicht** – komplett offline, ohne
+Konten. Tests und Benchmarks nutzen sie gemeinsam.
+
+Live-Tests: Zugangsdaten liegen AUSSERHALB des Repos
+(`%USERPROFILE%\.pyramid-autopilot\test-accounts.txt` bzw. `PYRAMID_TEST_ACCOUNTS`).
+Es sind die Test-Accounts `pyramidtest1/2`, nie Bernds oder Utas Konten.
+
+## UI-Durchlauf (`integration_test/`, seit 2026-10-07)
+
+`integration_test/mobile_ui_screens_test.dart` startet die ECHTE App
+(Windows-Build) mit dem Testprofil `pyramidtest1`
+(`PYRAMID_PROFILE_DIR=%USERPROFILE%\.pyramid-autopilot\profile1`) in
+simulierter Handy-Größe (1080×2340, Statusleiste 24 dp, Gestenleiste 16 dp),
+tippt sich durch Chatliste → Chat → Bild und prüft dabei: Vollansicht öffnet,
+Tippen daneben schließt, Tippen aufs Bild schließt nicht, Doppeltipp zoomt,
+Wischen nach unten schließt. Screenshots landen in `build/ui_screens/` – damit
+lassen sich UI-Änderungen ohne Handy ansehen.
+
+- Testinhalte (DM von pyramidtest2 mit langem Text, Antwort, Hoch- und
+  Querformat-Bild) legt `test/live_ui_fixture_test.dart` an
+  (`PYRAMID_LIVE_TEST=1`).
+- Läuft nur, wenn keine Pyramid-Instanz offen ist (nie zwei Clients auf
+  einer Datenbank) – das Skript prüft das.
+- Simulierte Fensterklicks (PostMessage) erreichen Flutter unter Windows
+  NICHT; deshalb dieser Weg über `integration_test`.
+
+## Benchmarks (`benchmark/`)
+
+Laufen bewusst NICHT im normalen `flutter test` mit (nur `-Bench` bzw.
+`flutter test benchmark --concurrency=1`).
+
+| Suite | Misst |
+|---|---|
+| `db_benchmark_test.dart` | Klartext- vs. SQLCipher-DB mit derselben Bibliothek: Sync-Schreiben (Transaktionen wie beim echten Sync), App-Start (DB öffnen + Raumliste), Chat öffnen (50 Nachrichten), lokale Suche (ohne Treffer = Worst Case, mit Treffern) |
+| `migration_benchmark_test.dart` | Dauer der einmaligen Klartext→SQLCipher-Migration beim ersten Start nach dem Update (exakt der App-Codepfad), danach Vollständigkeitsprüfung |
+
+**Wie gemessen wird:** DB im eigenen Isolate wie in der App; ungemessener
+Aufwärm-Durchlauf; Modi abwechselnd A-B-B-A (ohne das gewann einfach der
+später gemessene Modus um ±20 %, weil der Dart-JIT während des Laufs schneller
+wird); Median mehrerer Durchläufe.
+
+**Baseline & Regressionen:** Jeder Lauf schreibt `build/benchmarks/<suite>.json`
+und vergleicht mit `benchmark/baseline/<suite>.json`. Mehr als 25 % langsamer
+(und bei Zeiten mehr als 2 ms absolut) wird als „⚠ LANGSAMER" markiert.
+Umgebungsvariablen:
+
+- `-UpdateBaseline` bzw. `PYRAMID_BENCH_UPDATE_BASELINE=1` – aktuelle Werte als
+  neue Baseline speichern (nach bewusster Änderung oder auf neuer Hardware).
+  Die Baseline gilt nur für den Rechner, auf dem sie entstand.
+- `PYRAMID_BENCH_STRICT=1` – Regressionen lassen den Lauf scheitern.
+- `PYRAMID_BENCH_SCALE=0.2` – kleinere Datenmenge für einen schnellen Probelauf
+  (andere Mengen sind mit der Baseline nicht vergleichbar).
+
+### Erste Ergebnisse (2026-10-07, Bernds PC, 12 Kerne, Commit b2413ef)
+
+20 Räume × 500 Nachrichten (DB-Suite), 20 × 1000 (Migration):
+
+| Messung | Klartext | SQLCipher |
+|---|---|---|
+| Sync-Schreiben je Nachricht | 0,25 ms | 0,26 ms |
+| App-Start (DB + Raumliste) | 4,1 ms | 4,3 ms |
+| Chat öffnen (50 Nachrichten) | 0,33 ms | 0,32 ms |
+| Suche ohne Treffer (10 000 Nachrichten) | 64 ms | 64 ms |
+| Suche mit Treffern | 32 ms | 32 ms |
+| Migration Klartext → SQLCipher | – | 325 ms für 7,8 MB (≈ 42 ms/MB) |
+
+Was das heißt:
+
+- **Die Verschlüsselung kostet praktisch nichts.** Alle Unterschiede liegen im
+  Messrauschen (±5–10 %, zwei Läufe hintereinander). Die Kosten stecken im
+  Matrix-SDK selbst (JSON-Verarbeitung), nicht in SQLCipher.
+- **Sync-Schreiben** liegt bei ~0,26 ms pro Nachricht und hängt kaum von der
+  Raumgröße ab (nachgemessen: 250 vs. 4 000 Nachrichten pro Raum ≈ +15 %).
+- **Suche** wächst linear mit der Zahl der gespeicherten Nachrichten
+  (gedeckelt auf 1 500 pro Raum). Hochrechnung, nicht gemessen: 100 aktive
+  Räume am Deckel ≈ 150 000 Nachrichten ≈ 1 s pro Suche auf diesem PC –
+  auf Handys entsprechend länger. Kandidat für einen Suchindex (FTS), falls
+  das in der Praxis stört.
+- **Migration**: Hochrechnung für eine 100-MB-DB ≈ 4 s einmalig auf diesem
+  PC; auf Utas Handy vermutlich ein Mehrfaches davon (nicht gemessen).
+
+## Bekannte Grenzen (ehrlich)
+
+- Synthetische Daten: unverschlüsselte Räume, keine Olm/Megolm-Sessions
+  (vodozemac läuft im Host-Test nicht). Die DB-Struktur ist aber die echte.
+- Gemessen auf Windows im JIT-Modus von `flutter test`; die Release-App läuft
+  AOT-kompiliert und ist eher schneller. Für Vergleiche über die Zeit taugt
+  das, für absolute Aussagen über Handys nicht.
+- Nicht automatisiert: alles mit Klicks, echte Calls/Audio, 60-FPS-Streaming
+  zwischen zwei Geräten, Android-Push → `docs/PC_TESTPLAN.md`.
+
+## Nächste sinnvolle Messungen
+
+- **Streaming (M4 „Ursache messen"):** WebRTC-`getStats()` des Senders
+  auswerten (`framesPerSecond`, `qualityLimitationReason`, Encoder-Name) –
+  zeigt direkt, ob CPU, Bandbreite oder Encoder bremst. Braucht eine kleine
+  Diagnose-Anzeige im Call und zwei echte Geräte.
+- **UI-Flüssigkeit:** `integration_test` mit Frame-Timing beim Scrollen der
+  Raumliste/Timeline (Windows, Test-Account-Profil über `PYRAMID_PROFILE_DIR`).

docs/feature-checklist.md

@@ -1,6 +1,19 @@
 # Matrix / Element Feature Checklist für Pyramid
 
 *Stand: April 2026 — Pyramid v0.1.x (Early Development)*
+*Letzte Tiefenanalyse: 2026-04-29 (Vergleich mit FluffyChat / Element Web)*
+
+---
+
+## Legende
+
+- ✅ `[x]` — Implementiert und funktioniert korrekt
+- ⚠️ `[~]` — Teilweise / fehlerhaft implementiert (Details in Technische Analyse)
+- ❌ `[ ]` — Fehlt komplett
+- 🔴 P0 — Kritisch (Kernfunktionalität kaputt)
+- 🟠 P1 — Hoch (wichtige Funktion defekt oder nicht vorhanden)
+- 🟡 P2 — Mittel
+- 🔵 P3 — Niedrig / Nice-to-have
 
 ---
 
@@ -15,17 +28,19 @@
 - [x] Verschlüsselte Nachrichten anzeigen (Entschlüsselungsstatus)
 - [x] Nachrichtenverlauf paginieren (ältere Nachrichten beim Scrollen laden)
 - [x] Ungelesene-Nachrichten-Tracking
+- [~] Nachrichtenbearbeitung (Edit-Event erkannt, `getDisplayEvent` wird nicht gerendert) 🟠 P1
+- [~] Nachrichtenvorschau bei Reply (Zitat-Preview vorhanden, kein Jump-to-original) 🟡 P2
 
 ### Nachrichtenaktionen
 - [x] Nachrichtentext kopieren
 - [x] Eigene Nachrichten löschen (redact)
 - [x] Nachrichten anpinnen / Pinboard anzeigen
-- [~] Auf Nachrichten antworten (in-reply-to vorhanden, kein visuelles Zitatfeld)
-- [~] Nachrichten bearbeiten (m.edit im SDK erkannt, kein vollständiges UI)
+- [x] Auf Nachrichten antworten (in-reply-to)
 - [ ] Nachrichten weiterleiten
 - [ ] Zitat-Styling (visuelle Blockquote-Anzeige)
 
-### Textformatierung
+### Textformatierung (formatted_body)
+- [~] Markdown-Rendering — `formatted_body` / `org.matrix.custom.html` wird nicht gesendet und nicht gerendert 🔵 P3
 - [ ] Fett (**text**)
 - [ ] Kursiv (*text*)
 - [ ] Durchgestrichen (~~text~~)
@@ -33,7 +48,7 @@
 - [ ] Code-Block (```code```)
 - [ ] Aufzählungslisten
 - [ ] Klickbare Links
-- [ ] @Erwähnungen (User)
+- [~] @Erwähnungen — Button vorhanden, `onTap: null` 🟡 P2
 - [ ] #Kanal-Erwähnungen
 - [ ] Spoiler-Tags (||text||)
 
@@ -62,14 +77,118 @@
 - [x] Mehrere Reaktionen pro Nachricht
 - [x] Kategoriebasierte Emoji-Organisation
 
+### Tipp-Indikatoren (Typing)
+- [~] `room.setTyping()` wird **nirgendwo aufgerufen** — Einstellung existiert, aber Composer sendet nie "tippt…" 🟡 P2
+- [ ] "X tippt gerade"-Anzeige empfangen (kein Widget)
+- [ ] Timeout nach Tipp-Ende
+
 ### Threads
-- [ ] Thread-Antworten (m.in_reply_to vorhanden, kein Thread-View)
+- [~] Thread-Button vorhanden (`onPressed: () {}` — leer) 🔵 P3
 - [ ] Thread aufklappen / eigene Ansicht
 - [ ] Thread-Benachrichtigungen
 - [ ] Thread als gelöst markieren
 
 ---
 
+## Lesebestätigungen (Read Receipts)
+
+- [x] Senden von `m.read`-Receipts via `room.setReadMarker()`
+- [x] Privacy-Toggle (kein Senden wenn deaktiviert)
+- [x] ✓-Icon (Nachricht gesendet/zugestellt) auf eigenen Nachrichten
+- [x] ✓✓-Icon (gelesen) in DMs
+- [x] Sende-Status (Uhr/Fehler/gesendet/gelesen)
+- [~] ✓✓-Logik nur für DMs — in Gruppenräumen wird `receiptState.global.otherUsers` nicht ausgewertet 🟡 P2
+- [~] **Off-by-one**: Divider erscheint *über* der Gruppe die das `fullyRead`-Event enthält, nicht darunter 🟡 P2
+- [ ] Gruppen-Read-Receipt-Display (Seen-by-Avatare wie in FluffyChat) 🟡 P2
+- [ ] Hover-Tooltip "Gelesen von: ..." auf ✓✓
+- [ ] **Notification-Cancellation**: `cancelNotification(roomId)` beim Setzen des Read-Markers 🟡 P2
+
+---
+
+## „Neue Nachrichten" Trennlinie
+
+- [x] `_UnreadDivider`-Widget korrekt gestylt
+- [x] `_sessionFullyReadId` einmalig beim Öffnen erfasst (stabil für die Session)
+- [x] Keine Anzeige wenn Raum bereits gelesen
+- [~] **Position falsch** — Divider über der Gruppe mit `fullyRead`-Event statt darunter 🟡 P2
+- [ ] **Auto-Scroll zum Divider** beim Öffnen eines Raums mit ungelesenen Nachrichten 🟡 P2
+
+---
+
+## Presence / Zuletzt Online
+
+- [x] `_PresenceLine` im DM-Header mit Live-Updates
+- [x] 4s-Debounce gegen Sync-Spike-Fehlmeldungen
+- [x] Relative Zeitanzeige (gerade eben / vor Xmin / vor Xh)
+- [x] Guard: eigene Presence wird nie angezeigt
+- [x] Presence-Dot im Rooms-Panel und Members-Panel
+- [x] `setPresence(online/offline)` in den Settings
+- [~] **Kein Auto-Heartbeat** — `setPresence` nur in Settings, nie periodisch während Nutzung 🔵 P3
+- [~] **Kein `WidgetsBindingObserver`** — App-Lifecycle (Hintergrund/Vordergrund) löst kein Presence-Event aus 🔵 P3
+- [ ] Presence-Dot in DM-Listen-Items (`room_list_item.dart`) 🔵 P3
+
+---
+
+## Benachrichtigungen
+
+### Local Notifications (App im Vordergrund)
+- [x] Android Local Notifications (`flutter_local_notifications`)
+- [x] Windows Toast-Notifications (`local_notifier`)
+- [x] Windows Taskbar-Badge (Progress-Error-Mode)
+- [x] Tap-Handler navigiert zum richtigen Raum (Android)
+- [x] Guards: nur fremde Nachrichten, nur aktive Rooms, nur `Membership.join`
+- [x] `notificationsBlockedProvider` + Banner in `app_shell.dart`
+- [~] **Alle 4 Notification-Prefs werden ignoriert** — `notifDesktopProvider`, `notifSoundProvider`, `notifPreviewProvider`, `notifMentionOnlyDmProvider` haben keinen Effekt 🟠 P1
+- [~] Android-Grouping ohne Summary-Notification 🔵 P3
+
+### Remote Push (App im Hintergrund / geschlossen)
+- [ ] 🔴 **Keine Remote-Push-Integration** — FCM/UnifiedPush fehlt komplett, App muss laufen
+- [ ] iOS APNs-Setup
+- [ ] macOS-Notifications
+- [ ] Android Icon-Badge (Zahlenbadge)
+
+---
+
+## E2EE Verschlüsselungs-Pipeline
+
+### Implementiert
+- [x] Vodozemac (Rust-Olm) via Flutter-Isolate — modern, performant
+- [x] Bootstrap: SSSS, Cross-Signing, Online-Key-Backup
+- [x] `_decryptLegacyEvents` — entschlüsselt ältere Events in-place
+- [x] Device-Key-Preload vor erstem Senden
+- [x] Key-Verification UI (SAS Emoji, QR-Code, alle States)
+- [x] Megolm Session Export/Import (Element-kompatibles Format)
+- [x] Encrypted-Attachment-Handling
+- [x] `m.fully_read`-Marker beim Timeline-Open
+- [x] `timeline.requestKeys(onlineKeyBackupOnly: false)`
+
+### Fehlerhaft / Fehlend
+- [~] **"Entschlüsselt…"-Placeholder bleibt dauerhaft** wenn Key fehlt — kein Recovery-Button 🟠 P1
+- [~] `loadAllKeysFromRoom` Fehler werden silent geschluckt (`catch (_) {}`) 🟡 P2
+- [~] **Kein Incoming-Verification-Request-Handler** — `client.onKeyVerificationRequest` wird nicht abonniert 🔴 P0
+- [~] **Doppelte Bootstrap-Implementierung** (page vs. dialog) mit leicht inkonsistenter Logik 🔵 P3
+- [ ] Device-Trust-Indicator in der Timeline 🔵 P3
+- [ ] Unverified-Device-Warning beim Senden 🔵 P3
+- [ ] "Schlüssel anfordern"-Button bei dauerhaft verschlüsselten Events 🟠 P1
+
+---
+
+## Suche
+
+- [x] Suchdialog öffnen (UI vorhanden)
+- [x] Server-seitige Volltextsuche via Matrix `/search` API
+- [x] Filter: Alle / Medien / Personen
+- [x] Ergebnisse: Raum + Absender + Body + Zeitstempel
+- [x] Keyboard-Navigation in Ergebnissen
+- [x] 400ms Debounce
+- [ ] Jump-to-Message bei Klick auf Suchergebnis
+- [ ] Suche nach Absender filtern
+- [ ] Filter nach Datum
+- [ ] Suchergebnisse im Chat hervorheben
+- [ ] Suchverlauf
+
+---
+
 ## Raumverwaltung
 
 ### Grundfunktionen
@@ -79,14 +198,12 @@
 - [x] Raumname & Avatar anzeigen
 - [x] Verschlüsselungsstatus (Schloss-Icon)
 - [x] Einladungen annehmen / ablehnen
-- [ ] Neuen Raum erstellen
+- [ ] Neuen Raum erstellen (UI-Einstiegspunkt)
 - [ ] Raumname bearbeiten
 - [ ] Raumthema/Beschreibung bearbeiten
 - [ ] Raum-Avatar ändern
 - [ ] Raumvisibilität (öffentlich / privat)
-- [ ] Zugriffsregeln (invite/knock/public)
 - [ ] Verlaufsvisibilität konfigurieren
-- [ ] Raum-Aliases verwalten
 
 ### Direktnachrichten (DMs)
 - [x] 1:1 DM-Räume anzeigen & öffnen
@@ -94,261 +211,214 @@
 - [x] Echtzeit-Presence-Updates
 - [x] Sprachanruf aus DM starten
 - [x] Videoanruf aus DM starten
-- [ ] DM starten (neuen Chat beginnen, nur über Suchfeld)
+- [ ] DM starten (neuen Chat beginnen)
 
 ### Mitglieder & Rollen
 - [x] Mitgliederliste anzeigen
 - [x] Mitgliederanzahl anzeigen
 - [x] Avatar & Anzeigename der Mitglieder
-- [x] Nutzer in Raum einladen (Raum-Kontextmenü)
+- [x] Nutzer in Raum einladen
 - [ ] Nutzer aus Raum entfernen (Kick)
 - [ ] Nutzer sperren (Ban)
 - [ ] Power Levels bearbeiten
-- [ ] Nutzer zum Moderator / Admin befördern
-- [ ] Bans aufheben
-
-### Raumeinstellungen
-- [x] Raumeinstellungen-Dialog (Name, Thema, Moderationsregeln)
-- [ ] Raumverschlüsselung aktivieren/deaktivieren
-- [ ] Erweiterte Raumeinstellungen (Fluffychat-Level)
-- [ ] Widget-/App-Integration in Räume
 
 ---
 
 ## Spaces & Gemeinschaften
 
-### Spaces
 - [x] Spaces in der Seitenleiste anzeigen
 - [x] Zwischen Spaces navigieren
-- [x] Space-Avatar anzeigen
-- [x] Space-Banner hochladen & anzeigen (Discord-Style)
+- [x] Space-Avatar & Banner anzeigen
 - [x] Räume nach Space filtern
-- [x] Virtuelle "Rooms"- und "DMs"-Spaces
-- [x] Unterkategorien (Sub-Spaces) als Kategorien in der Kanalleiste
+- [x] Unterkategorien (Sub-Spaces)
 - [x] Drag-and-drop Kanalreihenfolge für Admins
-- [x] Space-Verwaltungsdialog (Name, Avatar, Banner, Einladungen, Mitglieder, Power Levels)
+- [x] Space-Verwaltungsdialog
 - [ ] Neuen Space erstellen
 - [ ] Räume zum Space hinzufügen / entfernen
-- [ ] Space-Regeln / Beschreibung
-- [ ] Space-Entdeckung (öffentliche Spaces durchsuchen)
-
-### Kanalorganisation
-- [x] Kanäle nach letzter Aktivität sortieren
-- [x] Ungelesene-Badge auf Kanälen
-- [x] Sprachkanal-Teilnehmerliste (Discord-Style, mit Echtzeit-Updates)
-- [x] Kollabierbare Kategorien
-- [ ] Favoriten / angeheftete Räume
-- [ ] Räume stummschalten
-- [ ] Räume ausblenden / archivieren
-- [ ] Kanalreihenfolge für reguläre Nutzer
+- [ ] Space-Entdeckung (öffentliche Spaces)
 
 ---
 
-## Sprach- & Videoanrufe
+## Sprach- & Videoanrufe (LiveKit)
 
-### Sprachanrufe (LiveKit)
-- [x] Sprachkanal betreten / verlassen (Toggle)
+- [x] Sprachkanal betreten / verlassen
+- [x] Mikrofon stummschalten / Deafen
 - [x] Teilnehmerliste im Sprachkanal
-- [x] Mikrofon stummschalten
-- [x] Audio-Ausgabe deaktivieren (Deafen)
-- [x] Anruf-UI im Profil-Panel (aktiver Anruf)
-- [x] Anruf-Ansicht öffnen (Vollansicht)
-- [x] Mini-Call-Widget bei VOIP-Anrufen
+- [x] Anruf-UI (Vollansicht + Mini-Widget)
+- [x] Videoanruf mit Kamera-Toggle
 - [ ] Klingelton bei eingehenden Anrufen
 - [ ] Anruf annehmen / ablehnen (UI)
 - [ ] Anrufdauer-Timer
-- [ ] Anrufverlauf
-
-### Videoanrufe
-- [x] Videoanruf starten (aus DM)
-- [x] Kamera-Toggle
-- [x] Videoteilnehmer-Anzeige
-- [ ] Bildschirmfreigabe (Toggle-UI vorhanden, Implementierung unklar)
-- [ ] Picture-in-Picture-Modus
-- [ ] Virtueller Hintergrund
-
-### Gruppenanrufe
-- [x] Mehrere Teilnehmer im Sprachkanal (LiveKit)
-- [ ] Gruppen-Videogitter
-- [ ] Spotlight-/Galerie-Ansicht
-
----
-
-## Benachrichtigungen & Presence
-
-### Push-Benachrichtigungen
-- [ ] Desktop-Benachrichtigungen (Windows/macOS/Linux)
-- [ ] Mobile Push-Benachrichtigungen (Android/iOS)
-- [ ] Benachrichtigungseinstellungen pro Raum
-- [ ] Nicht-Stören-Modus
-- [ ] Benachrichtigungssound konfigurieren
-
-### Presence & Status
-- [x] Nutzer-Presence abrufen (online/offline/abwesend)
-- [x] Presence-Indikator anzeigen
-- [x] Letzte-Aktivität-Zeitstempel
-- [x] Echtzeit-Presence-Updates
-- [ ] Eigenen Status setzen (online/abwesend/unsichtbar)
-- [ ] Benutzerdefinierte Statusmeldung
-- [ ] Aktivitätsbasierte Status-Änderung
-
-### Tipp-Indikatoren
-- [ ] "X tippt gerade"-Anzeige empfangen
-- [ ] Eigene Tipp-Benachrichtigung senden
-- [ ] Timeout nach Tipp-Ende
+- [ ] Bildschirmfreigabe
 
 ---
 
 ## Nutzereinstellungen & Profil
 
-### Profilverwaltung
-- [x] Eigene User-ID anzeigen
-- [x] Eigenen Avatar anzeigen (Initialen-Fallback)
-- [x] Anzeigenamen anzeigen
-- [ ] Anzeigenamen bearbeiten
-- [ ] Eigenen Avatar hochladen / entfernen
-- [ ] Status-Nachricht setzen
-
-### Kontosicherheit
+- [x] Hell / Dunkel-Theme, Akzentfarbe, Eckradius, Dichte
+- [x] Eigene User-ID, Avatar (Initialen-Fallback), Anzeigename anzeigen
+- [ ] Anzeigenamen & Avatar bearbeiten
 - [ ] Passwort ändern
-- [ ] E-Mail-Adresse verwalten
-- [ ] Sitzungsverwaltung (alle Sitzungen anzeigen)
-- [ ] Andere Sitzungen abmelden
-- [ ] Konto deaktivieren / löschen
-- [ ] Zwei-Faktor-Authentifizierung (2FA)
-
-### App-Einstellungen
-- [x] Hell / Dunkel-Theme
-- [x] Akzentfarbe (6 Voreinstellungen)
-- [x] Eckradius anpassen
-- [x] UI-Dichte / Kompaktheit
-- [x] Animationssteuerung
-- [ ] Schriftgröße anpassen
-- [ ] Sprachauswahl (i18n)
-- [ ] Kompaktansicht (kein Avatar in Nachrichten)
-
----
-
-## Datenschutz & Sicherheit
-
-### Ende-zu-Ende-Verschlüsselung (E2EE)
-- [x] E2EE-Unterstützung (Olm/Megolm via vodozemac)
-- [x] E2EE-Schlüssel beim ersten Login einrichten (Bootstrap)
-- [x] Verschlüsselte Nachrichten-Indikatoren
-- [x] Entschlüsselungsstatus anzeigen
-- [x] SSSS (Symmetric Secret Storage)
-- [x] Recovery-Key erzeugen & anzeigen
-- [x] Recovery-Key aus bestehender Einrichtung importieren
-- [x] Schlüssel-Caching (lokal speichern)
-- [x] Session-Keys von anderen Geräten anfordern
-- [ ] Schlüssel-Backup (Server-seitig)
-- [ ] Schlüssel-Backup verifizieren
-
-### Geräte-Verifizierung
-- [x] Cross-Signing (Master/Self-Signing/User-Signing Keys)
-- [x] Gerät per Emoji verifizieren
-- [x] Gerät per Zahlencodes verifizieren
-- [x] Geräte als vertrauenswürdig markieren
-- [ ] Gerätename / Modell anzeigen
-- [ ] Sitzungsverwaltung (alle Geräte dieses Accounts)
-- [ ] Fremde Geräte abmelden
-
-### Vertrauen & Sicherheit
-- [ ] Geräte-Vertrauensstatus-Indikator in Nachrichten
-- [ ] Nutzer blockieren / entsperren
-- [ ] Blockierte Nutzer-Liste
-- [ ] Verifizierter-Nutzer-Badge
-
----
-
-## Suche
-
-### Nachrichtensuche
-- [x] Suchdialog öffnen (UI vorhanden)
-- [ ] Volltextsuche in Nachrichteninhalten
-- [ ] Filter nach Absender
-- [ ] Filter nach Datum
-- [ ] Filter nach Raum
-- [ ] Filter nach Medientyp
-- [ ] Suchergebnisse hervorheben
-- [ ] Suchverlauf
-
-### Nutzer- / Raumsuche
-- [ ] Nutzer nach Anzeigenamen suchen
-- [ ] Nutzer nach User-ID suchen
-- [ ] Öffentliche Räume entdecken (Directory)
-- [ ] Eigene Räume filtern
-- [ ] Räume nach Name / Thema suchen
+- [ ] Sitzungsverwaltung
+- [ ] Konto deaktivieren
 
 ---
 
 ## Auto-Update
 
 - [x] GitHub-Releases als Update-Quelle
-- [x] Versions-Vergleich (SemVer)
-- [x] Rate-Limiting (max. alle 4 Stunden prüfen)
-- [x] Update-Banner im App-Header (Windows)
+- [x] Versions-Vergleich (SemVer), Rate-Limiting, Update-Banner
 - [x] "Diese Version überspringen"-Option
-- [x] Manueller Update-Check in den Einstellungen
-- [ ] Automatischer Download & Installation (Squirrel/NSIS)
-- [ ] Delta-Updates (nur geänderte Dateien)
-- [ ] Update-Kanal wählen (Stable/Beta/Nightly)
+- [ ] Automatischer Download & Installation
 
 ---
 
 ## Plattform-spezifisch
 
-### Desktop (Windows / macOS / Linux)
-- [x] Native Desktop-App (Flutter Desktop)
-- [x] Tastenkürzel (Enter = Senden, Shift+Enter = Zeile)
-- [x] Drag-and-Drop für Dateianhänge
+### Desktop
+- [x] Native Desktop-App, Tastenkürzel, Drag-and-Drop
 - [ ] System-Tray-Integration
-- [ ] Desktop-Benachrichtigungen
-- [ ] Minimieren in System-Tray
 - [ ] Fenster-State speichern (Größe, Position)
-- [ ] MSIX / Installer-Paketierung
 
-### Mobile (Android / iOS)
-- [x] Mobile App (Flutter)
-- [x] Drawer-Navigation (Hamburger-Menü)
-- [ ] Touch-optimiertes UI (derzeit Desktop-first)
+### Mobile
+- [x] Mobile App (Flutter), Drawer-Navigation
+- [ ] Touch-optimiertes UI
 - [ ] Mobile Push-Benachrichtigungen
-- [ ] Zurück-Geste Navigation
-- [ ] Bottom-Sheet-Modals
-- [ ] Share-Sheet-Integration
-- [ ] Haptisches Feedback
+
+---
+
+---
+
+# Technische Tiefenanalyse (2026-04-29)
+
+*Vergleichsbasis: FluffyChat (krille-chan/fluffychat) und Element Web*
+*Format: Befund → betroffene Datei:Zeile → Referenz-Implementierung*
+
+---
+
+## IMPLEMENTIERUNGS-BACKLOG (nach Priorität)
+
+### 🔴 P0 — Kritisch
+
+#### [P0-1] Incoming Key-Verification-Request-Handler fehlt
+**Problem:** Wenn ein anderes Gerät eine Verifikations-Anfrage (`m.key.verification.request`) an Pyramid schickt, gibt es keinen Listener. Die Anfrage läuft ab, ohne dass der Nutzer sie sieht. Das bedeutet: andere Geräte können Pyramid de facto nicht verifizieren — nur Pyramid kann aktiv verifizieren.
+**Betroffene Datei:** `lib/widgets/settings_modal.dart` (kein `onKeyVerificationRequest`-Listener)
+**FluffyChat-Referenz:** `lib/pages/key_verification/key_verification_dialog.dart` + `client.onKeyVerificationRequest.stream.listen(...)` in `lib/pages/matrix.dart`
+**Fix:** Stream auf `client.onKeyVerificationRequest` in `matrix_client.dart` oder `app_shell.dart` subscriben und `KeyVerificationDialog` öffnen.
+
+---
+
+### 🟠 P1 — Hoch
+
+#### [P1-1] Notification-Prefs werden ignoriert
+**Problem:** `notifDesktopProvider`, `notifSoundProvider`, `notifPreviewProvider`, `notifMentionOnlyDmProvider` sind in `settings_prefs.dart` gespeichert, werden in `notification_service.dart/_watchEvents()` aber nie ausgelesen. Notifications erscheinen immer, unabhängig von Nutzereinstellungen.
+**Betroffene Datei:** `lib/core/notification_service.dart`, Zeile 145–168
+**Fix:** In `_watchEvents()` die Prefs vor `showMessageNotification()` prüfen.
+
+#### [P1-2] Edits werden nicht gerendert
+**Problem:** `_isVisible()` filtert Edit-Events korrekt heraus, aber `event.getDisplayEvent(timeline)` wird nirgendwo aufgerufen. Nachrichten zeigen immer die Originalversion, auch wenn sie via `m.replace` bearbeitet wurden. Ein `(bearbeitet)`-Label fehlt ebenfalls.
+**Betroffene Datei:** `lib/features/chat/message_group.dart` — Event-Rendering-Bereich
+**FluffyChat-Referenz:** `event.getDisplayEvent(timeline)` vor dem Rendern jedes Events
+**Fix:** Beim Rendern von Events `event.getDisplayEvent(timeline)` statt `event` verwenden; `(bearbeitet)`-Label wenn `event != displayEvent`.
+
+#### [P1-3] Encrypted-Placeholder bleibt dauerhaft — kein Recovery-Button
+**Problem:** `EventTypes.Encrypted` zeigt "Nachricht wird entschlüsselt…" dauerhaft wenn die Entschlüsselung scheitert. Es gibt keinen Button zum Anfordern fehlender Keys.
+**Betroffene Datei:** `lib/features/chat/message_group.dart`, Zeilen ~408–421
+**FluffyChat-Referenz:** `_requestMissingKey()` mit `room.client.sendToDeviceEncrypted(...)` / SDK-`requestKey()`
+**Fix:** Wenn `event.status == EventStatus.error` oder nach Timeout immer noch `EventTypes.Encrypted`: "Schlüssel anfordern"-Button anzeigen, der `timeline.requestKeys()` aufruft.
+
+---
+
+### 🟡 P2 — Mittel
+
+#### [P2-1] Typing-Indikator: `room.setTyping()` nie aufgerufen
+**Problem:** `privacyTypingProvider` existiert, `chat_composer.dart` ruft aber nie `room.setTyping()` auf. Andere Nutzer sehen nie "X tippt gerade…".
+**Betroffene Datei:** `lib/features/chat/chat_input.dart` (oder `chat_composer.dart`)
+**FluffyChat-Referenz:** `onInputBarChanged` → 2s Debounce → `room.setTyping(true, timeout: 30000)`; bei Senden/Leerfeld: `room.setTyping(false)`
+**Fix:** Im Composer-Input `onChanged`-Handler mit Debounce und `room.setTyping()` ergänzen.
+
+#### [P2-2] Typing-Indikator: Kein Display-Widget
+**Problem:** Kein Widget das `room.typingUsers` anzeigt.
+**Fix:** `_TypingIndicator`-Widget in `chat_view.dart` unter der Nachrichtenliste einfügen, das `room.onUpdate`-Stream abonniert und `room.typingUsers` anzeigt.
+
+#### [P2-3] Unread-Divider: Position off-by-one
+**Problem:** Divider erscheint *über* der Gruppe die das `fullyRead`-Event *enthält*, nicht darunter. Das bereits-gelesene Event liegt unter dem "Neue Nachrichten"-Strich.
+**Betroffene Datei:** `lib/features/chat/chat_view.dart`, Zeile ~715
+**Fix:** Divider nach der Gruppe einsetzen, die das `fullyReadId`-Event enthält, nicht davor.
+
+#### [P2-4] Unread-Divider: Kein Auto-Scroll beim Öffnen
+**Problem:** Beim Öffnen eines Raums mit ungelesenen Nachrichten landet die View unten, nicht beim Divider.
+**FluffyChat-Referenz:** Initialer `scrollController.jumpTo()` zum Index des `fullyRead`-Events nach dem ersten Frame.
+**Fix:** In `initState`/`WidgetsBinding.addPostFrameCallback` zum Divider-Index springen wenn `_sessionHasUnread`.
+
+#### [P2-5] Gruppen-Read-Receipts fehlen
+**Problem:** ✓✓-Logik greift nur bei `room.isDirectChat`. In Gruppenräumen sehen eigene Nachrichten nie ✓✓.
+**FluffyChat-Referenz:** `SeenByRow` zeigt Avatare aller Leser unter der letzten Nachricht.
+**Fix:** Receipt-Prüfung auch in Gruppenräumen aktivieren; ggf. Avatar-Reihe unter letzter Nachricht.
+
+#### [P2-6] Notification-Cancellation beim Lesen fehlt
+**Problem:** Android-Notifications bleiben in der Benachrichtigungsleiste stehen, auch wenn der Chat geöffnet und die Nachrichten gelesen wurden.
+**FluffyChat-Referenz:** `backgroundPush?.cancelNotification(roomId)` in `_markRead()`
+**Fix:** In `_markRead()` in `chat_view.dart` die Android-Notification für `roomId` canceln.
+
+---
+
+### 🔵 P3 — Niedrig
+
+#### [P3-1] Presence: Kein Auto-Heartbeat
+**Problem:** `setPresence(online)` nur in Settings — Server setzt Client nach Timeout offline.
+**Fix:** Periodischer Timer (alle 60s) der `setPresence(online)` sendet solange App im Vordergrund.
+
+#### [P3-2] Presence: Kein App-Lifecycle-Hook
+**Problem:** Kein `WidgetsBindingObserver` — kein `unavailable` bei App-Hintergrund.
+**Fix:** `WidgetsBindingObserver.didChangeAppLifecycleState` in `matrix_client.dart` oder `app_shell.dart`.
+
+#### [P3-3] Markdown/`formatted_body` nicht gerendert
+**Problem:** `sendTextEvent` sendet nur plain text. Empfangene `formatted_body`-Felder werden nicht gerendert.
+**Fix:** Empfang: `flutter_html` oder `flutter_markdown` für `formatted_body`; Senden: simple Markdown-Erkennung im Composer.
+
+#### [P3-4] `requestFuture()` fehlt
+**Problem:** Kein Forward-Pagination-Mechanismus. Nach Jump-to-Event in der Vergangenheit kein Weg zurück.
+**Fix:** `timeline.requestFuture()` im Scroll-Listener für die Vorwärts-Richtung.
+
+#### [P3-5] `message_bubble.dart` — ungenutzter Code
+**Problem:** Veraltete WhatsApp-Style-Implementation koexistiert neben aktiver Discord-Style-Implementierung.
+**Fix:** Datei löschen oder auskommentieren.
 
 ---
 
 ## Statistik
 
-| Bereich | Implementiert | Teilweise | Fehlend |
+| Bereich | Implementiert | Fehlerhaft | Fehlend |
 |---|---|---|---|
-| Messaging | 14 | 2 | 14 |
-| Raumverwaltung | 8 | 0 | 14 |
-| Spaces | 10 | 0 | 6 |
-| Anrufe | 8 | 1 | 10 |
-| Benachrichtigungen | 4 | 0 | 8 |
-| Einstellungen/Profil | 5 | 0 | 11 |
-| Sicherheit/E2EE | 9 | 0 | 7 |
-| Suche | 1 | 0 | 10 |
-| Auto-Update | 6 | 0 | 3 |
-| Plattform | 5 | 0 | 10 |
-| **Gesamt** | **~70** | **~3** | **~93** |
+| Chat-Mechanik | Solide Basis | Edits, Typing, `requestFuture` | Jump-to-quote, Threads, Edited-Badge |
+| Read Receipts | DM-Logik ✓ | Gruppen, Off-by-one, Notif-Cancel | Seen-by-Avatare, Tooltip |
+| Presence | Anzeige ✓ | Broadcasting, Lifecycle | Heartbeat, Dot in Raumliste |
+| Benachrichtigungen | Local ✓ | Prefs ignoriert, Grouping | Remote Push, iOS, macOS |
+| Unread-Divider | Konzept ✓ | Position, Auto-Scroll | — |
+| E2EE | Stärkster Bereich | Incoming-Verif., Placeholder | Device-Trust-Indicator, Warn beim Senden |
+| Suche | API-Basis ✓ | — | Jump-to-message, Filter |
 
-**Implementierungsgrad: ~42 %** (inkl. Teilimplementierungen)
+**Implementierungsgrad gesamt: ~42 %** (inkl. Teilimplementierungen)
 
 ---
 
-## Empfohlene Feature-Prioritäten
+## Implementierungs-Fortschritt
 
-1. **Textformatierung** — häufig genutzt, von Nutzern erwartet
-2. **Push-Benachrichtigungen** — Desktop-Benachrichtigungen für Windows
-3. **Tipp-Indikatoren** — verbessert Gesprächsgefühl deutlich
-4. **Nachrichtenbearbeitung** — SDK-Grundlage vorhanden, nur UI fehlt
-5. **Profilbearbeitung** — Avatar & Anzeigename ändern
-6. **Raum erstellen** — Basis-Workflow, derzeit nicht möglich
-7. **Sprachnachricht abspielen** — Struktur vorhanden
-8. **Suche** — Dialog vorhanden, Backend-Abfrage fehlt
-9. **Nutzer blockieren** — Sicherheits-Grundfunktion
-10. **System-Tray** — Desktop-Erlebnis verbessern
+| ID | Beschreibung | Status |
+|---|---|---|
+| P0-1 | Incoming Key-Verification-Request-Handler | ✅ War bereits implementiert (`app_shell.dart`) |
+| P1-1 | Notification-Prefs auswerten | ✅ Implementiert (`notification_service.dart`) |
+| P1-2 | Edits rendern (`getDisplayEvent`) | ✅ Implementiert (`message_group.dart`) |
+| P1-3 | Encrypted-Placeholder + Recovery-Button | ✅ Implementiert (`message_group.dart`) |
+| P2-1 | Typing: `room.setTyping()` senden | ✅ Implementiert (`chat_composer.dart`) |
+| P2-2 | Typing: Display-Widget | ✅ Implementiert (`chat_view.dart` — `_TypingIndicator`) |
+| P2-3 | Unread-Divider: Position + leere fullyRead-Guard | ✅ Neu implementiert (`chat_view.dart`) |
+| P2-4 | Unread-Divider: Auto-Scroll (Schätzung) | ✅ Implementiert (`_scrollToUnread`) |
+| P2-5 | Gruppen-Read-Receipts (DM-Guard entfernt) | ✅ Implementiert (`chat_view.dart`) |
+| P2-6 | Notification-Cancellation beim Lesen | ✅ Implementiert (`chat_view.dart/_markRead`) |
+| P3-1 | Presence: Auto-Heartbeat (10s) | ✅ Implementiert (`app_shell.dart`) |
+| P3-2 | Presence: App-Lifecycle-Hook | ✅ Implementiert (`app_shell.dart` — `WidgetsBindingObserver`) |
+| P3-3 | HTML/Markdown (`_MatrixHtmlText`, `_PlainLinkText`) | ✅ Implementiert (`message_group.dart`) |
+| P3-4 | `requestFuture()` | ✅ Implementiert (`chat_view.dart/_onScroll`) |
+| P3-5 | `message_bubble.dart` entfernen | ⏳ Offen |

docs/matrix-sdk/01-auth.md

@@ -0,0 +1,241 @@
+# 01 — Authentifizierung & Session
+
+---
+
+## Inhaltsverzeichnis
+- [Login mit Passwort](#login-mit-passwort)
+- [Login mit Token](#login-mit-token)
+- [SSO / OAuth](#sso--oauth)
+- [Register](#registrierung)
+- [Session prüfen & wiederherstellen](#session-prüfen--wiederherstellen)
+- [Logout](#logout)
+- [Multi-Account / Device](#multi-account--device)
+- [Homeserver ermitteln](#homeserver-ermitteln)
+- [Flows & Login-Typen abfragen](#flows--login-typen-abfragen)
+
+---
+
+## Login mit Passwort
+
+```dart
+await client.checkHomeserver(Uri.parse('https://matrix.example.org'));
+
+final loginResponse = await client.login(
+  LoginType.mLoginPassword,
+  password: 'geheimesPasswort',
+  identifier: AuthenticationUserIdentifier(user: '@alice:example.org'),
+  // oder nur Username (ohne Server):
+  // identifier: AuthenticationUserIdentifier(user: 'alice'),
+  initialDeviceDisplayName: 'Pyramid Android',
+);
+// loginResponse.accessToken, .deviceId, .userId
+```
+
+---
+
+## Login mit Token
+
+```dart
+await client.checkHomeserver(Uri.parse('https://matrix.example.org'));
+
+await client.login(
+  LoginType.mLoginToken,
+  token: 'einmaliger_login_token',
+  initialDeviceDisplayName: 'Pyramid',
+);
+```
+
+---
+
+## SSO / OAuth
+
+```dart
+// Verfügbare Login-Flows abfragen
+final flows = await client.getLoginFlows();
+final hasSso = flows.flows?.any((f) => f.type == AuthenticationTypes.sso) ?? false;
+
+// SSO-URL erzeugen (öffnet Browser/WebView)
+final redirectUri = 'io.pyramid.app://login-callback';
+final ssoUrl = client.homeserver!.toString() +
+    '/_matrix/client/v3/login/sso/redirect?redirectUrl=${Uri.encodeComponent(redirectUri)}';
+// → Uri im Browser öffnen, nach Redirect den Token extrahieren
+
+// Nach Redirect mit Token einloggen
+await client.login(
+  LoginType.mLoginToken,
+  token: tokenAusRedirectUrl,
+  initialDeviceDisplayName: 'Pyramid',
+);
+```
+
+---
+
+## Registrierung
+
+```dart
+// Homeserver-Registrierung prüfen
+await client.checkHomeserver(Uri.parse('https://matrix.example.org'));
+
+// UIAA-Flow starten
+try {
+  await client.uiaRequestBackground(
+    (auth) => client.register(
+      username: 'neuernutzer',
+      password: 'sicheresPasswort',
+      initialDeviceDisplayName: 'Pyramid',
+      auth: auth,
+    ),
+  );
+} on MatrixException catch (e) {
+  // e.error: M_USER_IN_USE, M_INVALID_USERNAME, etc.
+}
+```
+
+---
+
+## Session prüfen & wiederherstellen
+
+```dart
+// Nach client.init() prüfen ob Session noch gültig ist
+if (client.isLogged()) {
+  print('Eingeloggt als: ${client.userID}');
+  print('Homeserver: ${client.homeserver}');
+  print('Device ID: ${client.deviceID}');
+  print('Access Token: ${client.accessToken}');
+}
+
+// Auf Login-State reagieren
+client.onLoginStateChanged.stream.listen((LoginState state) {
+  switch (state) {
+    case LoginState.loggedIn:  // Session aktiv
+    case LoginState.softLoggedOut: // Token abgelaufen, Re-Auth nötig
+    case LoginState.loggedOut:     // Ausgeloggt
+  }
+});
+```
+
+---
+
+## Logout
+
+```dart
+// Nur dieses Device
+await client.logout();
+
+// Alle Devices
+await client.logoutAll();
+```
+
+---
+
+## Multi-Account / Device
+
+```dart
+// Eigene Devices (Sessions) auflisten
+final devices = await client.getDevices();
+for (final device in devices ?? []) {
+  print('${device.deviceId}: ${device.displayName} — ${device.lastSeenIp}');
+}
+
+// Device umbenennen
+await client.updateDevice(
+  deviceId: 'DEVICEID',
+  displayName: 'Pyramid (Wohnzimmer)',
+);
+
+// Device löschen (andere Session killen)
+await client.deleteDevice(
+  'ANDERES_DEVICE_ID',
+  auth: AuthenticationPassword(
+    identifier: AuthenticationUserIdentifier(user: client.userID!),
+    password: 'meinPasswort',
+  ),
+);
+
+// Mehrere Devices auf einmal löschen
+await client.deleteDevices(
+  ['DEVICE1', 'DEVICE2'],
+  auth: AuthenticationPassword(...),
+);
+```
+
+---
+
+## Homeserver ermitteln
+
+```dart
+// .well-known auflösen (Autodiscovery)
+final discovery = await client.checkHomeserver(
+  Uri.parse('https://example.org'), // Domain reicht, SDK findet Matrix-Server
+);
+// client.homeserver ist jetzt gesetzt
+
+// Direkt mit bekannter HS-URL
+await client.checkHomeserver(Uri.parse('https://matrix.example.org'));
+
+// Homeserver-Versioninfo
+final serverVersion = await client.getVersions();
+print(serverVersion.versions); // ['v1.1', 'v1.2', ...]
+```
+
+---
+
+## Flows & Login-Typen abfragen
+
+```dart
+final response = await client.getLoginFlows();
+for (final flow in response.flows ?? []) {
+  switch (flow.type) {
+    case AuthenticationTypes.password: // m.login.password
+    case AuthenticationTypes.sso:      // m.login.sso
+    case AuthenticationTypes.token:    // m.login.token
+    case 'm.login.cas':                // Legacy-CAS
+  }
+}
+
+// SSO-Provider Details (für Brand-Buttons im UI)
+final ssoProviders = response.flows
+    ?.where((f) => f.type == AuthenticationTypes.sso)
+    .expand((f) => f.identityProviders ?? [])
+    .toList();
+// ssoProvider.id, .name, .brand, .icon
+```
+
+---
+
+## UIAA (User-Interactive Auth) Flows
+
+```dart
+// Generisches UIAA-Handling (z.B. für Account-Löschung)
+await client.uiaRequestBackground(
+  (auth) => client.deactivateAccount(auth: auth, eraseData: false),
+);
+
+// Passwort ändern (braucht Re-Auth)
+await client.uiaRequestBackground(
+  (auth) => client.changePassword(
+    'neuesPasswort',
+    auth: auth,
+    oldPassword: 'altesPasswort', // optional, falls Server es erlaubt
+  ),
+);
+```
+
+---
+
+## Fehlerbehandlung
+
+```dart
+try {
+  await client.login(...);
+} on MatrixException catch (e) {
+  switch (e.error) {
+    case MatrixError.M_FORBIDDEN:       // Falsches Passwort
+    case MatrixError.M_USER_IN_USE:     // Username vergeben
+    case MatrixError.M_INVALID_USERNAME:
+    case MatrixError.M_LIMIT_EXCEEDED:  // Rate-Limiting
+    case MatrixError.M_UNKNOWN:
+  }
+  print(e.errorMessage); // Menschenlesbarer Text vom Server
+}
+```

docs/matrix-sdk/02-rooms.md

@@ -0,0 +1,436 @@
+# 02 — Räume & Spaces
+
+---
+
+## Inhaltsverzeichnis
+- [Raum erstellen](#raum-erstellen)
+- [Raum beitreten](#raum-beitreten)
+- [Raum verlassen](#raum-verlassen)
+- [Raumliste](#raumliste)
+- [Raum-Metadaten lesen](#raum-metadaten-lesen)
+- [Raum-Einstellungen ändern](#raum-einstellungen-ändern)
+- [Mitglieder](#mitglieder)
+- [Einladen & Kick & Ban](#einladen--kick--ban)
+- [Öffentliches Raumverzeichnis](#öffentliches-raumverzeichnis)
+- [Spaces](#spaces)
+- [Room Upgrades](#room-upgrades)
+
+---
+
+## Raum erstellen
+
+```dart
+// Einfacher privater Raum
+final roomId = await client.createRoom(
+  name: 'Mein Raum',
+  topic: 'Willkommen!',
+  visibility: Visibility.private,      // oder .public
+  preset: CreateRoomPreset.privateChat, // oder .publicChat, .trustedPrivateChat
+);
+
+// Raum mit Einladungen
+final roomId = await client.createRoom(
+  name: 'Projekt Alpha',
+  invite: ['@bob:example.org', '@charlie:example.org'],
+  enableEncryption: true,              // E2EE aktivieren
+);
+
+// Raum mit Alias
+final roomId = await client.createRoom(
+  name: 'Öffentlicher Kanal',
+  roomAliasName: 'kanal',             // → #kanal:example.org
+  visibility: Visibility.public,
+  preset: CreateRoomPreset.publicChat,
+);
+
+// Raum mit Custom Power Levels
+final roomId = await client.createRoom(
+  name: 'Moderiert',
+  powerLevelContentOverride: PowerLevelsContent(
+    eventsDefault: 50,                 // Nur Moderatoren senden
+    usersDefault: 0,
+    users: {'@admin:example.org': 100},
+  ),
+);
+
+// Raum mit History-Visibility
+final roomId = await client.createRoom(
+  initialState: [
+    StateEvent(
+      type: EventTypes.HistoryVisibility,
+      content: {'history_visibility': 'invited'}, // shared|invited|joined|world_readable
+    ),
+  ],
+);
+```
+
+---
+
+## Raum beitreten
+
+```dart
+// Per Raum-ID
+await client.joinRoom('!roomId:server');
+
+// Per Alias
+await client.joinRoomOrAlias('#kanal:example.org');
+
+// Per Invite-Link / Matrix-URI
+// matrix:r/kanal:example.org
+// https://matrix.to/#/#kanal:example.org
+final uri = MatrixUri.parse('https://matrix.to/#/#kanal:example.org');
+if (uri != null) {
+  await client.joinRoomOrAlias(uri.primaryIdentifier);
+}
+
+// Mit Via-Servern (für föderierte Räume)
+await client.joinRoom(
+  '!roomId:remoteserver.org',
+  serverName: ['remoteserver.org', 'matrix.org'],
+);
+```
+
+---
+
+## Raum verlassen
+
+```dart
+// Verlassen (bleibt in Left-State)
+final room = client.getRoomById('!roomId:server')!;
+await room.leave();
+
+// Vergessen (entfernt aus Raumliste)
+await room.forget();
+
+// Verlassen + Vergessen
+await room.leave();
+await room.forget();
+```
+
+---
+
+## Raumliste
+
+```dart
+// Alle Räume (joined + invited)
+final allRooms = client.rooms;
+
+// Nur beigetretene
+final joinedRooms = client.rooms
+    .where((r) => r.membership == Membership.join)
+    .toList();
+
+// Nur Einladungen
+final invites = client.rooms
+    .where((r) => r.membership == Membership.invite)
+    .toList();
+
+// Sortiert nach letzter Aktivität
+final sorted = [...client.rooms]
+  ..sort((a, b) => (b.lastEvent?.originServerTs ?? DateTime(0))
+      .compareTo(a.lastEvent?.originServerTs ?? DateTime(0)));
+
+// Raum per ID
+final room = client.getRoomById('!roomId:server');
+
+// Raum per Alias auflösen
+final resolved = await client.getRoomIdByAlias('#alias:server');
+// resolved.roomId
+
+// Ungelesene Nachrichten
+final unread = client.rooms.fold<int>(
+  0, (sum, r) => sum + r.notificationCount);
+```
+
+---
+
+## Raum-Metadaten lesen
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Basis-Info
+print(room.id);                          // !roomId:server
+print(room.name);                        // Anzeigename (aufgelöst)
+print(room.topic);                       // Thema
+print(room.avatar);                      // mxc://… URI
+print(room.canonicalAlias);             // #alias:server
+print(room.membership);                  // Membership.join/invite/leave/ban
+print(room.isDirectChat);               // DM?
+print(room.directChatMatrixID);         // Gegenüber-MXID bei DM
+print(room.isEncrypted);                // E2EE aktiv?
+print(room.joinRules);                  // JoinRules.public/invite/knock/restricted
+print(room.guestAccess);               // GuestAccess.forbidden/canJoin
+print(room.historyVisibility);          // HistoryVisibility.*
+print(room.notificationCount);          // Ungelesene Notifications
+print(room.highlightCount);             // Mentions
+print(room.summary.mJoinedMemberCount); // Mitgliederzahl
+
+// Letztes Event
+final last = room.lastEvent;
+print(last?.body);
+print(last?.originServerTs);
+
+// Display-Name (lokalisiert, wie FluffyChat)
+final displayName = room.getLocalizedDisplayname();
+```
+
+---
+
+## Raum-Einstellungen ändern
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Name
+await room.setName('Neuer Name');
+
+// Thema
+await room.setDescription('Neues Thema');
+
+// Avatar (mxc:// URI nach Upload)
+final uri = await client.uploadContent(imageBytes, filename: 'avatar.png');
+await room.setAvatar(uri);
+
+// Alias setzen / entfernen
+await client.setRoomAlias('#neu:example.org', room.id);
+await client.deleteRoomAlias('#alt:example.org');
+await room.setCanonicalAlias('#neu:example.org'); // Kanonischen Alias setzen
+
+// Join-Rules
+await room.setJoinRules(JoinRules.invite);    // private
+await room.setJoinRules(JoinRules.public);    // öffentlich
+await room.setJoinRules(JoinRules.knock);     // Beitrittsanfragen
+await room.setJoinRules(
+  JoinRules.restricted,
+  allow: [SpaceRoomJoinRulesAllowInner(
+    roomId: '!spaceId:server',
+    type: SpaceRoomJoinRulesAllowInnerType.mRoomMembership,
+  )],
+);
+
+// History-Visibility
+await room.setHistoryVisibility(HistoryVisibility.shared);
+// .shared | .invited | .joined | .worldReadable
+
+// Guest Access
+await room.setGuestAccess(GuestAccess.canJoin);
+await room.setGuestAccess(GuestAccess.forbidden);
+
+// E2EE aktivieren (nicht mehr deaktivierbar!)
+await room.enableEncryption();
+
+// Generischer State-Event senden
+await room.client.sendState(
+  room.id,
+  'm.room.custom_event',
+  {'key': 'value'},
+  stateKey: '',
+);
+```
+
+---
+
+## Mitglieder
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Alle Mitglieder (gecacht)
+final members = room.getParticipants();
+
+// Vollständige Mitgliederliste vom Server laden
+final allMembers = await room.requestParticipants();
+
+// Einzelnen User holen
+final user = room.unsafeGetUserFromMemoryOrFallback('@alice:server');
+print(user.displayName);
+print(user.avatarUrl);
+print(user.powerLevel);
+print(user.membership); // Membership.join/invite/leave/ban/knock
+
+// Aktuell tippende User
+final typingUsers = room.typingUsers; // List<User>
+
+// Power Level eines Users
+final pl = room.getPowerLevelByUserId('@alice:server');
+
+// Eigener Power Level
+final myPl = room.ownPowerLevel;
+```
+
+---
+
+## Einladen, Kick & Ban
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Einladen
+await room.invite('@alice:server');
+
+// Kick (entfernt, kann wieder beitreten)
+await room.kick('@alice:server', reason: 'Regeln verletzt');
+
+// Ban (dauerhaft gesperrt)
+await room.ban('@alice:server', reason: 'Spam');
+
+// Unban
+await room.unban('@alice:server');
+
+// Eigene Berechtigungen prüfen
+room.canBan;     // bool
+room.canKick;    // bool
+room.canInvite;  // bool
+room.canSendEvent(EventTypes.Message); // bool
+```
+
+---
+
+## Power Levels
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Power Level eines Users setzen
+await room.setPower('@alice:server', 50); // 0=User, 50=Mod, 100=Admin
+
+// Power Level Content auslesen
+final plContent = room.getState(EventTypes.RoomPowerLevels)
+    ?.content
+    .tryGet<Map>('users');
+
+// Vollständig setzen
+await room.client.sendState(
+  room.id,
+  EventTypes.RoomPowerLevels,
+  {
+    'ban': 50,
+    'events': {
+      'm.room.name': 50,
+      'm.room.power_levels': 100,
+    },
+    'events_default': 0,
+    'invite': 50,
+    'kick': 50,
+    'redact': 50,
+    'state_default': 50,
+    'users': {
+      '@alice:server': 100,
+      '@mod:server': 50,
+    },
+    'users_default': 0,
+  },
+  stateKey: '',
+);
+
+// Berechtigungen prüfen
+room.canSendDefaultMessages;       // Nachrichten senden
+room.canChangeStateEvent(EventTypes.RoomName); // State-Events ändern
+```
+
+---
+
+## Öffentliches Raumverzeichnis
+
+```dart
+// Öffentliche Räume suchen
+final result = await client.queryPublicRooms(
+  limit: 20,
+  filter: PublicRoomQueryFilter(genericSearchTerm: 'flutter'),
+  server: 'matrix.org',             // optionaler anderer Server
+);
+
+for (final room in result.chunk) {
+  print(room.name);
+  print(room.roomId);
+  print(room.numJoinedMembers);
+  print(room.worldReadable);
+}
+
+// Nächste Seite
+final next = await client.queryPublicRooms(
+  since: result.nextBatch,
+  limit: 20,
+);
+```
+
+---
+
+## Spaces
+
+```dart
+// Space erstellen
+final spaceId = await client.createRoom(
+  name: 'Mein Space',
+  creationContent: {'type': 'm.space'}, // markiert als Space
+  visibility: Visibility.private,
+);
+
+// Kind-Raum zu Space hinzufügen
+final space = client.getRoomById(spaceId)!;
+await space.client.sendState(
+  spaceId,
+  EventTypes.SpaceChild,
+  {
+    'via': ['example.org'],
+    'suggested': true,
+    'auto_join': false,
+  },
+  stateKey: '!childRoomId:server',
+);
+
+// Space-Kinder auflisten (vom Server)
+final children = await client.getSpaceHierarchy(
+  spaceId,
+  maxDepth: 2,
+  suggestedOnly: false,
+);
+for (final room in children.rooms) {
+  print(room.name);
+  print(room.roomType);          // 'm.space' oder null
+  print(room.childrenState);     // Sub-Spaces
+}
+
+// Kind-Raum entfernen
+await space.client.sendState(
+  spaceId,
+  EventTypes.SpaceChild,
+  {},                            // leeres Content → entfernt
+  stateKey: '!childRoomId:server',
+);
+
+// Space-Parent setzen (vom Kind-Raum aus)
+await client.sendState(
+  '!childRoomId:server',
+  EventTypes.SpaceParent,
+  {
+    'via': ['example.org'],
+    'canonical': true,
+  },
+  stateKey: spaceId,
+);
+
+// Alle Spaces des Users
+final spaces = client.rooms.where((r) =>
+    r.membership == Membership.join &&
+    r.getState('m.room.create')?.content['type'] == 'm.space');
+```
+
+---
+
+## Room Upgrades
+
+```dart
+// Raum auf neuere Version upgraden (erstellt Nachfolger-Raum)
+final newRoomId = await client.upgradeRoom(
+  '!alterRaumId:server',
+  newVersion: '11',                // Aktuelle empfohlene Version
+);
+// Alle Mitglieder werden automatisch in den neuen Raum eingeladen
+// tombstone-Event wird im alten Raum gesetzt
+
+// Tombstone lesen
+final tombstone = room.getState(EventTypes.RoomTombstone);
+final replacement = tombstone?.content['replacement_room'] as String?;
+```

docs/matrix-sdk/03-messages.md

@@ -0,0 +1,463 @@
+# 03 — Nachrichten & Events
+
+---
+
+## Inhaltsverzeichnis
+- [Textnachricht senden](#textnachricht-senden)
+- [HTML / Markdown senden](#html--markdown-senden)
+- [Antworten (Reply)](#antworten-reply)
+- [Bearbeiten (Edit)](#bearbeiten-edit)
+- [Reaktionen](#reaktionen)
+- [Löschen (Redact)](#löschen-redact)
+- [Threads](#threads)
+- [Polls](#polls)
+- [Standort](#standort)
+- [Timeline lesen](#timeline-lesen)
+- [Event-Typen Referenz](#event-typen-referenz)
+- [Typing-Indikator](#typing-indikator)
+- [Read Markers / Lesebestätigung](#read-markers--lesebestätigung)
+- [Pinned Messages](#pinned-messages)
+- [Fehlgeschlagene Events erneut senden](#fehlgeschlagene-events-erneut-senden)
+
+---
+
+## Textnachricht senden
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Einfacher Text
+final eventId = await room.sendTextEvent('Hallo Welt!');
+
+// Gibt ein temporäres Event zurück (für optimistische UI)
+// Das Event bekommt Status EventStatus.sending → .sent → .synced
+```
+
+---
+
+## HTML / Markdown senden
+
+```dart
+// Mit HTML-Formatierung
+await room.sendTextEvent(
+  'Fett und kursiv',               // Fallback-Text (Plain)
+  htmlBody: '<b>Fett</b> und <em>kursiv</em>',
+  parseMarkdown: false,            // Kein automatisches Markdown-Parsing
+);
+
+// Automatisches Markdown-Parsing (SDK parst ** → <b>)
+await room.sendTextEvent(
+  '**Fett** und *kursiv*',
+  parseMarkdown: true,             // Standard: true
+);
+```
+
+---
+
+## Antworten (Reply)
+
+```dart
+// Event, auf das geantwortet wird
+final replyTo = timeline.events.first; // Event-Objekt
+
+await room.sendTextEvent(
+  'Das sehe ich auch so!',
+  inReplyTo: replyTo,
+);
+
+// Prüfen ob ein Event eine Antwort ist
+final isReply = event.isReply;           // bool
+final repliedId = event.inReplyTo;       // eventId als String?
+
+// Das referenzierte Event laden
+final original = await room.getEventById(repliedId!);
+```
+
+---
+
+## Bearbeiten (Edit)
+
+```dart
+// Nachricht bearbeiten
+await room.sendTextEvent(
+  'Korrigierter Text',
+  editEventId: altesEvent.eventId,       // Referenz auf Original
+  htmlBody: '<s>Alt</s> <b>Korrigiert</b>', // optional
+);
+
+// Prüfen ob ein Event bearbeitet wurde
+final isEdit = event.isEdit;             // bool
+
+// Gerendertes Event (mit letzter Bearbeitung) holen
+final displayed = event.getDisplayEvent(); // gibt die letzte Version zurück
+print(displayed.body);                    // aktuelle Nachricht
+
+// Alle Bearbeitungen eines Events
+final edits = timeline.events
+    .where((e) => e.isEdit && e.relationshipEventId == originalEvent.eventId)
+    .toList();
+```
+
+---
+
+## Reaktionen
+
+```dart
+// Reaktion senden (Emoji oder Text)
+await room.sendReaction(event.eventId, '👍');
+await room.sendReaction(event.eventId, '❤️');
+
+// Alle Reaktionen eines Events lesen
+final reactions = event.aggregatedEvents(
+  timeline,
+  RelationshipTypes.reaction,
+);
+// Gruppiert nach Emoji-Key:
+// Map<String, List<Event>>
+
+// Eigene Reaktion entfernen (= Redact)
+final myReaction = reactions['👍']
+    ?.firstWhere((e) => e.senderId == client.userID);
+if (myReaction != null) {
+  await myReaction.redactEvent(reason: null);
+}
+```
+
+---
+
+## Löschen (Redact)
+
+```dart
+// Event löschen
+await room.redactEvent(
+  event.eventId,
+  reason: 'Unpassender Inhalt',     // optional
+);
+
+// Über das Event-Objekt direkt
+await event.redactEvent(reason: 'Spam');
+
+// Prüfen ob redacted
+final redacted = event.isRedacted;   // bool
+```
+
+---
+
+## Threads
+
+```dart
+// Thread-Antwort senden
+await room.sendEvent(
+  {
+    'm.relates_to': {
+      'rel_type': 'm.thread',
+      'event_id': rootEvent.eventId,
+      'is_falling_back': true,       // true wenn kein echter Thread-Client
+      'm.in_reply_to': {
+        'event_id': rootEvent.eventId,
+      },
+    },
+    'msgtype': 'm.text',
+    'body': 'Antwort im Thread',
+  },
+  EventTypes.Message,
+);
+
+// Thread-Events eines Root-Events laden
+final threadEvents = timeline.events
+    .where((e) =>
+        e.relationshipType == RelationshipTypes.thread &&
+        e.relationshipEventId == rootEvent.eventId)
+    .toList();
+```
+
+---
+
+## Polls
+
+```dart
+// Poll erstellen (MSC3381)
+await room.sendEvent(
+  {
+    'org.matrix.msc3381.poll.start': {
+      'question': {
+        'msgtype': 'm.text',
+        'body': 'Was ist dein Lieblingsessen?',
+      },
+      'kind': 'org.matrix.msc3381.poll.disclosed', // oder .undisclosed
+      'max_selections': 1,
+      'answers': [
+        {'id': '1', 'org.matrix.msc3381.poll.answer': {'msgtype': 'm.text', 'body': 'Pizza'}},
+        {'id': '2', 'org.matrix.msc3381.poll.answer': {'msgtype': 'm.text', 'body': 'Pasta'}},
+        {'id': '3', 'org.matrix.msc3381.poll.answer': {'msgtype': 'm.text', 'body': 'Salat'}},
+      ],
+    },
+    'msgtype': 'm.text',
+    'body': 'Was ist dein Lieblingsessen? (Poll)',
+  },
+  'org.matrix.msc3381.poll.start',
+);
+
+// Abstimmen
+await room.sendEvent(
+  {
+    'm.relates_to': {
+      'rel_type': 'm.reference',
+      'event_id': pollEvent.eventId,
+    },
+    'org.matrix.msc3381.poll.response': {
+      'answers': ['1'],              // Ausgewählte IDs
+    },
+    'msgtype': 'm.text',
+    'body': 'Meine Antwort: Pizza',
+  },
+  'org.matrix.msc3381.poll.response',
+);
+
+// Poll beenden
+await room.sendEvent(
+  {
+    'm.relates_to': {
+      'rel_type': 'm.reference',
+      'event_id': pollEvent.eventId,
+    },
+    'msgtype': 'm.text',
+    'body': 'Poll beendet.',
+  },
+  'org.matrix.msc3381.poll.end',
+);
+```
+
+---
+
+## Standort
+
+```dart
+// Standort senden
+await room.sendEvent(
+  {
+    'msgtype': 'm.location',
+    'body': 'Mein Standort: geo:52.5200,13.4050',
+    'geo_uri': 'geo:52.5200,13.4050',
+    'org.matrix.msc3488.location': {
+      'uri': 'geo:52.5200,13.4050',
+      'description': 'Berlin',
+    },
+  },
+  EventTypes.Message,
+);
+```
+
+---
+
+## Timeline lesen
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Timeline erstellen (Callbacks werden bei Änderungen gerufen)
+Timeline? timeline;
+timeline = await room.getTimeline(
+  onUpdate: () {
+    // Vollständiges UI-Rebuild
+    setState(() {});
+  },
+  onChange: (int index) {
+    // Einzelnes Event geändert (z.B. Reaktion, Edit, Status)
+    setState(() {});
+  },
+  onInsert: (int index) {
+    // Neues Event eingefügt
+    setState(() {});
+  },
+  onRemove: (int index) {
+    // Event entfernt (Redaction)
+    setState(() {});
+  },
+);
+
+// WICHTIG: Immer aufräumen!
+@override
+void dispose() {
+  timeline?.cancelSubscriptions();
+  super.dispose();
+}
+
+// Events abrufen (neueste zuerst, Index 0 = aktuellstes)
+final events = timeline.events;
+
+// Ältere Nachrichten nachladen (z.B. beim Scrollen nach oben)
+await timeline.requestHistory(count: 30);
+// Gibt true zurück wenn es noch mehr gibt
+final hasMore = timeline.canRequestHistory;
+
+// Bestimmtes Event aus Timeline oder Server laden
+final event = await room.getEventById('$eventId');
+
+// Neuere Events nachladen (nach Gap)
+await timeline.requestFuture(count: 20);
+```
+
+---
+
+## Event-Typen Referenz
+
+```dart
+// Nachrichten-Typen (msgtype)
+'m.text'       // Textnachricht
+'m.emote'      // /me Aktion
+'m.notice'     // Bot-Nachricht (dezenter)
+'m.image'      // Bild
+'m.video'      // Video
+'m.audio'      // Audio/Sprachnachricht
+'m.file'       // Datei
+'m.location'   // Standort
+'m.sticker'    // Sticker (eigener Event-Typ: m.sticker)
+
+// Event-Typen (type)
+EventTypes.Message          // m.room.message
+EventTypes.Sticker          // m.sticker
+EventTypes.Reaction         // m.reaction
+EventTypes.RoomRedaction    // m.room.redaction
+EventTypes.Encrypted        // m.room.encrypted
+EventTypes.RoomName         // m.room.name
+EventTypes.RoomTopic        // m.room.topic
+EventTypes.RoomAvatar       // m.room.avatar
+EventTypes.RoomMember       // m.room.member
+EventTypes.RoomPowerLevels  // m.room.power_levels
+EventTypes.RoomCanonicalAlias // m.room.canonical_alias
+EventTypes.RoomJoinRules    // m.room.join_rules
+EventTypes.RoomGuestAccess  // m.room.guest_access
+EventTypes.HistoryVisibility // m.room.history_visibility
+EventTypes.RoomCreate       // m.room.create
+EventTypes.RoomTombstone    // m.room.tombstone
+EventTypes.Encryption       // m.room.encryption
+EventTypes.SpaceChild       // m.space.child
+EventTypes.SpaceParent      // m.space.parent
+EventTypes.CallInvite        // m.call.invite
+EventTypes.CallAnswer        // m.call.answer
+EventTypes.CallHangup        // m.call.hangup
+
+// Event-Status prüfen
+event.status == EventStatus.sending    // Wird gesendet (optimistisch)
+event.status == EventStatus.sent       // Vom Server bestätigt
+event.status == EventStatus.synced     // Im eigenen Sync empfangen
+event.status == EventStatus.error      // Fehlgeschlagen
+event.status == EventStatus.removed    // Gelöscht
+
+// Nützliche Event-Properties
+event.type               // String: Event-Typ
+event.eventId            // String: ID
+event.senderId           // String: MXID des Senders
+event.originServerTs     // DateTime: Sendezeitpunkt
+event.body               // String: Nachrichtentext (entschlüsselt)
+event.messageType        // String?: msgtype
+event.formattedBody      // String?: HTML-Inhalt
+event.isReply            // bool
+event.isEdit             // bool
+event.isReacted          // bool
+event.isRedacted         // bool
+event.isEncrypted        // bool
+event.isBadEncrypted     // bool: Entschlüsselung fehlgeschlagen
+event.isState            // bool: State-Event?
+event.relationshipEventId // String?: ID des referenzierten Events
+event.relationshipType   // String?: Beziehungstyp (m.replace, m.thread, etc.)
+
+// Sender-User holen
+final sender = room.unsafeGetUserFromMemoryOrFallback(event.senderId);
+print(sender.displayName);
+print(sender.avatarUrl);
+```
+
+---
+
+## Typing-Indikator
+
+```dart
+// Schreiben anzeigen
+await room.setTyping(true, timeout: 30000); // 30 Sekunden
+
+// Schreiben beenden
+await room.setTyping(false);
+
+// Tippende User im Raum beobachten
+final typing = room.typingUsers; // List<User>
+// Automatisch aktuell durch Sync
+```
+
+---
+
+## Read Markers / Lesebestätigung
+
+```dart
+// Gelesenes Event markieren
+await room.setReadMarker(
+  event.eventId,
+  mRead: event.eventId,   // private receipt (unsichtbar für andere)
+  // public receipt weglassen für private-only
+);
+
+// Öffentliche + private Lesebestätigung
+await room.setReadMarker(
+  event.eventId,
+  mRead: event.eventId,
+);
+
+// Letztes gelesenes Event
+final lastRead = room.lastReadEventId;
+
+// Ungelesen-Badge
+final count = room.notificationCount;   // Notifications
+final hl    = room.highlightCount;      // Mentions/Highlights
+```
+
+---
+
+## Pinned Messages
+
+```dart
+// Events anpinnen
+final currentPinned = (room.getState(EventTypes.RoomPinnedEvents)
+    ?.content['pinned'] as List?)
+    ?.cast<String>() ?? [];
+
+await room.client.sendState(
+  room.id,
+  EventTypes.RoomPinnedEvents,
+  {'pinned': [...currentPinned, eventId]},
+  stateKey: '',
+);
+
+// Angepinnte Events lesen
+final pinned = (room.getState(EventTypes.RoomPinnedEvents)
+    ?.content['pinned'] as List?)
+    ?.cast<String>() ?? [];
+
+// Events laden
+final pinnedEvents = await Future.wait(
+  pinned.map((id) => room.getEventById(id)),
+);
+```
+
+---
+
+## Fehlgeschlagene Events erneut senden
+
+```dart
+// Events mit Status error finden
+final failed = timeline.events
+    .where((e) => e.status == EventStatus.error)
+    .toList();
+
+// Erneut senden
+for (final event in failed) {
+  await event.sendAgain();
+}
+
+// Oder aus dem Timeline-Controller:
+await room.sendEvent(
+  event.content,
+  event.type,
+  txnId: event.eventId, // Gleiche txnId → überschreibt fehlgeschlagenes
+);
+```

docs/matrix-sdk/04-dm.md

@@ -0,0 +1,221 @@
+# 04 — Direct Messages (DMs)
+
+---
+
+## Inhaltsverzeichnis
+- [DM starten oder finden](#dm-starten-oder-finden)
+- [DM-Raum identifizieren](#dm-raum-identifizieren)
+- [DM-Liste](#dm-liste)
+- [Gruppen-DM](#gruppen-dm)
+- [DM-Raum schließen / vergessen](#dm-raum-schließen--vergessen)
+- [User-Profil für DM laden](#user-profil-für-dm-laden)
+- [Verschlüsselung in DMs](#verschlüsselung-in-dms)
+
+---
+
+## DM starten oder finden
+
+```dart
+// Existierenden DM finden oder neuen erstellen
+// Gibt immer einen joined Room zurück
+final room = await client.startDirectChat('@alice:server');
+print(room.id); // !roomId:server
+
+// Mit expliziten Optionen
+final room = await client.startDirectChat(
+  '@alice:server',
+  // enableEncryption: true,  // Standard: true
+);
+
+// Navigieren zum DM-Raum
+// (z.B. in Pyramid:)
+ref.read(activeRoomIdProvider.notifier).state = room.id;
+```
+
+---
+
+## DM-Raum identifizieren
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Ist es ein DM?
+final isDm = room.isDirectChat;                      // bool
+
+// Mit wem?
+final partner = room.directChatMatrixID;             // '@alice:server' oder null
+
+// DM zu einem bestimmten User finden
+final existingDm = client.getDirectChatFromUserId('@alice:server');
+// Gibt Room? zurück (null wenn kein DM vorhanden)
+
+// Alle DMs des Users (Account-Data)
+final dmMap = client.directChats;
+// Map<String, List<String>>: { '@alice:server': ['!roomId:server'] }
+```
+
+---
+
+## DM-Liste
+
+```dart
+// Alle DM-Räume (joined)
+final dms = client.rooms.where((r) =>
+    r.isDirectChat &&
+    r.membership == Membership.join,
+).toList();
+
+// Sortiert nach letzter Aktivität
+dms.sort((a, b) =>
+  (b.lastEvent?.originServerTs ?? DateTime(0))
+      .compareTo(a.lastEvent?.originServerTs ?? DateTime(0)));
+
+// DMs mit ungelesenen Nachrichten
+final unreadDms = dms.where((r) => r.notificationCount > 0).toList();
+
+// Display-Info für DM-Liste
+for (final dm in dms) {
+  final partner = client.getDirectChatFromUserId(dm.directChatMatrixID!);
+  final user = dm.unsafeGetUserFromMemoryOrFallback(dm.directChatMatrixID!);
+  print(user.displayName ?? dm.directChatMatrixID);
+  print(user.avatarUrl);
+  print(dm.lastEvent?.body);              // Vorschautext
+  print(dm.lastEvent?.originServerTs);   // Zeitstempel
+  print(dm.notificationCount);           // Ungelesen
+}
+```
+
+---
+
+## Gruppen-DM
+
+```dart
+// Gruppen-DM mit mehreren Personen erstellen
+final roomId = await client.createRoom(
+  name: 'Gruppenunterhaltung',
+  invite: ['@bob:server', '@charlie:server'],
+  isDirect: true,                        // Als DM markieren
+  preset: CreateRoomPreset.trustedPrivateChat,
+  enableEncryption: true,
+);
+
+// Oder mit startDirectChat (für Einzel-DMs) und manuell Teilnehmer hinzufügen
+final room = await client.startDirectChat('@bob:server');
+await room.invite('@charlie:server');
+
+// Gruppe als DM im Account-Data kennzeichnen
+// (passiert automatisch bei isDirect: true)
+```
+
+---
+
+## DM-Raum schließen / vergessen
+
+```dart
+final room = client.getRoomById('!roomId:server')!;
+
+// Verlassen (Gegenüber kann weiter chatten)
+await room.leave();
+
+// Aus Raumliste entfernen
+await room.forget();
+
+// DM aus Account-Daten entfernen
+final dmMap = Map<String, dynamic>.from(client.directChats);
+dmMap.remove('@alice:server');
+// oder nur den spezifischen Raum entfernen:
+final rooms = List<String>.from(dmMap['@alice:server'] ?? []);
+rooms.remove(room.id);
+if (rooms.isEmpty) {
+  dmMap.remove('@alice:server');
+} else {
+  dmMap['@alice:server'] = rooms;
+}
+await client.setAccountData(
+  client.userID!,
+  'm.direct',
+  dmMap,
+);
+```
+
+---
+
+## User-Profil für DM laden
+
+```dart
+// Profil des DM-Partners laden
+final partnerMxid = room.directChatMatrixID!;
+
+// Aus Room-Membership (gecacht, schnell)
+final user = room.unsafeGetUserFromMemoryOrFallback(partnerMxid);
+print(user.displayName);
+print(user.avatarUrl);
+
+// Frisch vom Server (genauer, aber langsamer)
+final profile = await client.getProfileFromUserId(partnerMxid);
+print(profile.displayname);
+print(profile.avatarUrl);
+
+// Avatar-URL in Widget verwenden
+// (mxc:// URI → HTTP-URL via SDK)
+final httpUrl = user.avatarUrl?.getThumbnail(
+  client,
+  width: 56,
+  height: 56,
+  method: ThumbnailMethod.crop,
+);
+```
+
+---
+
+## Verschlüsselung in DMs
+
+```dart
+// E2EE-Status prüfen
+final isEncrypted = room.isEncrypted;
+
+// E2EE aktivieren (einmalig, nicht mehr rückgängig!)
+if (!room.isEncrypted) {
+  await room.enableEncryption();
+}
+
+// Geräte des Partners verifizieren
+final partnerDevices = await client.getUserDeviceKeys('@alice:server');
+for (final device in partnerDevices?.deviceKeys.values ?? []) {
+  print('${device.deviceId}: verified=${device.verified}');
+}
+
+// Fehlende Schlüssel für Entschlüsselung anfordern
+await client.requestMissingSessionKeys();
+
+// Schlechte Verschlüsselung erkennen
+final badEvents = timeline.events
+    .where((e) => e.isBadEncrypted)
+    .toList();
+```
+
+---
+
+## Einladungen (DM-Invite-Ansicht)
+
+```dart
+// Eingehende DM-Einladungen
+final invites = client.rooms.where((r) =>
+    r.membership == Membership.invite &&
+    r.isDirectChat).toList();
+
+// Einladung anzeigen
+for (final invite in invites) {
+  final senderId = invite.getState(EventTypes.RoomMember, client.userID!)
+      ?.senderId;              // Wer hat eingeladen?
+  final sender = await client.getProfileFromUserId(senderId ?? '');
+  print('Einladung von ${sender.displayname}');
+
+  // Annehmen
+  await invite.join();
+
+  // Ablehnen
+  await invite.leave();
+  await invite.forget();
+}
+```

docs/matrix-sdk/05-media.md

@@ -0,0 +1,355 @@
+# 05 — Medien & Dateien
+
+---
+
+## Inhaltsverzeichnis
+- [Datei hochladen](#datei-hochladen)
+- [Bild senden](#bild-senden)
+- [Video senden](#video-senden)
+- [Audio / Sprachnachricht senden](#audio--sprachnachricht-senden)
+- [Datei senden](#datei-senden)
+- [Sticker senden](#sticker-senden)
+- [Medien herunterladen & entschlüsseln](#medien-herunterladen--entschlüsseln)
+- [Thumbnails & Vorschaubilder](#thumbnails--vorschaubilder)
+- [MXC-URL zu HTTP-URL](#mxc-url-zu-http-url)
+- [Verschlüsselte Medien](#verschlüsselte-medien)
+- [Avatar hochladen](#avatar-hochladen)
+- [MatrixFile-Objekte](#matrixfile-objekte)
+
+---
+
+## Datei hochladen
+
+```dart
+// Bytes hochladen → mxc:// URI zurück
+final mxcUri = await client.uploadContent(
+  fileBytes,                              // Uint8List
+  filename: 'datei.pdf',
+  contentType: 'application/pdf',         // optional, SDK erkennt es
+);
+print(mxcUri); // mxc://example.org/AbCdEf...
+```
+
+---
+
+## Bild senden
+
+```dart
+import 'package:matrix/matrix.dart';
+
+// MatrixImageFile erstellen
+final imageFile = MatrixImageFile(
+  bytes: imageBytes,                      // Uint8List
+  name: 'foto.jpg',
+  mimeType: 'image/jpeg',
+  width: 1920,                            // optional, für Info
+  height: 1080,
+);
+
+// Mit Thumbnail
+final thumbnail = MatrixImageFile(
+  bytes: thumbnailBytes,
+  name: 'foto_thumb.jpg',
+  mimeType: 'image/jpeg',
+  width: 320,
+  height: 180,
+);
+
+// Senden (lädt automatisch hoch + sendet m.image Event)
+await room.sendFileEvent(
+  imageFile,
+  thumbnail: thumbnail,                   // optional
+);
+
+// Alternativ mit sendImageEvent
+await room.sendImageEvent(
+  imageFile,
+  thumbnail: thumbnail,
+);
+```
+
+---
+
+## Video senden
+
+```dart
+final videoFile = MatrixVideoFile(
+  bytes: videoBytes,
+  name: 'video.mp4',
+  mimeType: 'video/mp4',
+  duration: 45000,                        // Millisekunden
+  width: 1920,
+  height: 1080,
+);
+
+final thumbFile = MatrixImageFile(
+  bytes: thumbnailBytes,
+  name: 'thumb.jpg',
+  mimeType: 'image/jpeg',
+  width: 320,
+  height: 180,
+);
+
+await room.sendVideoEvent(
+  videoFile,
+  thumbnail: thumbFile,
+);
+```
+
+---
+
+## Audio / Sprachnachricht senden
+
+```dart
+// Audio-Datei
+final audioFile = MatrixAudioFile(
+  bytes: audioBytes,
+  name: 'aufnahme.ogg',
+  mimeType: 'audio/ogg',
+  duration: 12000,                        // Millisekunden
+);
+
+await room.sendAudioEvent(audioFile);
+
+// Sprachnachricht (Voice Message MSC3245)
+await room.sendFileEvent(
+  audioFile,
+  extraContent: {
+    'org.matrix.msc3245.voice': {},       // markiert als Sprachnachricht
+    'org.matrix.msc1767.audio': {
+      'duration': 12000,
+      'waveform': [0, 50, 100, 75, ...],  // Amplituden (0-1024)
+    },
+  },
+);
+```
+
+---
+
+## Datei senden
+
+```dart
+final file = MatrixFile(
+  bytes: fileBytes,
+  name: 'dokument.pdf',
+  mimeType: 'application/pdf',
+);
+
+await room.sendFileEvent(file);
+
+// Mit Extra-Metadaten
+await room.sendFileEvent(
+  file,
+  extraContent: {
+    'org.matrix.msc3554.caption': {
+      'msgtype': 'm.text',
+      'body': 'Hier das Dokument',
+    },
+  },
+);
+```
+
+---
+
+## Sticker senden
+
+```dart
+// Sticker sind ein eigener Event-Typ (m.sticker)
+await room.sendEvent(
+  {
+    'body': 'Ein Sticker',
+    'url': 'mxc://example.org/stickerId',
+    'info': {
+      'mimetype': 'image/png',
+      'w': 256,
+      'h': 256,
+    },
+  },
+  EventTypes.Sticker,                     // 'm.sticker'
+);
+```
+
+---
+
+## Medien herunterladen & entschlüsseln
+
+```dart
+// Aus Event-Attachment herunterladen (+ automatisch entschlüsseln bei E2EE)
+final data = await event.downloadAndDecryptAttachment(
+  getThumbnail: false,                    // true für Thumbnail statt Original
+);
+// data ist MatrixFile mit .bytes: Uint8List
+
+// Direkte MXC-URL herunterladen
+final bytes = await client.database.getFile(mxcUri);
+// oder über HTTP:
+final httpUri = mxcUri.getDownloadUri(client);
+// → https://homeserver/_matrix/media/v3/download/server/mediaId
+```
+
+---
+
+## Thumbnails & Vorschaubilder
+
+```dart
+// Thumbnail-URL für Widget
+final thumbnailUri = event.thumbnailUrl;  // mxc:// URI
+
+// HTTP-URL für Thumbnail (mit Größe)
+final httpUrl = thumbnailUri?.getThumbnail(
+  client,
+  width: 800,
+  height: 600,
+  method: ThumbnailMethod.scale,          // oder .crop
+);
+
+// Avatar-Thumbnail
+final avatarUrl = user.avatarUrl?.getThumbnail(
+  client,
+  width: 56,
+  height: 56,
+  method: ThumbnailMethod.crop,
+);
+
+// Im Flutter Widget (CachedNetworkImage o.ä.):
+Image.network(httpUrl.toString());
+```
+
+---
+
+## MXC-URL zu HTTP-URL
+
+```dart
+// Download-URL
+final downloadUrl = Uri.parse(mxcUriString).getDownloadUri(client);
+// → https://homeserver/_matrix/media/v3/download/server/mediaId
+
+// Thumbnail-URL
+final thumbUrl = Uri.parse(mxcUriString).getThumbnail(
+  client,
+  width: 300,
+  height: 300,
+  method: ThumbnailMethod.crop,
+);
+
+// Direkt als String
+final urlString = downloadUrl.toString();
+```
+
+---
+
+## Verschlüsselte Medien
+
+```dart
+// In verschlüsselten Räumen werden Medien automatisch verschlüsselt.
+// Das SDK übernimmt Ver- und Entschlüsselung transparent.
+
+// Verschlüsselter Download (automatisch):
+final file = await event.downloadAndDecryptAttachment();
+// file.bytes enthält die entschlüsselten Rohdaten
+
+// Manuell ver-/entschlüsseln (selten nötig):
+// Nutze EncryptedFile aus dem matrix-package
+final encryptedFile = EncryptedFile(
+  url: 'mxc://...',
+  key: {/* JWK */},
+  iv: 'base64...',
+  hashes: {'sha256': 'base64...'},
+  v: 'v2',
+);
+```
+
+---
+
+## Avatar hochladen
+
+```dart
+// Eigener Avatar
+final avatarBytes = await File('avatar.png').readAsBytes();
+final mxcUri = await client.uploadContent(
+  avatarBytes,
+  filename: 'avatar.png',
+  contentType: 'image/png',
+);
+await client.setAvatarUrl(client.userID!, mxcUri);
+
+// Raum-Avatar
+final roomAvatarMxc = await client.uploadContent(imageBytes, filename: 'room.png');
+await room.setAvatar(roomAvatarMxc);
+```
+
+---
+
+## MatrixFile-Objekte
+
+```dart
+// Basis-Klasse
+MatrixFile({
+  required Uint8List bytes,
+  required String name,
+  String? mimeType,
+})
+
+// Spezialisierte Unterklassen:
+MatrixImageFile({
+  required Uint8List bytes,
+  required String name,
+  String? mimeType,       // z.B. 'image/jpeg'
+  int? width,
+  int? height,
+  bool? animated,         // für GIFs
+})
+
+MatrixVideoFile({
+  required Uint8List bytes,
+  required String name,
+  String? mimeType,       // 'video/mp4'
+  int? duration,          // ms
+  int? width,
+  int? height,
+  MatrixImageFile? thumbnail,
+})
+
+MatrixAudioFile({
+  required Uint8List bytes,
+  required String name,
+  String? mimeType,       // 'audio/ogg'
+  int? duration,          // ms
+})
+
+// Eigenschaften
+file.bytes              // Uint8List
+file.name               // Dateiname
+file.mimeType           // MIME-Typ
+file.sizeString         // '1.4 MB' (formatiert)
+file.size               // Bytes als int
+```
+
+---
+
+## Medien-Events lesen
+
+```dart
+// Attachment-Info aus Event
+if (event.messageType == 'm.image') {
+  final url = event.attachmentMxcUrl;     // mxc:// URI
+  final mime = event.attachmentMimetype;  // 'image/jpeg'
+  final size = event.attachmentSize;      // Bytes
+  final width = event.infoMap['w'] as int?;
+  final height = event.infoMap['h'] as int?;
+}
+
+if (event.messageType == 'm.video') {
+  final duration = event.infoMap['duration'] as int?; // ms
+}
+
+if (event.messageType == 'm.audio') {
+  final duration = event.infoMap['duration'] as int?;
+  final waveform = event.content
+      .tryGetMap('org.matrix.msc1767.audio')
+      ?.tryGetList<int>('waveform');
+}
+
+// Datei-Größe als lesbarer String
+print(event.sizeString); // '2.3 MB'
+```

docs/matrix-sdk/06-encryption.md

@@ -0,0 +1,313 @@
+# 06 — E2EE Verschlüsselung
+
+---
+
+## Inhaltsverzeichnis
+- [Setup & Initialisierung](#setup--initialisierung)
+- [Verschlüsselung aktivieren](#verschlüsselung-aktivieren)
+- [Entschlüsselung & Fehlerfälle](#entschlüsselung--fehlerfälle)
+- [Device-Verifikation (SAS)](#device-verifikation-sas)
+- [Cross-Signing](#cross-signing)
+- [Key Backup](#key-backup)
+- [Fehlende Session Keys anfordern](#fehlende-session-keys-anfordern)
+- [Geräte-Keys abfragen](#geräte-keys-abfragen)
+- [Trust-Status](#trust-status)
+
+---
+
+## Setup & Initialisierung
+
+```dart
+// flutter_vodozemac muss initialisiert sein BEVOR Client erstellt wird
+import 'package:flutter_vodozemac/flutter_vodozemac.dart' as vod;
+await vod.init();
+
+// Client mit E2EE-Support
+final client = Client(
+  'Pyramid',
+  database: await MatrixSdkDatabase.init('pyramid', database: db),
+  nativeImplementations: NativeImplementationsIsolate(compute),
+  // Oder für Hintergrund-Isolaten (kein compute):
+  // nativeImplementations: NativeImplementationsDummy(),
+  verificationMethods: {
+    KeyVerificationMethod.numbers,
+    KeyVerificationMethod.emoji,
+    // KeyVerificationMethod.qrCodeScan,  // falls QR-Scanner vorhanden
+    // KeyVerificationMethod.qrCodeShow,
+  },
+);
+
+await client.init(
+  waitForFirstSync: false,
+  waitUntilLoadCompletedLoaded: false,
+);
+
+// E2EE verfügbar prüfen
+print(client.encryptionEnabled); // true wenn Vodozemac/Olm geladen
+```
+
+---
+
+## Verschlüsselung aktivieren
+
+```dart
+// Raum-Verschlüsselung einschalten (PERMANENT, nicht rückgängig!)
+if (!room.isEncrypted) {
+  await room.enableEncryption();
+}
+
+// Verschlüsselung beim Erstellen aktivieren
+final roomId = await client.createRoom(
+  name: 'Verschlüsselter Raum',
+  enableEncryption: true,
+  preset: CreateRoomPreset.privateChat,
+);
+
+// Status prüfen
+print(room.isEncrypted);          // bool
+print(room.encryptionAlgorithm);  // 'm.megolm.v1.aes-sha2'
+```
+
+---
+
+## Entschlüsselung & Fehlerfälle
+
+```dart
+// Beim Anzeigen von Events prüfen:
+if (event.isBadEncrypted) {
+  // Anzeigen: "Nachricht kann nicht entschlüsselt werden"
+  // Mögliche Ursachen:
+  // - Gerät war nicht in der Raumschlüssel-Verteilung
+  // - Session fehlt (Megolm Session nicht vorhanden)
+  // - Falsches Gerät / fehlende Olm-Session
+}
+
+// Entschlüsselungs-Fehler-Typ
+if (event.content['can_not_decrypt'] != null) {
+  // Generischer Fehler
+}
+if (event.type == EventTypes.Encrypted && event.plaintextContent == null) {
+  // Noch nicht entschlüsselt
+}
+
+// Event-Body bei Fehler prüfen
+final body = event.body;
+// Enthält "** Unable to decrypt: ..." bei Fehlern
+
+// Fehlende Schlüssel anfordern (von anderen Geräten)
+await client.requestMissingSessionKeys();
+```
+
+---
+
+## Device-Verifikation (SAS)
+
+```dart
+// ── Verifikation starten (ich verifiziere ein anderes Gerät) ──────────────
+
+// Verifikations-Anfrage senden
+final request = await client.userDeviceKeys[otherUserId]!
+    .startVerification();
+// request.onUpdate: Stream mit Zustandsänderungen
+
+// ── Verifikation empfangen (anderes Gerät will mich verifizieren) ─────────
+
+// Eingehende Anfragen beobachten
+client.onKeyVerificationRequest.stream.listen((request) async {
+  // Anfrage annehmen
+  await request.acceptVerification();
+});
+
+// ── SAS-Flow ─────────────────────────────────────────────────────────────
+
+// Auf SAS-Ready warten und Emojis/Zahlen anzeigen
+request.onUpdate.stream.listen((_) async {
+  if (request.state == KeyVerificationState.showSas) {
+    // Emojis anzeigen
+    final emojis = request.sasEmojis; // List<KeyVerificationEmoji>
+    for (final emoji in emojis) {
+      print('${emoji.emoji} ${emoji.name}');
+    }
+
+    // Oder Dezimalzahlen
+    final decimals = request.sasDecimals; // List<int> (3 Zahlen)
+    print(decimals); // z.B. [1234, 5678, 9012]
+
+    // Wenn User bestätigt dass sie übereinstimmen:
+    await request.confirmSas();
+
+    // Wenn sie nicht übereinstimmen:
+    // await request.rejectSas();
+  }
+
+  if (request.state == KeyVerificationState.done) {
+    print('Verifikation erfolgreich!');
+  }
+
+  if (request.state == KeyVerificationState.error) {
+    print('Verifikation fehlgeschlagen: ${request.cancelCode}');
+  }
+});
+
+// ── QR-Code Verifikation ─────────────────────────────────────────────────
+
+// QR-Code zum Anzeigen generieren
+final qrData = await request.generateQrCodeData();
+// qrData als QR-Code rendern (z.B. mit qr_flutter-Package)
+
+// Gescannten QR-Code verarbeiten
+await request.scanQrCode(scannedData);
+
+// Bestätigen dass QR gescannt wurde
+await request.confirmQrCodeScanned();
+```
+
+---
+
+## Cross-Signing
+
+```dart
+// Cross-Signing bootstrappen (erstellt Master-, Self- und User-Signing-Keys)
+// Nur einmal pro Account nötig
+await client.encryption!.bootstrapCrossSigning(
+  setupMasterKey: true,
+  setupSelfSigningKey: true,
+  setupUserSigningKey: true,
+);
+
+// Cross-Signing-Status
+final crossSigning = client.encryption!.crossSigning;
+print(crossSigning.enabled);          // bool
+print(crossSigning.selfSigned);       // bool: eigenes Gerät ist self-signed
+
+// Eigenes Gerät ist verifiziert?
+final myDevice = client.userDeviceKeys[client.userID]
+    ?.deviceKeys[client.deviceID];
+print(myDevice?.verified);            // bool
+
+// Anderen User als vertrauenswürdig markieren
+await client.encryption!.crossSigning.signUser(otherUserId);
+
+// Gerät verifizieren (nach SAS/QR)
+await myDevice?.setVerified(true);
+```
+
+---
+
+## Key Backup
+
+```dart
+// ── Key Backup einrichten ─────────────────────────────────────────────────
+
+// Vollständiges Crypto-Setup (empfohlen):
+// Erstellt Secret Storage + Cross-Signing + Key Backup
+await client.bootstrapCryptoIdentity(
+  wipeRecovery: false,    // true: bestehende Recovery überschreiben
+);
+
+// Nur Key Backup:
+final backup = client.encryption!.keyManager;
+
+// Recovery-Key generieren und anzeigen
+final recoveryKey = await client.encryption!.ssss.generateKey();
+print(recoveryKey); // Langer alphanumerischer Schlüssel → User aufschreiben lassen!
+
+// ── Key Backup Status ─────────────────────────────────────────────────────
+
+// Ist Key Backup aktiv?
+final keyBackupEnabled = client.encryption!.keyManager.enabled;
+
+// Alle Sessions hochladen
+await client.encryption!.keyManager.uploadInboundGroupSessions();
+
+// ── Backup wiederherstellen (Recovery) ───────────────────────────────────
+
+// Keys von Server-Backup wiederherstellen
+await client.encryption!.keyManager.loadFromResponse(
+  await client.getRoomKeysBackup(),
+);
+
+// Oder mit Recovery-Key:
+await client.encryption!.ssss.unlock(recoveryKey: eingabe);
+await client.encryption!.keyManager.restore();
+```
+
+---
+
+## Fehlende Session Keys anfordern
+
+```dart
+// Schlüssel von anderen Geräten desselben Users anfordern
+await client.requestMissingSessionKeys();
+
+// Für einen spezifischen Raum
+await client.requestMissingSessionKeys(
+  rooms: [room],
+);
+
+// Einzelne Session anfordern (für ein spezifisches Event)
+if (event.isBadEncrypted) {
+  final sessionId = event.content
+      .tryGet<String>('session_id');
+  final senderKey = event.content
+      .tryGet<String>('sender_key');
+  if (sessionId != null) {
+    await room.requestKey(sessionId);
+  }
+}
+```
+
+---
+
+## Geräte-Keys abfragen
+
+```dart
+// Alle Geräte eines Users laden
+final userDevices = await client.getUserDeviceKeys(userId);
+// → Map<String, DeviceKeysList>
+
+// Geräte eines Raums (alle Mitglieder)
+final roomDevices = await room.getUserDeviceKeys();
+
+// Eigene Geräte
+final myDevices = client.userDeviceKeys[client.userID]?.deviceKeys;
+
+// Gerät-Details
+for (final device in myDevices?.values ?? []) {
+  print(device.deviceId);
+  print(device.displayName);
+  print(device.verified);
+  print(device.blocked);
+  print(device.ed25519Key);    // Signatur-Schlüssel
+  print(device.curve25519Key); // Encryption-Schlüssel
+}
+
+// Gerät sperren (Nachrichten werden nicht mehr entschlüsselt gesendet)
+await myDevices?['DEVICEID']?.setBlocked(true);
+```
+
+---
+
+## Trust-Status
+
+```dart
+// Trust-Level für Raum berechnen
+final encryption = room.client.encryption;
+if (encryption != null) {
+  final trust = await room.calcEncryptionHealthState();
+  // trust: .allVerified | .unverifiedDevices | .unknown
+}
+
+// User-Trust
+final userTrust = client.userDeviceKeys[userId]?.verified;
+// null = unbekannt, true = verifiziert, false = blockiert
+
+// Nachrichten-Verifikation
+if (!event.encryptionHealthState.allVerified) {
+  // Anzeigen: "Gesendet von unverifiziertem Gerät"
+}
+
+// Eigene Identität
+final myIdentity = client.encryption?.crossSigning;
+print(myIdentity?.selfSigned);      // Eigenes Gerät cross-signed?
+```

docs/matrix-sdk/07-push.md

@@ -0,0 +1,291 @@
+# 07 — Push & Benachrichtigungen
+
+---
+
+## Inhaltsverzeichnis
+- [Pusher registrieren (FCM)](#pusher-registrieren-fcm)
+- [Pusher abrufen & verwalten](#pusher-abrufen--verwalten)
+- [Push Rules](#push-rules)
+- [onNotification Stream](#onnotification-stream)
+- [Lokale Benachrichtigungen (Android)](#lokale-benachrichtigungen-android)
+- [Benachrichtigungen: Pyramid-Architektur](#benachrichtigungen-pyramid-architektur)
+- [Notification Counts](#notification-counts)
+
+---
+
+## Pusher registrieren (FCM)
+
+```dart
+// FCM-Token holen
+import 'package:firebase_messaging/firebase_messaging.dart';
+final fcmToken = await FirebaseMessaging.instance.getToken();
+
+// Pusher beim Homeserver registrieren
+await client.postPusher(
+  Pusher(
+    pushkey: fcmToken!,
+    kind: 'http',
+    appId: 'chat.pyramid.pyramid',        // Unique App-ID (muss zu Push-Gateway passen)
+    appDisplayName: 'Pyramid',
+    deviceDisplayName: 'Mein Android',
+    lang: 'de',
+    data: PusherData(
+      url: Uri.parse('https://push.example.org/_matrix/push/v1/notify'),
+      format: 'event_id_only',            // Empfohlen (nur Event-ID, nicht der Inhalt)
+    ),
+  ),
+  append: true,                           // Nicht andere Pusher dieses Geräts löschen
+);
+
+// Token-Refresh überwachen
+FirebaseMessaging.instance.onTokenRefresh.listen((newToken) async {
+  await client.postPusher(
+    Pusher(pushkey: newToken, /* ... */ ),
+    append: true,
+  );
+});
+```
+
+---
+
+## Pusher abrufen & verwalten
+
+```dart
+// Alle Pusher dieses Users
+final pushers = await client.getPushers() ?? [];
+for (final pusher in pushers) {
+  print(pusher.appId);
+  print(pusher.pushkey);
+  print(pusher.data.url);
+}
+
+// Pusher entfernen
+await client.deletePusher(
+  Pusher(
+    pushkey: fcmToken,
+    appId: 'chat.pyramid.pyramid',
+    kind: 'http',          // Pflichtfeld beim Löschen
+    // ...
+  ),
+);
+
+// Beim Logout alle Pusher entfernen
+final myPushers = (await client.getPushers() ?? [])
+    .where((p) => p.appId == 'chat.pyramid.pyramid');
+for (final p in myPushers) {
+  await client.deletePusher(p);
+}
+```
+
+---
+
+## Push Rules
+
+```dart
+// Alle Push Rules abrufen
+final ruleset = await client.getPushRules();
+
+// Globale Regeln
+for (final rule in ruleset.global.content ?? []) {
+  print(rule.ruleId);
+  print(rule.enabled);
+  print(rule.actions);
+}
+
+// Kategorien der Regeln:
+// .override  — höchste Priorität (z.B. DND-Modus)
+// .content   — Inhalt-basiert (z.B. eigener Name erwähnt)
+// .room      — Raum-spezifisch
+// .sender    — Sender-spezifisch
+// .underride — niedrigste Priorität (Fallback)
+
+// Push Rule aktivieren/deaktivieren
+await client.setPushRuleEnabled(
+  'global',
+  PushRuleKind.override,
+  '.m.rule.master',              // DND: stumm schalten
+  false,                         // false = Regel deaktivieren
+);
+
+// Eigene Push Rule erstellen (z.B. Raum stumm schalten)
+await client.setPushRule(
+  'global',
+  PushRuleKind.room,
+  '!roomId:server',              // RuleId = RoomId für Raum-Regeln
+  [PushRuleAction.dontNotify],
+);
+
+// Push Rule löschen
+await client.deletePushRule(
+  'global',
+  PushRuleKind.room,
+  '!roomId:server',
+);
+
+// Standard-Rules für Erwähnungen
+// Pyramid prüft lokal ob ein Event eine Mention enthält:
+final myId = client.userID!;
+final mentions = event.content
+    .tryGetMap<String, dynamic>('m.mentions')
+    ?.tryGetList<String>('user_ids') ?? [];
+final isMentioned = mentions.contains(myId) ||
+    event.body.contains(myId);
+
+// Raum stumm schalten
+await client.setPushRule(
+  'global',
+  PushRuleKind.override,
+  '!roomId:server',
+  [PushRuleAction.dontNotify],
+  conditions: [
+    PushCondition(kind: 'event_match', key: 'room_id', pattern: '!roomId:server'),
+  ],
+);
+```
+
+---
+
+## onNotification Stream
+
+```dart
+// Matrix-SDK emittiert Events die Benachrichtigungen auslösen sollen
+// (nach Push-Rule-Matching, entschlüsselt)
+client.onNotification.stream.listen((Event event) {
+  final roomId = event.room.id;
+  final room = client.getRoomById(roomId)!;
+  final sender = room.unsafeGetUserFromMemoryOrFallback(event.senderId);
+
+  final title = room.isDirectChat
+      ? sender.displayName ?? event.senderId
+      : '${sender.displayName} · ${room.getLocalizedDisplayname()}';
+  final body = event.body;
+
+  // Lokale Benachrichtigung anzeigen
+  showLocalNotification(title, body, roomId);
+});
+```
+
+---
+
+## Lokale Benachrichtigungen (Android)
+
+```dart
+// Siehe auch: lib/core/notification_service.dart und PushService.kt
+
+// flutter_local_notifications initialisieren
+final plugin = FlutterLocalNotificationsPlugin();
+await plugin.initialize(
+  const InitializationSettings(
+    android: AndroidInitializationSettings('@drawable/ic_notification'),
+  ),
+  onDidReceiveNotificationResponse: _handleNotificationTap,
+  onDidReceiveBackgroundNotificationResponse: handleBackgroundResponse,
+);
+
+// Notification-Kanal erstellen (Android 8+)
+await plugin.resolvePlatformSpecificImplementation<
+    AndroidFlutterLocalNotificationsPlugin>()
+  ?.createNotificationChannel(
+    const AndroidNotificationChannel(
+      'pyramid_messages',
+      'Nachrichten',
+      description: 'Neue Nachrichten',
+      importance: Importance.high,
+    ),
+  );
+
+// Benachrichtigung anzeigen (mit Reply-Action)
+await plugin.show(
+  notifId,
+  'Absender',
+  'Nachrichtentext',
+  NotificationDetails(
+    android: AndroidNotificationDetails(
+      'pyramid_messages',
+      'Nachrichten',
+      importance: Importance.high,
+      priority: Priority.high,
+      icon: '@drawable/ic_notification',
+      actions: [
+        AndroidNotificationAction(
+          'reply', 'Antworten',
+          inputs: [AndroidNotificationActionInput(label: 'Antworten…')],
+          allowGeneratedReplies: true,
+          showsUserInterface: false,   // BroadcastReceiver-Pfad
+        ),
+        AndroidNotificationAction('read', 'Gelesen',
+          showsUserInterface: false),
+      ],
+    ),
+  ),
+  payload: roomId,
+);
+
+// Benachrichtigung schließen
+await plugin.cancel(notifId);
+```
+
+---
+
+## Benachrichtigungen: Pyramid-Architektur
+
+```
+FCM-Payload → PushService.kt (Kotlin, kein Dart-Overhead)
+    │
+    ├─ App im Vordergrund? → Heartbeat-Check → Skip
+    │
+    ├─ HTTP-Fetch: Absender + Raumname (ohne Entschlüsselung möglich)
+    │
+    ├─ Native Notification anzeigen: "Neue Nachricht"
+    │    └─ Reply-Action → getActivity(MainActivity) → onNewIntent
+    │
+    └─ Flutter-Engine im Cache? → MethodChannel "decryptAndUpdateNotification"
+           └─ Dart: decryptAndUpdateNotification() → showNativeNotification() [mit echtem Text]
+
+Reply-Flow:
+    User tippt Antwort → Reply-PendingIntent (getActivity)
+    → MainActivity.onNewIntent → MethodChannel "replyFromNotification"
+    → Dart: room.sendTextEvent(text)
+    → moveTaskToBack(true)
+```
+
+```dart
+// Heartbeat (App aktiv?) setzen:
+void _pingHeartbeat() {
+  SharedPreferences.getInstance().then(
+    (p) => p.setInt('notif_app_heartbeat', DateTime.now().millisecondsSinceEpoch),
+  );
+}
+
+// Heartbeat löschen (App im Hintergrund):
+void setAppForeground(bool value) {
+  if (!value) {
+    SharedPreferences.getInstance()
+        .then((p) => p.setInt('notif_app_heartbeat', 0));
+  }
+}
+```
+
+---
+
+## Notification Counts
+
+```dart
+// Pro Raum
+print(room.notificationCount);  // Ungelesene Nachrichten
+print(room.highlightCount);     // Mentions / Highlights
+
+// Gesamt
+final totalUnread = client.rooms.fold<int>(
+  0, (sum, r) => sum + r.notificationCount);
+final totalHighlights = client.rooms.fold<int>(
+  0, (sum, r) => sum + r.highlightCount);
+
+// Badge für Windows Taskbar
+import 'package:windows_taskbar/windows_taskbar.dart';
+if (totalUnread > 0) {
+  WindowsTaskbar.setProgressMode(TaskbarProgressMode.error);
+} else {
+  WindowsTaskbar.setProgressMode(TaskbarProgressMode.noProgress);
+}
+```

docs/matrix-sdk/08-voip.md

@@ -0,0 +1,422 @@
+# 08 — VoIP, Calls & LiveKit (MatrixRTC)
+
+---
+
+## Inhaltsverzeichnis
+- [Architektur-Überblick](#architektur-überblick)
+- [1:1 Call (Legacy m.call)](#11-call-legacy-mcall)
+- [MatrixRTC (Gruppen-Calls)](#matrixrtc-gruppen-calls)
+- [LiveKit-Integration](#livekit-integration)
+- [Klingel-Flow](#klingel-flow)
+- [WebRTC Setup in Flutter](#webrtc-setup-in-flutter)
+- [Call-State Management](#call-state-management)
+- [Pyramid VoIP-Architektur](#pyramid-voip-architektur)
+
+---
+
+## Architektur-Überblick
+
+```
+Matrix Signaling (to-device / room events)
+        │
+        ▼
+  MatrixRTC Layer
+  ┌─────────────────────────────────┐
+  │  com.famedly.call.member Events │
+  │  (Membership, Backend, Expiry)  │
+  └──────────────┬──────────────────┘
+                 │
+        ┌────────┴────────┐
+        │                 │
+    Mesh (P2P)       LiveKit (SFU)
+    WebRTC direct    livekit-server
+    (1:1, max ~4)    (skalierbar, n:m)
+```
+
+---
+
+## 1:1 Call (Legacy m.call)
+
+```dart
+// ── Anruf starten ────────────────────────────────────────────────────────
+// Wird vom SDK über room events (m.call.invite, m.call.candidates,
+// m.call.answer, m.call.hangup) signalisiert.
+
+// Anruf-Einladung senden (nach WebRTC offer)
+await room.sendEvent(
+  {
+    'call_id': 'eindeutige-call-id',
+    'version': 1,
+    'lifetime': 60000,              // ms, wie lange das Invite gültig ist
+    'offer': {
+      'type': 'offer',
+      'sdp': sdpString,            // WebRTC SDP Offer
+    },
+  },
+  EventTypes.CallInvite,           // 'm.call.invite'
+);
+
+// ICE-Kandidaten senden
+await room.sendEvent(
+  {
+    'call_id': callId,
+    'version': 1,
+    'candidates': [
+      {
+        'candidate': 'candidate:...',
+        'sdpMid': '0',
+        'sdpMLineIndex': 0,
+      },
+    ],
+  },
+  EventTypes.CallCandidates,       // 'm.call.candidates'
+);
+
+// Anruf annehmen (SDP Answer)
+await room.sendEvent(
+  {
+    'call_id': callId,
+    'version': 1,
+    'answer': {
+      'type': 'answer',
+      'sdp': sdpAnswerString,
+    },
+  },
+  EventTypes.CallAnswer,           // 'm.call.answer'
+);
+
+// Auflegen
+await room.sendEvent(
+  {
+    'call_id': callId,
+    'version': 1,
+    'reason': 'user_hangup',        // oder 'ice_failed', 'invite_timeout'
+  },
+  EventTypes.CallHangup,           // 'm.call.hangup'
+);
+
+// Ablehnen (Reject)
+await room.sendEvent(
+  {
+    'call_id': callId,
+    'version': 1,
+    'reason': 'user_hangup',
+  },
+  EventTypes.CallReject,           // 'm.call.reject'
+);
+
+// Eingehende Anrufe überwachen
+client.onCallInvite.stream.listen((CallInvite invite) {
+  print('Eingehender Anruf von ${invite.roomId}');
+  print('Call-ID: ${invite.callId}');
+});
+```
+
+---
+
+## MatrixRTC (Gruppen-Calls)
+
+```dart
+// MatrixRTC verwendet com.famedly.call.member State-Events
+
+// ── Call beitreten (Membership senden) ───────────────────────────────────
+
+final myDeviceId = client.deviceID!;
+final callId = room.id;               // Normalerweise = Raum-ID
+
+// Membership-Event senden (signalisiert "ich bin im Call")
+await room.client.sendState(
+  room.id,
+  'org.matrix.msc3401.call.member',  // oder 'com.famedly.call.member'
+  {
+    'application': 'm.call',
+    'call_id': callId,
+    'device_id': myDeviceId,
+    'expires_ts': DateTime.now()
+        .add(const Duration(hours: 1))
+        .millisecondsSinceEpoch,
+    'backend': {
+      'type': 'm.sfu',               // LiveKit
+      'livekit_service_url': 'https://livekit.example.org',
+    },
+    // Für Mesh:
+    // 'backend': {'type': 'm.mesh'},
+    'membershipID': 'eindeutige-membership-id',
+  },
+  stateKey: '$myDeviceId:$callId',
+);
+
+// ── Call verlassen (Membership entfernen) ─────────────────────────────────
+
+await room.client.sendState(
+  room.id,
+  'org.matrix.msc3401.call.member',
+  {},                                // Leeres Content = Austritt
+  stateKey: '$myDeviceId:$callId',
+);
+
+// ── Aktive Call-Mitglieder auflesen ──────────────────────────────────────
+
+final callStates = room.states['org.matrix.msc3401.call.member'];
+final now = DateTime.now().millisecondsSinceEpoch;
+final activeMembers = callStates?.values.where((event) {
+  final expiresTs = event.content['expires_ts'] as int? ?? 0;
+  return expiresTs > now;           // Nicht abgelaufen
+}).toList() ?? [];
+
+for (final member in activeMembers) {
+  print(member.content['device_id']);
+  print(member.stateKey);           // 'deviceId:callId'
+}
+```
+
+---
+
+## LiveKit-Integration
+
+```dart
+// LiveKit-Token vom Matrix-Homeserver anfragen (OpenID)
+// Dieser Flow authentifiziert den User beim LiveKit-Server ohne eigenes Passwort.
+
+// 1. OpenID-Token vom Homeserver holen
+final openIdToken = await client.requestOpenIdToken(client.userID!);
+// openIdToken.accessToken, .matrixServerName
+
+// 2. LiveKit-Token beim MatrixRTC-Service tauschen
+// (Pyramid sendet openIdToken an livekit_service_url des Raums)
+final response = await http.post(
+  Uri.parse('https://livekit-service.example.org/sfu/get'),
+  headers: {'Content-Type': 'application/json'},
+  body: jsonEncode({
+    'room': room.id,
+    'openid_token': {
+      'access_token': openIdToken.accessToken,
+      'token_type': 'Bearer',
+      'matrix_server_name': openIdToken.matrixServerName,
+    },
+    'device_id': client.deviceID,
+  }),
+);
+final livekitToken = jsonDecode(response.body)['token'];
+
+// 3. Mit LiveKit verbinden
+import 'package:livekit_client/livekit_client.dart';
+final room = await LiveKitClient.connect(
+  'wss://livekit.example.org',
+  livekitToken,
+  roomOptions: const RoomOptions(
+    adaptiveStream: true,
+    dynacast: true,
+    defaultVideoPublishOptions: VideoPublishOptions(
+      simulcast: true,
+    ),
+  ),
+);
+
+// 4. Mikrofon aktivieren
+await room.localParticipant?.setMicrophoneEnabled(true);
+
+// 5. Kamera aktivieren (Video-Call)
+await room.localParticipant?.setCameraEnabled(true);
+
+// 6. Teilnehmer observieren
+room.addListener(() {
+  for (final participant in room.participants.values) {
+    print(participant.identity);    // Matrix User-ID
+    for (final track in participant.videoTracks) {
+      // Widget: VideoTrackRenderer(track.track!)
+    }
+  }
+});
+```
+
+---
+
+## Klingel-Flow
+
+```dart
+// ── Anruf initiieren ──────────────────────────────────────────────────────
+
+// 1. Membership-Event senden (MatrixRTC)
+// 2. To-Device-Event senden für Push-Benachrichtigung beim Empfänger
+
+// Klingelanruf via to-device-Event
+await client.sendToDevice(
+  'com.famedly.call',              // Event-Typ
+  {
+    otherUserId: {
+      '*': {                       // Alle Geräte des Users
+        'call_id': callId,
+        'room_id': room.id,
+        'type': 'invite',
+        'sender_session_id': client.deviceID,
+      },
+    },
+  },
+);
+
+// ── Eingehenden Anruf empfangen ───────────────────────────────────────────
+
+client.onToDeviceEvent.stream
+    .where((e) => e.type == 'com.famedly.call')
+    .listen((event) {
+  final callId = event.content['call_id'];
+  final roomId = event.content['room_id'];
+  final type   = event.content['type']; // 'invite' | 'hangup'
+  // Klingelton abspielen, UI anzeigen
+});
+
+// ── Anruf ablehnen (während Klingeln) ────────────────────────────────────
+
+await client.sendToDevice(
+  'com.famedly.call',
+  {
+    callerId: {'*': {'call_id': callId, 'type': 'reject'}},
+  },
+);
+```
+
+---
+
+## WebRTC Setup in Flutter
+
+```dart
+// flutter_webrtc Package
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+
+// Media-Stream holen
+final stream = await navigator.mediaDevices.getUserMedia({
+  'audio': true,
+  'video': false,       // true für Video-Call
+});
+
+// PeerConnection erstellen
+final pc = await createPeerConnection({
+  'iceServers': [
+    {'urls': 'stun:stun.matrix.org:3478'},
+    // TURN-Server (für NAT-Traversal):
+    {
+      'urls': 'turn:turn.example.org:5349',
+      'username': 'user',
+      'credential': 'pass',
+    },
+  ],
+  'iceCandidatePoolSize': 10,
+});
+
+// Track hinzufügen
+for (final track in stream.getTracks()) {
+  await pc.addTrack(track, stream);
+}
+
+// ICE-Kandidaten sammeln
+pc.onIceCandidate = (RTCIceCandidate candidate) {
+  // Kandidaten via Matrix senden
+  sendIceCandidates([candidate]);
+};
+
+// Angebot erstellen
+final offer = await pc.createOffer();
+await pc.setLocalDescription(offer);
+// offer.sdp → via Matrix senden
+
+// Angebot annehmen
+await pc.setRemoteDescription(RTCSessionDescription(sdpOffer, 'offer'));
+final answer = await pc.createAnswer();
+await pc.setLocalDescription(answer);
+// answer.sdp → via Matrix senden
+
+// Eingehende Streams
+pc.onTrack = (RTCTrackEvent event) {
+  final remoteStream = event.streams.first;
+  // Widget: RTCVideoRenderer() mit remoteStream
+};
+
+// Aufräumen
+await pc.close();
+await stream.dispose();
+```
+
+---
+
+## Call-State Management
+
+```dart
+// Call-Zustand in Pyramid
+enum CallState {
+  idle,
+  calling,        // Anruf geht raus
+  ringing,        // Eingehender Anruf
+  connecting,     // ICE/SDP in Bearbeitung
+  connected,      // Verbunden
+  ended,
+}
+
+// Stummschalten
+final audioTrack = localStream.getAudioTracks().first;
+audioTrack.enabled = false; // Mute
+audioTrack.enabled = true;  // Unmute
+
+// Lautsprecher vs. Hörer (Android/iOS)
+// flutter_webrtc kümmert sich darum via Helper.setSpeakerphoneOn
+
+// DTMF (Zifferntasten)
+final sender = pc.getSenders().firstWhere(
+    (s) => s.track?.kind == 'audio');
+await sender.dtmf?.insertDTMF('1');
+
+// Screen-Sharing starten
+final screenStream = await navigator.mediaDevices.getDisplayMedia({
+  'video': true,
+  'audio': false,
+});
+final screenTrack = screenStream.getVideoTracks().first;
+final videoSender = pc.getSenders()
+    .firstWhere((s) => s.track?.kind == 'video');
+await videoSender.replaceTrack(screenTrack);
+```
+
+---
+
+## Pyramid VoIP-Architektur
+
+```
+Pyramid Call-Stack:
+┌─────────────────────────────────────────────────────┐
+│  Dart (Flutter)                                      │
+│  lib/features/call/                                  │
+│    call_notifier.dart   — Zustand, Aktionen          │
+│    call_page.dart       — UI (Kamera/Mic Controls)   │
+│    livekit_service.dart — LiveKit-Token-Tausch        │
+├─────────────────────────────────────────────────────┤
+│  Matrix SDK                                          │
+│    room.sendState(com.famedly.call.member)           │
+│    client.sendToDevice(com.famedly.call)             │
+│    client.requestOpenIdToken()                       │
+├─────────────────────────────────────────────────────┤
+│  LiveKit Client (livekit_client package)             │
+│    LiveKitClient.connect(url, token)                 │
+│    room.localParticipant.setMicrophoneEnabled()      │
+│    VideoTrackRenderer Widget                         │
+├─────────────────────────────────────────────────────┤
+│  Native (Android/iOS)                               │
+│  FlutterForegroundService — hält Call am Leben       │
+│  Klingelton via AudioManager                         │
+└─────────────────────────────────────────────────────┘
+
+TURN/STUN-Server Konfiguration (from Matrix):
+await client.getTurnServer() →
+  TurnServerCredentials(
+    username, password, ttl,
+    uris: ['turn:turn.example.org:5349?transport=udp']
+  )
+```
+
+```dart
+// TURN-Credentials vom Homeserver holen
+final turn = await client.getTurnServer();
+final iceServers = [
+  {'urls': turn.uris, 'username': turn.username, 'credential': turn.password},
+  {'urls': 'stun:stun.matrix.org:3478'},
+];
+```

docs/matrix-sdk/09-profile.md

@@ -0,0 +1,264 @@
+# 09 — Profil, Präsenz & Account-Daten
+
+---
+
+## Inhaltsverzeichnis
+- [Eigenes Profil lesen](#eigenes-profil-lesen)
+- [Profil aktualisieren](#profil-aktualisieren)
+- [Profil anderer User](#profil-anderer-user)
+- [Präsenz (Presence)](#präsenz-presence)
+- [Account-Daten (Account Data)](#account-daten-account-data)
+- [Ignorierte User](#ignorierte-user)
+- [Tags / Favoriten](#tags--favoriten)
+- [Account löschen / deaktivieren](#account-löschen--deaktivieren)
+
+---
+
+## Eigenes Profil lesen
+
+```dart
+// Aus dem Client (gecacht)
+print(client.userID);             // '@alice:server'
+print(client.displayName);        // 'Alice'
+print(client.avatarUrl);          // mxc://...
+
+// Frisch vom Server
+final profile = await client.fetchOwnProfile();
+print(profile.displayname);
+print(profile.avatarUrl);
+
+// Avatar als HTTP-URL
+final avatarHttp = client.avatarUrl?.getThumbnail(
+  client,
+  width: 128,
+  height: 128,
+  method: ThumbnailMethod.crop,
+);
+```
+
+---
+
+## Profil aktualisieren
+
+```dart
+// Displayname setzen
+await client.setDisplayName(client.userID!, 'Neuer Name');
+
+// Avatar hochladen und setzen
+final avatarBytes = await File('avatar.png').readAsBytes();
+final mxcUri = await client.uploadContent(
+  avatarBytes,
+  filename: 'avatar.png',
+  contentType: 'image/png',
+);
+await client.setAvatarUrl(client.userID!, mxcUri);
+
+// Avatar entfernen
+await client.setAvatarUrl(client.userID!, null);
+```
+
+---
+
+## Profil anderer User
+
+```dart
+// Profil via API
+final profile = await client.getProfileFromUserId('@bob:server');
+print(profile.displayname);
+print(profile.avatarUrl);
+
+// Spezifisches Feld (Matrix 1.16+ API)
+final displayname = await client.getProfileField(
+  '@bob:server',
+  'displayname',
+);
+final avatar = await client.getProfileField(
+  '@bob:server',
+  'avatar_url',
+);
+
+// User in einem Raum (schneller, gecacht)
+final user = room.unsafeGetUserFromMemoryOrFallback('@bob:server');
+print(user.displayName);
+print(user.avatarUrl);
+print(user.id);
+
+// User-Suche
+final results = await client.searchUserDirectory(
+  'alice',
+  limit: 20,
+);
+for (final user in results.results) {
+  print(user.userId);
+  print(user.displayName);
+  print(user.avatarUrl);
+}
+```
+
+---
+
+## Präsenz (Presence)
+
+```dart
+// Eigene Präsenz setzen
+await client.setPresence(
+  client.userID!,
+  PresenceType.online,           // .online | .unavailable | .offline
+  statusMsg: 'Im Meeting',       // Optionaler Status-Text
+);
+
+// Präsenz anderer User abrufen
+final presence = await client.fetchCurrentPresence('@bob:server');
+print(presence.presence);        // PresenceType
+print(presence.currentlyActive); // bool?
+print(presence.statusMsg);       // String?
+print(presence.lastActiveAgo);   // int? (Millisekunden seit letzter Aktivität)
+
+// Präsenz aus Raum-Mitglieder
+final user = room.unsafeGetUserFromMemoryOrFallback('@bob:server');
+// Präsenz wird nicht direkt im User gecacht — fetchCurrentPresence nötig
+
+// Präsenz-Anzeige im UI
+String getPresenceText(PresenceType? type, int? lastActiveAgo) {
+  switch (type) {
+    case PresenceType.online:    return 'Online';
+    case PresenceType.unavailable:
+      return 'Abwesend';
+    case PresenceType.offline:
+      if (lastActiveAgo != null) {
+        final mins = lastActiveAgo ~/ 60000;
+        if (mins < 60) return 'Vor $mins Min. aktiv';
+        final hours = mins ~/ 60;
+        if (hours < 24) return 'Vor $hours Std. aktiv';
+        return 'Vor ${hours ~/ 24} Tagen aktiv';
+      }
+      return 'Offline';
+    default: return '';
+  }
+}
+```
+
+---
+
+## Account-Daten (Account Data)
+
+```dart
+// Account-Daten sind private, servergespeicherte Einstellungen.
+// Bleiben über Geräte hinweg synchron.
+
+// Lesen
+final data = client.accountData['com.example.my_setting']?.content;
+
+// Schreiben
+await client.setAccountData(
+  client.userID!,
+  'com.example.my_setting',
+  {'key': 'value', 'enabled': true},
+);
+
+// Wichtige Standard-Account-Daten:
+// 'm.direct'              → DM-Raumliste
+// 'm.push_rules'          → Push-Regel-Overrides
+// 'm.ignored_user_list'   → Ignorierte User
+// 'm.identity_server'     → Identity-Server-URL
+// 'im.vector.setting.breadcrumbs' → FluffyChat letzte Räume
+
+// Raumspezifische Account-Daten
+await client.setRoomAccountData(
+  client.userID!,
+  '!roomId:server',
+  'm.fully_read',
+  {'event_id': eventId},
+);
+
+// Tag für Raum setzen (Favorit, Low-Priority)
+await client.setRoomTag(
+  client.userID!,
+  '!roomId:server',
+  'm.favourite',
+  TagContent(order: 0.5),
+);
+await client.setRoomTag(client.userID!, '!roomId:server', 'm.lowpriority', TagContent());
+await client.deleteRoomTag(client.userID!, '!roomId:server', 'm.favourite');
+```
+
+---
+
+## Ignorierte User
+
+```dart
+// User ignorieren
+final ignoredList = client.ignoredUsers; // List<String>
+final updated = [...ignoredList, '@spammer:server'];
+await client.setAccountData(
+  client.userID!,
+  'm.ignored_user_list',
+  {'ignored_users': Map.fromIterable(updated, value: (_) => {})},
+);
+
+// User entblockieren
+final filtered = ignoredList.where((id) => id != '@spammer:server').toList();
+await client.setAccountData(
+  client.userID!,
+  'm.ignored_user_list',
+  {'ignored_users': Map.fromIterable(filtered, value: (_) => {})},
+);
+
+// Ignorierte User abrufen
+final ignored = client.ignoredUsers; // automatisch aus Account-Data
+```
+
+---
+
+## Tags / Favoriten
+
+```dart
+// Raum als Favorit markieren
+await room.addTag('m.favourite', order: 0.1);
+
+// Raum als Low-Priority markieren
+await room.addTag('m.lowpriority');
+
+// Alle Tags eines Raums
+final tags = room.tags; // Map<String, Tag>
+final isFavourite = tags.containsKey('m.favourite');
+final isLowPriority = tags.containsKey('m.lowpriority');
+
+// Tag entfernen
+await room.removeTag('m.favourite');
+
+// Eigene Tags
+await room.addTag('com.example.myapp.tag', order: 0.5);
+
+// Räume nach Tag filtern
+final favourites = client.rooms
+    .where((r) => r.tags.containsKey('m.favourite'))
+    .toList();
+```
+
+---
+
+## Account löschen / deaktivieren
+
+```dart
+// Account deaktivieren (PERMANENT, nicht rückgängig!)
+await client.uiaRequestBackground(
+  (auth) => client.deactivateAccount(
+    auth: auth,
+    eraseData: true,     // true: alle Nachrichten löschen (soweit möglich)
+  ),
+);
+
+// Passwort ändern (braucht Re-Auth via UIAA)
+await client.uiaRequestBackground(
+  (auth) => client.changePassword(
+    'neuesPasswort',
+    auth: auth,
+    oldPassword: 'altesPasswort',
+  ),
+);
+
+// E-Mail-Adresse hinzufügen (über Identity-Server)
+// Dies ist ein mehrstufiger UIAA-Flow und erfordert E-Mail-Bestätigung.
+// Normalerweise über den Homeserver-spezifischen Registration-Flow.
+```

docs/matrix-sdk/10-room-admin.md

@@ -0,0 +1,410 @@
+# 10 — Raum-Administration & Moderation
+
+---
+
+## Inhaltsverzeichnis
+- [Power Levels vollständig](#power-levels-vollständig)
+- [Moderation: Kick, Ban, Unban](#moderation-kick-ban-unban)
+- [Server-Side Room Admin](#server-side-room-admin)
+- [Raum-Einstellungen komplett](#raum-einstellungen-komplett)
+- [Raum-Alias verwalten](#raum-alias-verwalten)
+- [Server ACL (IP-Sperren)](#server-acl-ip-sperren)
+- [Raum-Audit / State inspizieren](#raum-audit--state-inspizieren)
+- [Widgets / Bots verwalten](#widgets--bots-verwalten)
+- [Room Tombstone / Upgrade](#room-tombstone--upgrade)
+- [Reporting (Melden)](#reporting-melden)
+
+---
+
+## Power Levels vollständig
+
+```dart
+// Power Level eines Users ändern
+await room.setPower('@alice:server', 50); // 0=User, 50=Mod, 100=Admin
+
+// Alle Power Levels auf einmal setzen
+await room.client.sendState(
+  room.id,
+  EventTypes.RoomPowerLevels,
+  {
+    // Welche Power-Level für Standard-Aktionen benötigt werden:
+    'ban':              50,
+    'kick':             50,
+    'invite':           0,
+    'redact':           50,
+    'events_default':   0,    // Nachrichten senden
+    'state_default':    50,   // State-Events ändern
+
+    // Spezifische Event-Typen:
+    'events': {
+      'm.room.name':           50,
+      'm.room.topic':          50,
+      'm.room.avatar':         50,
+      'm.room.power_levels':   100,
+      'm.room.canonical_alias': 50,
+      'm.room.history_visibility': 100,
+      'm.room.encryption':     100,
+      'm.space.child':         50,
+    },
+
+    // User-Overrides:
+    'users': {
+      '@admin:server':    100,
+      '@moderator:server': 50,
+    },
+    'users_default': 0,      // Alle anderen User
+    'notifications': {
+      'room': 50,            // @room mention power level
+    },
+  },
+  stateKey: '',
+);
+
+// Power Level lesen
+final plContent = room.getState(EventTypes.RoomPowerLevels)?.content;
+final usersMap = plContent?.tryGetMap<String, dynamic>('users') ?? {};
+final adminPl = usersMap['@alice:server'] as int? ?? 0;
+
+// Berechtigungen prüfen
+room.ownPowerLevel;                               // int: eigener PL
+room.getPowerLevelByUserId('@alice:server');      // int
+room.canBan;                                      // bool
+room.canKick;                                     // bool
+room.canInvite;                                   // bool
+room.canRedactEvent(event);                       // bool
+room.canSendEvent(EventTypes.Message);            // bool
+room.canSendEvent(EventTypes.RoomName);           // bool
+room.canChangeStateEvent(EventTypes.RoomTopic);   // bool
+room.canChangeNameAndTopic;                       // bool
+room.canChangeJoinRules;                          // bool
+room.canChangeHistoryVisibility;                  // bool
+```
+
+---
+
+## Moderation: Kick, Ban, Unban
+
+```dart
+// Kick (User wird entfernt, kann wieder beitreten)
+await room.kick('@alice:server', reason: 'Verstoß gegen Regeln');
+
+// Ban (User kann nicht mehr beitreten)
+await room.ban('@alice:server', reason: 'Dauerhafter Ausschluss');
+
+// Unban
+await room.unban('@alice:server');
+
+// Alle gebannten User anzeigen
+final bannedMembers = room.getParticipants(
+  membershipFilter: [Membership.ban],
+);
+
+// Eigene Berechtigungen prüfen vor Moderation-Aktionen
+if (room.canKick) {
+  await room.kick(userId);
+}
+if (room.canBan) {
+  await room.ban(userId);
+}
+
+// User-PL prüfen (kann man diesen User kicken/bannen?)
+// Man kann nur User mit niedrigerem PL als dem eigenen moderieren.
+final theirPl = room.getPowerLevelByUserId(userId);
+final myPl    = room.ownPowerLevel;
+final canModerate = myPl > theirPl;
+```
+
+---
+
+## Server-Side Room Admin
+
+> ⚠️ **Pyramid läuft auf Continuwuity** — Synapse Admin API (`/_synapse/admin/`) **existiert nicht!**  
+> Für vollständige Continuwuity-Admin-Dokumentation: **[→ 13-server-admin-continuwuity.md](13-server-admin-continuwuity.md)**
+
+```dart
+// Server-Admin-Status prüfen (Matrix-Standard, funktioniert überall)
+final isAdmin = await client.getIsAdmin();
+
+// Für Continuwuity: Admin-Aktionen über Standard Matrix Client API
+// oder über den Admin-Room (#admins:steggi-matrix.work)
+
+// Power Level in einem Raum als Admin setzen:
+await client.setRoomStateWithKey(
+  room.id,
+  EventTypes.RoomPowerLevels,
+  '',
+  {
+    'users': {'@admin:server': 100},
+    'users_default': 0,
+    'state_default': 50,
+    'events_default': 0,
+    'ban': 50, 'kick': 50, 'invite': 0, 'redact': 50,
+  },
+);
+
+// Raum beitreten (Admin kann invite-only-Räume per API beitreten):
+await client.joinRoom(room.id);
+
+// Space-Child-Relation setzen (Channel einem Space hinzufügen):
+await client.setRoomStateWithKey(
+  spaceId,
+  EventTypes.SpaceChild,
+  channelRoomId,
+  {'via': [client.homeserver.host], 'suggested': false},
+);
+```
+
+```bash
+# Continuwuity Admin HTTP API
+# Basis: https://server/_conduwuit/admin/v1/
+
+# User zu Server-Admin machen:
+curl -X POST "https://server/_conduwuit/admin/v1/make_user_admin" \
+  -H "Authorization: Bearer TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"user_id": "@admin:server"}'
+
+# Power Level in Raum setzen (Standard Matrix API, mit Admin-Token):
+curl -X PUT "https://server/_matrix/client/v3/rooms/!roomId:server/state/m.room.power_levels/" \
+  -H "Authorization: Bearer ADMIN_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"users": {"@admin:server": 100}, "users_default": 0, "state_default": 50}'
+
+# Für Synapse (falls Server-Wechsel zu Synapse):
+# curl .../server/_synapse/admin/v1/rooms/{roomId}  ← dann wieder relevant
+```
+
+---
+
+## Raum-Einstellungen komplett
+
+```dart
+// Name
+await room.setName('Neuer Raumname');
+
+// Thema
+await room.setDescription('Neues Thema');
+
+// Avatar
+final mxcUri = await client.uploadContent(imageBytes, filename: 'avatar.png');
+await room.setAvatar(mxcUri);
+
+// Join-Rules
+await room.setJoinRules(JoinRules.invite);      // Privat
+await room.setJoinRules(JoinRules.public);      // Öffentlich
+await room.setJoinRules(JoinRules.knock);       // Beitrittsanfragen
+
+// Restricted (Nur Space-Mitglieder können beitreten)
+await room.setJoinRules(
+  JoinRules.restricted,
+  allow: [
+    SpaceRoomJoinRulesAllowInner(
+      roomId: '!spaceId:server',
+      type: SpaceRoomJoinRulesAllowInnerType.mRoomMembership,
+    ),
+  ],
+);
+
+// History-Visibility
+await room.setHistoryVisibility(HistoryVisibility.shared);
+// .shared       = alle sehen vergangene Nachrichten (nach Join)
+// .invited      = sieht Nachrichten ab dem Einladungs-Zeitpunkt
+// .joined       = sieht Nachrichten nur ab dem Beitritts-Zeitpunkt
+// .worldReadable = öffentlich lesbar (auch ohne Account)
+
+// Guest Access
+await room.setGuestAccess(GuestAccess.canJoin);   // Gäste erlaubt
+await room.setGuestAccess(GuestAccess.forbidden); // Keine Gäste
+
+// E2EE aktivieren (einmalig, nicht deaktivierbar!)
+await room.enableEncryption();
+
+// Notifications für @room: Welcher PL nötig?
+// → über Power Levels 'notifications.room' setzen
+```
+
+---
+
+## Raum-Alias verwalten
+
+```dart
+// Alias erstellen
+await client.setRoomAlias('#neuer-alias:server', room.id);
+
+// Kanonischen Alias setzen (sichtbarer Hauptalias)
+await room.client.sendState(
+  room.id,
+  EventTypes.RoomCanonicalAlias,
+  {
+    'alias': '#hauptalias:server',
+    'alt_aliases': ['#alternativ:server'],
+  },
+  stateKey: '',
+);
+
+// Alias auflösen → Raum-ID
+final resolved = await client.getRoomIdByAlias('#alias:server');
+print(resolved.roomId); // !roomId:server
+
+// Alias löschen
+await client.deleteRoomAlias('#alter-alias:server');
+
+// Alle Aliases eines Raums
+final aliases = (room.getState(EventTypes.RoomCanonicalAlias)
+    ?.content['alt_aliases'] as List?)
+    ?.cast<String>() ?? [];
+final canonical = room.canonicalAlias;
+```
+
+---
+
+## Server ACL (IP-Sperren)
+
+```dart
+// Server ACL: Welche Server dürfen am Raum teilnehmen?
+// Wichtig für öffentliche Räume um Spam-Server zu sperren.
+
+await room.client.sendState(
+  room.id,
+  'm.room.server_acl',
+  {
+    'allow': ['*'],            // Alle erlauben
+    'deny': ['spam.example.org', '*.badserver.org'],
+    'allow_ip_literals': false, // IP-Adressen als Server-Namen verboten
+  },
+  stateKey: '',
+);
+
+// ACL lesen
+final acl = room.getState('m.room.server_acl')?.content;
+final denied = (acl?['deny'] as List?)?.cast<String>() ?? [];
+```
+
+---
+
+## Raum-Audit / State inspizieren
+
+```dart
+// Alle State-Events lesen
+final states = room.states;
+// Map<EventType, Map<StateKey, StrippedStateEvent>>
+
+// Spezifischer State
+final nameEvent    = room.getState(EventTypes.RoomName);
+final topicEvent   = room.getState(EventTypes.RoomTopic);
+final memberEvent  = room.getState(EventTypes.RoomMember, '@alice:server');
+final encEvent     = room.getState(EventTypes.Encryption);
+
+// Alle Mitglieder-States
+final memberStates = states[EventTypes.RoomMember] ?? {};
+for (final entry in memberStates.entries) {
+  final mxid = entry.key;           // stateKey = MXID
+  final membership = entry.value.content['membership'];
+  print('$mxid: $membership');
+}
+
+// Raum-History vom Server laden (Admin)
+final response = await client.request(
+  RequestType.GET,
+  '/rooms/${room.id}/state',
+);
+
+// Event-Timeline abrufen (Admin)
+final timeline = await client.request(
+  RequestType.GET,
+  '/rooms/${room.id}/messages',
+  query: {'limit': '100', 'dir': 'b'},
+);
+```
+
+---
+
+## Widgets / Bots verwalten
+
+```dart
+// Widget hinzufügen (z.B. Jitsi, Etherpad)
+await room.client.sendState(
+  room.id,
+  'm.widget',
+  {
+    'type': 'jitsi',
+    'url': 'https://jitsi.example.org/#!roomId',
+    'name': 'Jitsi Call',
+    'data': {'domain': 'jitsi.example.org'},
+    'waitForIframeLoad': true,
+    'creatorUserId': client.userID,
+    'id': 'jitsi-widget',
+  },
+  stateKey: 'jitsi-widget',
+);
+
+// Widget entfernen
+await room.client.sendState(
+  room.id,
+  'm.widget',
+  {},                              // Leeres Content = entfernen
+  stateKey: 'jitsi-widget',
+);
+
+// Alle Widgets lesen
+final widgets = room.states['m.widget'] ?? {};
+for (final widget in widgets.values) {
+  print(widget.content['name']);
+  print(widget.content['url']);
+}
+```
+
+---
+
+## Room Tombstone / Upgrade
+
+```dart
+// Raum-Upgrade (Nachfolger-Raum erstellen)
+final newRoomId = await client.upgradeRoom(
+  room.id,
+  newVersion: '11',        // Aktuelle empfohlene Version
+);
+// SDK sendet m.room.tombstone in alten Raum
+// Und m.room.create mit predecessor in neuen Raum
+// Alle Mitglieder werden in neuen Raum eingeladen
+
+// Tombstone lesen
+final tombstone = room.getState(EventTypes.RoomTombstone);
+if (tombstone != null) {
+  final replacementRoomId = tombstone.content['replacement_room'] as String;
+  final serverMessage = tombstone.content['body'] as String;
+  // → Zum neuen Raum navigieren
+}
+
+// Predecessor lesen (im neuen Raum)
+final create = room.getState(EventTypes.RoomCreate);
+final predecessor = create?.content['predecessor'] as Map?;
+if (predecessor != null) {
+  final oldRoomId = predecessor['room_id'] as String;
+  final lastEventId = predecessor['event_id'] as String;
+}
+```
+
+---
+
+## Reporting (Melden)
+
+```dart
+// Event melden (z.B. Spam, illegaler Inhalt)
+await client.reportContent(
+  room.id,
+  event.eventId,
+  reason: 'Spam/Belästigung',
+  score: -100,              // -100 = sehr schlimm, 0 = nicht schlimm
+);
+
+// User melden (via MSC4151, wenn vom Server unterstützt)
+await client.httpClient.post(
+  Uri.parse('${client.homeserver}/_matrix/client/v3/report/${Uri.encodeComponent("@user:server")}'),
+  headers: {
+    'Authorization': 'Bearer ${client.accessToken}',
+    'Content-Type': 'application/json',
+  },
+  body: jsonEncode({'reason': 'Belästigung'}),
+);
+```

docs/matrix-sdk/11-search.md

@@ -0,0 +1,238 @@
+# 11 — Suche & Discovery
+
+---
+
+## Inhaltsverzeichnis
+- [Nachrichten in einem Raum suchen](#nachrichten-in-einem-raum-suchen)
+- [Globale Nachrichten-Suche](#globale-nachrichten-suche)
+- [User-Suche](#user-suche)
+- [Öffentliches Raumverzeichnis](#öffentliches-raumverzeichnis)
+- [Matrix-URI auflösen](#matrix-uri-auflösen)
+- [Raum per Alias finden](#raum-per-alias-finden)
+
+---
+
+## Nachrichten in einem Raum suchen
+
+```dart
+// In der lokalen Timeline suchen (gecacht)
+final found = timeline.events
+    .where((e) =>
+        e.type == EventTypes.Message &&
+        e.body.toLowerCase().contains(query.toLowerCase()))
+    .toList();
+
+// Auf dem Server suchen (Matrix-Suchendpoint)
+final result = await client.searchEvents(
+  Categories(
+    roomEvents: RoomEventsCriteria(
+      searchTerm: 'suchbegriff',
+      roomId: room.id,           // optional: nur in einem Raum
+      orderBy: SearchOrder.recent, // oder .rank
+      keys: [SearchKey.contentBody], // oder .contentName, .contentTopic
+      filter: RoomEventFilter(
+        limit: 20,
+        rooms: [room.id],
+        notRooms: [],
+      ),
+    ),
+  ),
+);
+
+// Ergebnisse
+for (final result in result.roomEvents?.results ?? []) {
+  print(result.result.body);
+  print(result.result.originServerTs);
+  print(result.result.senderId);
+}
+
+// Paginierung
+final nextToken = result.roomEvents?.nextBatch;
+if (nextToken != null) {
+  final more = await client.searchEvents(
+    /* gleiche Criteria */,
+    nextBatch: nextToken,
+  );
+}
+```
+
+---
+
+## Globale Nachrichten-Suche
+
+```dart
+// Über alle Räume suchen
+final result = await client.searchEvents(
+  Categories(
+    roomEvents: RoomEventsCriteria(
+      searchTerm: 'flutter matrix',
+      orderBy: SearchOrder.recent,
+      includeState: false,
+      groupings: Groupings(
+        groupBy: [Group(key: GroupKey.roomId)], // Gruppiert nach Raum
+      ),
+    ),
+  ),
+);
+
+// Gruppen-Ergebnisse
+for (final entry in result.roomEvents?.groups?.entries ?? []) {
+  final groupKey = entry.key; // 'room_id'
+  for (final roomGroup in entry.value.entries) {
+    final roomId = roomGroup.key;
+    print('Treffer in $roomId: ${roomGroup.value.count}');
+    // roomGroup.value.results: List<String> (Event-IDs)
+  }
+}
+```
+
+---
+
+## User-Suche
+
+```dart
+// User-Verzeichnis durchsuchen
+final response = await client.searchUserDirectory(
+  'alice',                       // Suchbegriff (Name oder MXID)
+  limit: 20,
+);
+
+for (final user in response.results) {
+  print(user.userId);            // @alice:server
+  print(user.displayName);       // Alice
+  print(user.avatarUrl);         // mxc://...
+
+  // Avatar als HTTP-URL
+  final avatarHttp = user.avatarUrl?.getThumbnail(
+    client,
+    width: 56,
+    height: 56,
+    method: ThumbnailMethod.crop,
+  );
+}
+
+print(response.limited);        // true wenn weitere Ergebnisse vorhanden
+
+// MXID direkt laden (ohne Suche)
+final profile = await client.getProfileFromUserId('@alice:server');
+print(profile.displayname);
+print(profile.avatarUrl);
+```
+
+---
+
+## Öffentliches Raumverzeichnis
+
+```dart
+// Öffentliche Räume (des eigenen Servers)
+final result = await client.queryPublicRooms(
+  limit: 50,
+);
+
+// Mit Suchbegriff
+final searched = await client.queryPublicRooms(
+  limit: 20,
+  filter: PublicRoomQueryFilter(
+    genericSearchTerm: 'flutter',
+  ),
+);
+
+// Anderen Server durchsuchen
+final remote = await client.queryPublicRooms(
+  server: 'matrix.org',
+  limit: 20,
+  filter: PublicRoomQueryFilter(genericSearchTerm: 'linux'),
+);
+
+// Paginierung
+var batch = await client.queryPublicRooms(limit: 50);
+while (batch.nextBatch != null) {
+  batch = await client.queryPublicRooms(
+    limit: 50,
+    since: batch.nextBatch,
+  );
+}
+
+// Einzelnes Ergebnis
+for (final room in result.chunk) {
+  print(room.roomId);
+  print(room.name);
+  print(room.topic);
+  print(room.numJoinedMembers);
+  print(room.worldReadable);
+  print(room.guestCanJoin);
+  print(room.avatarUrl);
+  print(room.canonicalAlias);
+  print(room.joinRule);          // 'public' | 'knock' | etc.
+  print(room.roomType);          // 'm.space' | null
+}
+```
+
+---
+
+## Matrix-URI auflösen
+
+```dart
+// Matrix-to URI parsen
+// https://matrix.to/#/@alice:server
+// https://matrix.to/#/!roomId:server
+// https://matrix.to/#/#alias:server
+// matrix:u/alice:server
+// matrix:r/alias:server
+// matrix:roomid/roomId:server
+
+import 'package:matrix/matrix.dart';
+
+final uri = MatrixUri.parse('https://matrix.to/#/#kanal:example.org');
+if (uri != null) {
+  switch (uri.primaryType) {
+    case MatrixUriType.room:     // Raum-Alias
+    case MatrixUriType.roomId:   // Raum-ID
+    case MatrixUriType.user:     // User-MXID
+    case MatrixUriType.event:    // Event-Link
+  }
+
+  final identifier = uri.primaryIdentifier;
+  // z.B. '#kanal:example.org' oder '!roomId:server'
+
+  // Beitreten (bei Raum)
+  if (uri.primaryType == MatrixUriType.room ||
+      uri.primaryType == MatrixUriType.roomId) {
+    await client.joinRoomOrAlias(
+      identifier,
+      serverName: uri.viaServers, // föderierte Server
+    );
+  }
+}
+
+// Matrix-URI generieren
+final roomUri = MatrixUri(
+  primaryType: MatrixUriType.roomId,
+  primaryIdentifier: room.id,
+  viaServers: ['example.org'],
+).toUri().toString();
+// → matrix:roomid/roomId:server?via=example.org
+
+// Matrix.to Link generieren
+final matrixToLink = 'https://matrix.to/#/${Uri.encodeComponent(room.canonicalAlias ?? room.id)}';
+```
+
+---
+
+## Raum per Alias finden
+
+```dart
+// Alias → Raum-ID auflösen
+final result = await client.getRoomIdByAlias('#alias:server');
+print(result.roomId);
+print(result.servers); // Via-Server für Beitritt
+
+// Direkt beitreten via Alias
+await client.joinRoomOrAlias('#alias:server');
+
+// Lokal prüfen (gecacht)
+final localRoom = client.rooms.firstWhere(
+  (r) => r.canonicalAlias == '#alias:server',
+  orElse: () => throw Exception('Nicht gefunden'),
+);
+```

docs/matrix-sdk/12-quick-reference.md

@@ -0,0 +1,366 @@
+# 12 — Schnellreferenz: Typen, Konstanten & Patterns
+
+---
+
+## Wichtige Enum-Werte
+
+```dart
+// Membership
+Membership.join      // Mitglied
+Membership.invite    // Eingeladen
+Membership.leave     // Verlassen
+Membership.ban       // Gesperrt
+Membership.knock     // Klopf-Anfrage
+
+// JoinRules
+JoinRules.public     // Offen
+JoinRules.invite     // Nur per Einladung
+JoinRules.knock      // Beitrittsanfragen erlaubt
+JoinRules.restricted // Nur Mitglieder bestimmter Spaces/Räume
+JoinRules.knockRestricted
+
+// HistoryVisibility
+HistoryVisibility.worldReadable // Ohne Login lesbar
+HistoryVisibility.shared        // Alle Mitglieder sehen History
+HistoryVisibility.invited       // Ab Einladungszeitpunkt
+HistoryVisibility.joined        // Ab Beitrittszeitpunkt
+
+// GuestAccess
+GuestAccess.canJoin    // Gäste erlaubt
+GuestAccess.forbidden  // Keine Gäste
+
+// Visibility
+Visibility.public      // Im Verzeichnis
+Visibility.private     // Nicht im Verzeichnis
+
+// CreateRoomPreset
+CreateRoomPreset.privateChat        // invite + joined History
+CreateRoomPreset.publicChat         // public + shared History
+CreateRoomPreset.trustedPrivateChat // wie private + alle Mitglieder sind Admins
+
+// EventStatus
+EventStatus.sending  // Wird übertragen
+EventStatus.sent     // Server-ACK
+EventStatus.synced   // Im Sync empfangen
+EventStatus.error    // Fehlgeschlagen
+EventStatus.removed  // Gelöscht
+
+// PresenceType
+PresenceType.online
+PresenceType.unavailable
+PresenceType.offline
+
+// ThumbnailMethod
+ThumbnailMethod.crop   // Ausschneiden auf exakte Größe
+ThumbnailMethod.scale  // Skalieren ohne Abschneiden
+
+// LoginType
+LoginType.mLoginPassword
+LoginType.mLoginToken
+LoginType.mLoginSso
+
+// PushRuleKind
+PushRuleKind.override
+PushRuleKind.content
+PushRuleKind.room
+PushRuleKind.sender
+PushRuleKind.underride
+```
+
+---
+
+## EventTypes Konstanten
+
+```dart
+EventTypes.Message             // m.room.message
+EventTypes.Sticker             // m.sticker
+EventTypes.Reaction            // m.reaction
+EventTypes.RoomRedaction       // m.room.redaction
+EventTypes.Encrypted           // m.room.encrypted
+EventTypes.RoomCreate          // m.room.create
+EventTypes.RoomName            // m.room.name
+EventTypes.RoomTopic           // m.room.topic
+EventTypes.RoomAvatar          // m.room.avatar
+EventTypes.RoomMember          // m.room.member
+EventTypes.RoomPowerLevels     // m.room.power_levels
+EventTypes.RoomCanonicalAlias  // m.room.canonical_alias
+EventTypes.RoomJoinRules       // m.room.join_rules
+EventTypes.RoomGuestAccess     // m.room.guest_access
+EventTypes.HistoryVisibility   // m.room.history_visibility
+EventTypes.RoomPinnedEvents    // m.room.pinned_events
+EventTypes.RoomTombstone       // m.room.tombstone
+EventTypes.Encryption          // m.room.encryption
+EventTypes.SpaceChild          // m.space.child
+EventTypes.SpaceParent         // m.space.parent
+EventTypes.CallInvite          // m.call.invite
+EventTypes.CallAnswer          // m.call.answer
+EventTypes.CallHangup          // m.call.hangup
+EventTypes.CallCandidates      // m.call.candidates
+EventTypes.CallReject          // m.call.reject
+EventTypes.CallSelectAnswer    // m.call.select_answer
+EventTypes.CallNegotiate       // m.call.negotiate
+```
+
+---
+
+## Häufige Content-Zugriffe
+
+```dart
+// Sicher auf Map-Inhalte zugreifen (Matrix SDK Extension)
+final text = event.content.tryGet<String>('body');
+final map  = event.content.tryGetMap<String, dynamic>('info');
+final list = event.content.tryGetList<String>('aliases');
+
+// Event-Inhalt strukturiert
+final msgtype   = event.content['msgtype'] as String?;
+final body      = event.content['body']    as String?;
+final formatted = event.content['formatted_body'] as String?;
+final format    = event.content['format'] as String?; // 'org.matrix.custom.html'
+
+// Relation
+final relatesTo = event.content
+    .tryGetMap<String, dynamic>('m.relates_to');
+final relType   = relatesTo?.tryGet<String>('rel_type');
+final eventId   = relatesTo?.tryGet<String>('event_id');
+
+// Verschlüsselte Medien
+final file = event.content.tryGetMap<String, dynamic>('file');
+final url  = file?.tryGet<String>('url');  // mxc://
+final key  = file?.tryGetMap<String, dynamic>('key');
+
+// Mentions (MSC3952)
+final mentions    = event.content.tryGetMap<String, dynamic>('m.mentions');
+final userIds     = mentions?.tryGetList<String>('user_ids') ?? [];
+final roomMention = mentions?.tryGet<bool>('room') ?? false;
+```
+
+---
+
+## Timeline-Widget Pattern (Flutter)
+
+```dart
+class ChatView extends ConsumerStatefulWidget {
+  final String roomId;
+  const ChatView({required this.roomId, super.key});
+  @override
+  ConsumerState<ChatView> createState() => _ChatViewState();
+}
+
+class _ChatViewState extends ConsumerState<ChatView> {
+  Timeline? _timeline;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadTimeline();
+  }
+
+  Future<void> _loadTimeline() async {
+    final client = await ref.read(matrixClientProvider.future);
+    final room = client.getRoomById(widget.roomId)!;
+    _timeline = await room.getTimeline(
+      onUpdate: () => setState(() {}),
+    );
+    setState(() {});
+  }
+
+  @override
+  void dispose() {
+    _timeline?.cancelSubscriptions(); // WICHTIG!
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final events = _timeline?.events ?? [];
+    return ListView.builder(
+      reverse: true,                   // Neueste unten
+      itemCount: events.length,
+      itemBuilder: (ctx, i) {
+        final event = events[i];
+        if (event.type != EventTypes.Message) return const SizedBox();
+        return ListTile(
+          title: Text(event.body),
+          subtitle: Text(event.senderId),
+        );
+      },
+    );
+  }
+}
+```
+
+---
+
+## Raum-Liste Widget Pattern
+
+```dart
+// StreamProvider für reaktive Raumliste
+final roomsProvider = StreamProvider<List<Room>>((ref) async* {
+  final client = await ref.watch(matrixClientProvider.future);
+  yield _sortedRooms(client);
+  await for (final _ in client.onSync.stream) {
+    yield _sortedRooms(client);
+  }
+});
+
+List<Room> _sortedRooms(Client client) => client.rooms
+  .where((r) => r.membership == Membership.join)
+  .toList()
+  ..sort((a, b) =>
+      (b.lastEvent?.originServerTs ?? DateTime(0))
+          .compareTo(a.lastEvent?.originServerTs ?? DateTime(0)));
+
+// In Widget:
+final rooms = ref.watch(roomsProvider);
+rooms.when(
+  data: (list) => ListView.builder(
+    itemCount: list.length,
+    itemBuilder: (ctx, i) {
+      final room = list[i];
+      return ListTile(
+        leading: CircleAvatar(child: Text(room.name[0])),
+        title: Text(room.getLocalizedDisplayname()),
+        subtitle: Text(room.lastEvent?.body ?? ''),
+        trailing: room.notificationCount > 0
+            ? Badge(label: Text('${room.notificationCount}'))
+            : null,
+      );
+    },
+  ),
+  loading: () => const CircularProgressIndicator(),
+  error: (e, s) => Text('Fehler: $e'),
+);
+```
+
+---
+
+## Nachrichten senden mit optimistischem UI
+
+```dart
+// Das SDK fügt das Event sofort mit Status 'sending' in die Timeline ein.
+// UI kann es sofort anzeigen, ohne auf Server zu warten.
+
+class MessageInput extends ConsumerWidget {
+  final Room room;
+  const MessageInput({required this.room, super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final controller = TextEditingController();
+    return Row(
+      children: [
+        Expanded(child: TextField(controller: controller)),
+        IconButton(
+          icon: const Icon(Icons.send),
+          onPressed: () async {
+            final text = controller.text.trim();
+            if (text.isEmpty) return;
+            controller.clear();
+            try {
+              await room.sendTextEvent(text);
+            } catch (e) {
+              // Event bleibt mit Status 'error' in Timeline
+              // User kann auf "Erneut senden" tippen
+            }
+          },
+        ),
+      ],
+    );
+  }
+}
+```
+
+---
+
+## Nützliche Client-Extensions & Helpers
+
+```dart
+// User-Erwähnung formatieren
+'@${userId.split(':').first.replaceFirst('@', '')}' // kurzform ohne Server
+
+// Raum-Display-Name (FluffyChat-Stil)
+// Für DMs: Name des Gegenübers
+// Für Räume mit Name: Name
+// Für Räume ohne Name: kommagetrennte Mitgliedernamen
+room.getLocalizedDisplayname()
+
+// Avatar-URL sicher holen
+user.avatarUrl?.getThumbnail(client, width: 56, height: 56)
+
+// Event-Zeitstempel formatieren
+event.originServerTs.toLocal().toString()
+// oder mit intl:
+DateFormat.Hm().format(event.originServerTs.toLocal())
+
+// Stable Notification-ID aus Raum-ID (deterministisch)
+int stableId(String roomId) {
+  var h = 0;
+  for (final c in roomId.codeUnits) {
+    h = ((h * 31) + c) & 0x7FFFFFFF;
+  }
+  return h == 0 ? 1 : h;
+}
+
+// Matrix-Größenangabe
+// event.sizeString → '2.3 MB', '512 KB'
+
+// mxc:// URI in HTTP umwandeln
+mxcUri.getDownloadUri(client)
+mxcUri.getThumbnail(client, width: 300, height: 300)
+```
+
+---
+
+## Fehler-Handling
+
+```dart
+// MatrixException — Fehler vom Server
+try {
+  await client.joinRoom('!room:server');
+} on MatrixException catch (e) {
+  switch (e.error) {
+    case MatrixError.M_FORBIDDEN:       // Kein Zugang
+    case MatrixError.M_NOT_FOUND:       // Raum existiert nicht
+    case MatrixError.M_LIMIT_EXCEEDED:  // Rate-Limit
+      final retryAfter = e.retryAfterMs; // Wann wieder versuchen
+    case MatrixError.M_UNKNOWN:
+    default:
+      print(e.errorMessage);
+  }
+}
+
+// TimeoutException — Keine Antwort vom Server
+// SocketException — Keine Netzwerkverbindung
+// FormatException — Ungültige Server-Antwort
+
+// Verbindungsstatus überwachen
+client.onConnectionStateChanged.stream.listen((state) {
+  switch (state) {
+    case ConnectionState.connected:    // Sync läuft
+    case ConnectionState.connecting:   // Verbindet
+    case ConnectionState.reconnecting: // Verbindung wiederhergestellt
+  }
+});
+```
+
+---
+
+## Wichtige Pakete für Pyramid
+
+```yaml
+dependencies:
+  matrix: ^6.x.x              # Matrix SDK (Haupt-SDK)
+  flutter_vodozemac: ^x.x.x   # E2EE (Rust-basiert, empfohlen)
+  firebase_messaging: ^x.x.x  # FCM Push (Android)
+  firebase_core: ^x.x.x
+  flutter_local_notifications: ^x.x.x  # Lokale Notifications
+  flutter_riverpod: ^x.x.x    # State Management
+  sqflite: ^x.x.x             # Datenbank
+  path_provider: ^x.x.x       # App-Verzeichnisse
+  shared_preferences: ^x.x.x  # Einfache KV-Speicherung
+  livekit_client: ^x.x.x      # LiveKit für VoIP
+  flutter_webrtc: ^x.x.x      # WebRTC
+  go_router: ^x.x.x           # Navigation
+  local_notifier: ^x.x.x      # Windows Notifications
+  windows_taskbar: ^x.x.x     # Windows Badge
+```

docs/matrix-sdk/13-server-admin-continuwuity.md

@@ -0,0 +1,437 @@
+# 13 — Server-Administration: Continuwuity
+
+> **Gilt für:** Continuwuity 0.5.x (Fork von Conduwuit, welches ein Fork von Conduit ist)  
+> **Homeserver:** `steggi-matrix.work`  
+> **WICHTIG:** Continuwuity hat KEINE Synapse Admin API (`/_synapse/admin/` existiert nicht!)
+
+---
+
+## Inhaltsverzeichnis
+- [Server-Admin vs. Room Power Level](#server-admin-vs-room-power-level)
+- [Admin Room — Befehle](#admin-room--befehle)
+- [Continuwuity Admin HTTP API](#continuwuity-admin-http-api)
+- [Power Level in Räumen erzwingen (als Server-Admin)](#power-level-in-räumen-erzwingen)
+- [MSC3083: Restricted Join Rules auf Continuwuity](#msc3083-restricted-join-rules-auf-continuwuity)
+- [Diagnose: Warum M_FORBIDDEN?](#diagnose-warum-m_forbidden)
+- [User-Admin-Status prüfen/setzen](#user-admin-status-prüfensetzen)
+- [Raum-Administration via Matrix API](#raum-administration-via-matrix-api)
+- [Wichtige Unterschiede: Continuwuity vs. Synapse](#wichtige-unterschiede-continuwuity-vs-synapse)
+- [Continuwuity `homeserver.yaml` — relevante Einstellungen](#continuwuity-homeserveryaml--relevante-einstellungen)
+
+---
+
+## Server-Admin vs. Room Power Level
+
+```
+Continuwuity Server-Admin
+├── Ermöglicht: Admin-Room-Befehle, Server-API
+├── Ermöglicht: User deaktivieren, Räume löschen (Server-Level)
+└── NICHT: Automatisch PL 100 in jedem Matrix-Raum!
+
+Matrix Room Power Level 100
+├── Gilt pro Raum (in m.room.power_levels State-Event gespeichert)
+├── Ermöglicht: Name/Topic/Avatar setzen, Join-Rules ändern, User kicken/bannen
+└── Unabhängig vom Server-Admin-Status
+```
+
+**Beispiel-Problem:**
+- Du bist Server-Admin auf `steggi-matrix.work` ✅
+- Du hast PL 100 im Space `!xyz:steggi-matrix.work` ✅
+- Du erstellst einen neuen Channel → Server gibt dir PL 100 als Ersteller ✅
+- Du versuchst `join_rules: restricted` zu setzen → M_FORBIDDEN ❌
+  - **Grund:** Continuwuity 0.5.x unterstützt MSC3083 möglicherweise nicht vollständig
+
+---
+
+## Admin Room — Befehle
+
+Continuwuity hat einen speziellen Admin-Raum. Als Server-Admin kannst du dort Befehle eingeben:
+
+```
+# Admin-Raum beitreten (normalerweise automatisch eingeladen)
+# Raum-Alias: #admins:steggi-matrix.work
+
+# Befehle im Admin-Raum (als Nachricht senden):
+
+!admin help                              # Alle Befehle anzeigen
+
+!admin make_user_admin @user:server      # User zu Server-Admin machen
+!admin deactivate_user @user:server      # User deaktivieren
+!admin list_users                        # Alle User auflisten
+
+!admin get_room_state !roomId:server     # Room-State anzeigen
+!admin delete_room !roomId:server        # Raum löschen
+
+!admin get_mem_usage                     # Server-Speicherverbrauch
+!admin server_version                    # Server-Version
+```
+
+```bash
+# Als curl (Admin-Token erforderlich):
+# Admin-Room-ID herausfinden:
+curl -s "https://steggi-matrix.work/_matrix/client/v3/directory/room/%23admins%3Asteggi-matrix.work" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+# → {"room_id": "!adminRoomId:steggi-matrix.work", ...}
+```
+
+---
+
+## Continuwuity Admin HTTP API
+
+```bash
+# Basis-URL: https://steggi-matrix.work/_conduwuit/admin/v1/
+# (Nicht /_synapse/admin/ — das ist Synapse-only!)
+
+# User zu Server-Admin machen
+curl -X POST "https://steggi-matrix.work/_conduwuit/admin/v1/make_user_admin" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"user_id": "@todesneutron:steggi-matrix.work"}'
+
+# Server-Status abfragen
+curl "https://steggi-matrix.work/_conduwuit/server/version" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# Alternativ — Standard Matrix-Whoami (prüft ob Token gültig):
+curl "https://steggi-matrix.work/_matrix/client/v3/account/whoami" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+# → {"user_id": "@todesneutron:steggi-matrix.work", "is_guest": false}
+
+# Prüfen ob User Server-Admin ist (Conduwuit-spezifisch):
+curl "https://steggi-matrix.work/_conduwuit/admin/v1/users/@todesneutron:steggi-matrix.work" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+```
+
+---
+
+## Power Level in Räumen erzwingen (als Server-Admin)
+
+Als Server-Admin kannst du via Matrix Client API Power Levels in jedem Raum setzen,
+**auch wenn du kein Mitglied bist** (Continuwuity erlaubt das für Server-Admins):
+
+```bash
+# Schritt 1: Aktuelles Power-Level-Event lesen
+ROOM_ID="!raumId:steggi-matrix.work"
+TOKEN="<ADMIN_TOKEN>"
+SERVER="https://steggi-matrix.work"
+
+curl "${SERVER}/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.power_levels/" \
+  -H "Authorization: Bearer ${TOKEN}"
+
+# Schritt 2: Power Level setzen (users-Map ändern)
+curl -X PUT "${SERVER}/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.power_levels/" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "users": {
+      "@todesneutron:steggi-matrix.work": 100
+    },
+    "users_default": 0,
+    "events_default": 0,
+    "state_default": 50,
+    "ban": 50,
+    "kick": 50,
+    "invite": 0,
+    "redact": 50
+  }'
+```
+
+```dart
+// In Flutter / Dart (mit Admin-Token):
+// Zuerst aktuellen PL-State lesen:
+final currentPl = await client.getRoomStateWithKey(
+  roomId,
+  EventTypes.RoomPowerLevels,
+  '',
+);
+
+// Users-Map erweitern und zurückschreiben:
+final users = Map<String, dynamic>.from(
+  (currentPl['users'] as Map?)?.cast<String, dynamic>() ?? {},
+);
+users['@todesneutron:steggi-matrix.work'] = 100;
+
+await client.setRoomStateWithKey(
+  roomId,
+  EventTypes.RoomPowerLevels,
+  '',
+  {
+    ...currentPl,
+    'users': users,
+  },
+);
+```
+
+---
+
+## MSC3083: Restricted Join Rules auf Continuwuity
+
+`join_rules: restricted` (MSC3083) erlaubt Räumen, nur Space-Mitglieder beizutreten.
+**Continuwuity 0.5.x unterstützt MSC3083 möglicherweise nicht vollständig.**
+
+```bash
+# Testen ob restricted join rules funktionieren:
+ROOM_ID="!testRaum:steggi-matrix.work"
+TOKEN="<ADMIN_TOKEN>"
+SPACE_ID="!spaceId:steggi-matrix.work"
+
+curl -X PUT "https://steggi-matrix.work/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.join_rules/" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "join_rule": "restricted",
+    "allow": [
+      {
+        "type": "m.room_membership",
+        "room_id": "'"${SPACE_ID}"'"
+      }
+    ]
+  }'
+# → 200 OK: Unterstützt!
+# → M_FORBIDDEN oder M_UNRECOGNIZED: Nicht unterstützt oder PL zu niedrig
+```
+
+**Workaround wenn restricted nicht funktioniert:**
+```bash
+# Fallback: invite-only (explizit jeden User einladen)
+curl -X PUT "https://steggi-matrix.work/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.join_rules/" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{"join_rule": "invite"}'
+```
+
+```dart
+// In space_admin_dialog.dart — Fallback wenn restricted nicht supported:
+try {
+  await room.setJoinRules(
+    JoinRules.restricted,
+    allow: [
+      SpaceRoomJoinRulesAllowInner(
+        roomId: spaceId,
+        type: SpaceRoomJoinRulesAllowInnerType.mRoomMembership,
+      ),
+    ],
+  );
+} on MatrixException catch (e) {
+  if (e.error == MatrixError.M_FORBIDDEN || e.error == MatrixError.M_UNKNOWN) {
+    // Continuwuity unterstützt restricted join rules nicht
+    // Fallback zu invite-only:
+    await room.setJoinRules(JoinRules.invite);
+  } else {
+    rethrow;
+  }
+}
+```
+
+---
+
+## Diagnose: Warum M_FORBIDDEN?
+
+```bash
+# 1. Prüfen: Welchen Power Level hat mein User in diesem Raum?
+ROOM_ID="!raumId:steggi-matrix.work"
+TOKEN="<ADMIN_TOKEN>"
+
+curl "https://steggi-matrix.work/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.power_levels/" \
+  -H "Authorization: Bearer ${TOKEN}"
+# Antwort zeigt 'users' Map — prüfen ob '@todesneutron:steggi-matrix.work' drin ist
+
+# 2. Prüfen: Was ist state_default?
+# Im Antwort-JSON: "state_default": 50 bedeutet: PL 50 nötig für State-Events
+# "m.room.join_rules": 100 in events-Map = PL 100 für Join-Rule-Änderung
+
+# 3. Prüfen: Bin ich Mitglied des Raums?
+curl "https://steggi-matrix.work/_matrix/client/v3/rooms/${ROOM_ID}/state/m.room.member/%40todesneutron%3Asteggi-matrix.work/" \
+  -H "Authorization: Bearer ${TOKEN}"
+# → {"membership": "join"} = Mitglied ✅
+# → {"errcode": "M_NOT_FOUND"} = Nicht Mitglied ❌ (Server-Admin kann trotzdem State setzen)
+
+# 4. Prüfen: Unterstützt der Server restricted join rules?
+curl "https://steggi-matrix.work/_matrix/client/v3/capabilities" \
+  -H "Authorization: Bearer ${TOKEN}"
+# Antwort: capabilities-Objekt — MSC3083 ist nicht explizit gelistet (kein Standard-Capability)
+```
+
+**Häufige Ursachen und Lösungen:**
+
+| Fehler | Ursache | Lösung |
+|---|---|---|
+| M_FORBIDDEN beim State-Event | PL zu niedrig im Raum | Power Level via curl erhöhen (s.o.) |
+| M_FORBIDDEN bei join_rules: restricted | MSC3083 nicht unterstützt | Fallback zu `invite` nutzen |
+| M_FORBIDDEN beim Channel erstellen | Bug in space_admin_dialog.dart | Raum manuell erstellen, dann Space-Child setzen |
+| M_NOT_FOUND | Raum nicht bekannt | Raum beitreten oder Admin-Join |
+| M_FORBIDDEN bei Power-Level-Änderung | PL darf nur gleich/höher gesetzt werden | Als Ersteller oder via Admin-API |
+
+---
+
+## User-Admin-Status prüfen/setzen
+
+```bash
+# Prüfen ob User Server-Admin ist:
+curl "https://steggi-matrix.work/_matrix/client/v3/account/whoami" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# Auf Pi (SSH): User-Datenbank direkt abfragen (Conduwuit/Continuwuity nutzt RocksDB)
+# Alternativ: Über Admin-Room-Befehl
+# (Im Admin-Room als Nachricht senden:)
+# !admin make_user_admin @todesneutron:steggi-matrix.work
+
+# Über HTTP (Conduwuit Admin-Endpoint):
+curl -X POST "https://steggi-matrix.work/_conduwuit/admin/v1/make_user_admin" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"user_id": "@todesneutron:steggi-matrix.work"}'
+```
+
+---
+
+## Raum-Administration via Matrix API
+
+Da kein Synapse-Admin-API existiert, nutze die Standard-Matrix-Client-API mit Admin-Token:
+
+```bash
+# Raum beitreten (als Admin, auch wenn invite-only):
+curl -X POST "https://steggi-matrix.work/_matrix/client/v3/join/!roomId%3Asteggi-matrix.work" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{}'
+
+# User in Raum einladen:
+curl -X POST "https://steggi-matrix.work/_matrix/client/v3/rooms/!roomId%3Asteggi-matrix.work/invite" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"user_id": "@user:steggi-matrix.work"}'
+
+# Space-Child-Relation setzen (Channel einem Space hinzufügen):
+curl -X PUT "https://steggi-matrix.work/_matrix/client/v3/rooms/!spaceId%3Asteggi-matrix.work/state/m.space.child/!channelId%3Asteggi-matrix.work/" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "via": ["steggi-matrix.work"],
+    "suggested": false
+  }'
+
+# Space-Parent-Relation setzen (im Channel-Raum):
+curl -X PUT "https://steggi-matrix.work/_matrix/client/v3/rooms/!channelId%3Asteggi-matrix.work/state/m.space.parent/!spaceId%3Asteggi-matrix.work/" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "via": ["steggi-matrix.work"],
+    "canonical": true
+  }'
+
+# Alle Mitglieder eines Raums auflisten:
+curl "https://steggi-matrix.work/_matrix/client/v3/rooms/!roomId%3Asteggi-matrix.work/members" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# Raum verlassen (als User, nicht löschen):
+curl -X POST "https://steggi-matrix.work/_matrix/client/v3/rooms/!roomId%3Asteggi-matrix.work/leave" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+
+---
+
+## Wichtige Unterschiede: Continuwuity vs. Synapse
+
+| Feature | Synapse | Continuwuity 0.5.x |
+|---|---|---|
+| Admin API URL | `/_synapse/admin/v1/` | `/_conduwuit/admin/v1/` |
+| Admin Room | Optional | Standard |
+| MSC3083 (restricted join rules) | ✅ Vollständig | ⚠️ Teilweise / experimentell |
+| Spaces (MSC1772) | ✅ | ✅ Grundfunktionen |
+| MatrixRTC / MSC3401 | ✅ (Element Call) | ⚠️ Eingeschränkt |
+| Push-Gateway | ✅ | ✅ |
+| Server-side search | ✅ | ✅ Grundfunktionen |
+| E2EE / Cross-Signing | ✅ | ✅ |
+| Presence | ✅ | ✅ |
+| Account Deactivation | Admin API | Admin Room / API |
+| Room Deletion/Purge | Admin API | Admin Room / API |
+| User Listing | Admin API | Admin Room / API |
+| Federation | ✅ | ✅ |
+| Application Services | ✅ | ⚠️ Eingeschränkt |
+
+---
+
+## Continuwuity `homeserver.yaml` — relevante Einstellungen
+
+```yaml
+# /etc/continuwuity/homeserver.yaml (oder /etc/conduwuit/conduwuit.toml je nach Version)
+
+# Matrix-RTC / LiveKit
+# MSC3266: Room Summary
+# MSC3401: MatrixRTC
+allow_unstable_room_versions: true
+
+# Federation (für Multi-Server-Calls nötig)
+allow_federation: true
+allow_public_room_directory_without_auth: false
+
+# Push (für Notifications)
+# Kein spezieller Config — nutzt Standard-Matrix-Push-API
+
+# TURN-Server für WebRTC
+turn_uris:
+  - "turn:steggi-matrix.work:3478?transport=udp"
+  - "turn:steggi-matrix.work:3478?transport=tcp"
+turn_secret: "dein-turn-secret"
+turn_username: ""  # leer = HMAC-basiert
+turn_password: ""
+turn_ttl: 86400
+
+# Registrierung
+allow_registration: false  # Kein offener Signup
+registration_token: "dein-token"  # Oder token-basiert
+
+# Log-Level
+log: "warn,conduwuit=info"
+
+# Performance
+rocksdb_parallelism_threads: 4  # Pi 5 hat 4 Cores
+
+# Unter Continuwuity: Admin-User beim ersten Start setzen
+# Erster registrierter User wird automatisch Server-Admin
+```
+
+```bash
+# Auf dem Pi: Config-Datei editieren
+ssh steggi@192.168.178.71
+sudo nano /etc/continuwuity/homeserver.yaml
+# oder:
+sudo nano /etc/conduwuit/conduwuit.toml  # Falls TOML-Format
+
+# Service neu starten:
+sudo systemctl restart continuwuity
+# oder:
+sudo systemctl restart conduwuit
+
+# Logs prüfen:
+sudo journalctl -u continuwuity -f
+```
+
+---
+
+## Schnell-Diagnose Checkliste
+
+Wenn du M_FORBIDDEN bekommst:
+
+```bash
+# 1. Token gültig?
+curl "https://steggi-matrix.work/_matrix/client/v3/account/whoami" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# 2. PL im betroffenen Raum prüfen:
+curl "https://steggi-matrix.work/_matrix/client/v3/rooms/!ROOM_ID/state/m.room.power_levels/" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# 3. Mitglied des Raums?
+curl "https://steggi-matrix.work/_matrix/client/v3/rooms/!ROOM_ID/state/m.room.member/%40todesneutron%3Asteggi-matrix.work/" \
+  -H "Authorization: Bearer <ADMIN_TOKEN>"
+
+# 4. Was genau schlägt fehl? (Antwort-Body lesen!)
+# M_FORBIDDEN + "Power level too low" → PL erhöhen
+# M_FORBIDDEN + "Not a member" → Raum beitreten
+# M_UNRECOGNIZED → Feature nicht unterstützt
+# M_FORBIDDEN + "..." → join_rules restricted Problem
+```

docs/matrix-sdk/CHECKLIST.md

@@ -0,0 +1,433 @@
+# Pyramid — Feature-Checklist & Implementierungsstand
+
+> Stand: Mai 2026  
+> Legende: ✅ Fertig | ⚠️ Teilweise / Bug | ❌ Fehlt | 🔧 In Arbeit
+
+---
+
+## Inhaltsverzeichnis
+- [Authentifizierung](#authentifizierung)
+- [Raumliste](#raumliste)
+- [Chat / Timeline](#chat--timeline)
+- [Nachrichtentypen](#nachrichtentypen)
+- [Nachrichtenfunktionen](#nachrichtenfunktionen)
+- [Direct Messages](#direct-messages)
+- [E2EE Verschlüsselung](#e2ee-verschlüsselung)
+- [Push Notifications](#push-notifications)
+- [VoIP & Calls](#voip--calls)
+- [Settings / Einstellungen](#settings--einstellungen)
+- [Benutzerprofil](#benutzerprofil)
+- [Raum-Einstellungen](#raum-einstellungen)
+- [Suche](#suche)
+- [Medien](#medien)
+- [Read Receipts & Typing](#read-receipts--typing)
+- [Spaces](#spaces)
+- [Windows / Desktop](#windows--desktop)
+- [Sonstige Features](#sonstige-features)
+- [Dokumentations-Vollständigkeit](#dokumentations-vollständigkeit)
+
+---
+
+## Authentifizierung
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Login mit Passwort | ✅ | `login_page.dart`, `login_notifier.dart` |
+| Homeserver-Auswahl | ✅ | `server_page.dart` — HTTPS-Prefix fix, .well-known Autodiscovery |
+| Session wiederherstellen (init) | ✅ | `matrix_client.dart` — `client.init()` beim App-Start |
+| Logout | ✅ | Via Matrix SDK `client.logout()` |
+| Login-Redirect nach Init | ✅ | `router.dart` — StreamProvider-basierter Guard |
+| SSO / OAuth | ❌ | Nicht implementiert |
+| Registrierung / Account erstellen | ❌ | Keine UI |
+| Login mit Token | ❌ | Nur Passwort-Login |
+| Multi-Account | ❌ | Nur ein Account gleichzeitig |
+| UIAA Re-Auth (Passwort ändern) | ❌ | Kein UI |
+
+---
+
+## Raumliste
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Raumliste anzeigen | ✅ | `rooms_page.dart`, `room_list_item.dart` |
+| Sortierung nach letzter Aktivität | ✅ | In `rooms_provider.dart` |
+| Avatar-Anzeige (MXC) | ✅ | `mxc_image.dart` |
+| Vorschautext (letztes Event) | ✅ | `room_list_item.dart` |
+| Ungelesen-Badge | ✅ | `notificationCount` |
+| Ungelesen-Punkt (kein Count) | ✅ | Bei `notificationCount == 0` aber ungelesen |
+| Zeitstempel-Formatierung | ✅ | Heute: HH:MM, andere: DD.MM |
+| DM-Erkennung (`isDirectChat`) | ✅ | Typ-Differenzierung in Liste |
+| Space-Filterung | ✅ | `SpacesRail` filtert nach aktiver Space |
+| Einladungen anzeigen | ⚠️ | Membership.invite vorhanden, gesonderte Ansicht fehlt |
+| Raum suchen / filtern | ✅ | Via `search_modal.dart` |
+| Archivierte Räume | ❌ | Kein UI für left-rooms |
+| Raum erstellen (Knopf) | ✅ | `create_join_dialog.dart` |
+| Raum beitreten (Alias) | ✅ | `create_join_dialog.dart` |
+
+---
+
+## Chat / Timeline
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Nachrichten anzeigen | ✅ | `message_bubble.dart`, `message_group.dart` |
+| Gruppen-Bubbles (gleicher Sender) | ✅ | Continuation-Nachrichten (eingerückt, kein Avatar) |
+| Datums-Trenner | ✅ | Tagstrennlinie |
+| Ungelesen-Trenner ("Neue Nachrichten") | ✅ | `fullyRead`-Position |
+| Scroll-to-Unread beim Öffnen | ✅ | `chat_view.dart` |
+| History-Nachladen beim Scrollen | ✅ | `_onScroll()` → `requestHistory(60)` |
+| Optimistische Nachrichtenanzeige | ✅ | SDK fügt Event mit Status `sending` ein |
+| Nachrichtenstatus (senden/sent) | ✅ | Uhren-Icons |
+| Timeline-Cleanup (`cancelSubscriptions`) | ✅ | In `dispose()` |
+| Sprung zu bestimmtem Event | ⚠️ | Infrastruktur vorhanden, kein UI |
+| Event-Suche in Timeline | ❌ | Nur globale Suche |
+
+---
+
+## Nachrichtentypen
+| Typ | Status | Details |
+|-----|--------|---------|
+| Text (`m.text`) | ✅ | Vollständig |
+| Bild (`m.image`) | ✅ | Thumbnail + Vollansicht mit Zoom |
+| Video (`m.video`) | ✅ | Playback via `media_kit` |
+| Audio (`m.audio`) | ✅ | Player mit Progress/Dauer |
+| Datei (`m.file`) | ✅ | Download mit MIME-Icon |
+| Sticker (`m.sticker`) | ✅ | Anzeige und Senden (Sticker-Picker) |
+| Sprachnachricht (MSC3245) | ⚠️ | Audio-Aufnahme fehlt, Abspielen funktioniert |
+| Standort (`m.location`) | ❌ | Nicht implementiert |
+| Emote (`m.emote`) | ❌ | Kein gesondertes Rendering |
+| Poll (MSC3381) | ❌ | Nicht implementiert |
+| Verschlüsselte Nachrichten | ✅ | Automatisch via SDK, Fehler-UI vorhanden |
+| Redacted-Events | ⚠️ | Wird angezeigt, kein "Nachricht gelöscht"-Platzhalter |
+
+---
+
+## Nachrichtenfunktionen
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Antworten (Reply) | ✅ | Swipe-Geste + Quote-Anzeige |
+| Reaktionen (Emojis) | ✅ | Quick-Picker + vollständiger Emoji-Picker |
+| Reaktionen entfernen | ⚠️ | UI zum Entfernen fehlt |
+| Nachrichten bearbeiten (Edit) | ⚠️ | `getDisplayEvent()` vorhanden, Senden nicht im UI |
+| Nachricht löschen (Redact) | ❌ | Kein Button / Dialog |
+| Threads | ❌ | Nicht implementiert |
+| Polls | ❌ | Nicht implementiert |
+| Weitersenden (Forward) | ❌ | Nicht implementiert |
+| Kopieren (Text) | ⚠️ | Nicht explizit sichtbar |
+| Long-Press Auswahl-Modus | ✅ | `message_bubble.dart` — Long-Press aktiviert Selection |
+| Bulk-Aktionen (Auswahl) | ⚠️ | Modus vorhanden, Aktionen begrenzt |
+| Pinned Messages Panel | ✅ | `pinned_messages_panel.dart` |
+| Pins setzen (UI-Aktion) | ❌ | Kein Pin-Button in Nachricht |
+| Linkvorschau | ❌ | Keine URL-Preview |
+| Mention-Links klickbar | ✅ | `@user`-Links via `url_launcher` |
+
+---
+
+## Direct Messages
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Neuen DM starten | ✅ | `new_dm_dialog.dart` → `startDirectChat()` |
+| User-Verzeichnis-Suche | ✅ | `searchUserDirectory()` |
+| DM-Erkennung in Raumliste | ✅ | `room.isDirectChat` |
+| Partner-Avatar/Name | ✅ | `directChatMatrixID` → Profil laden |
+| DM-Verschlüsselung | ✅ | Standard E2EE bei DM-Erstellung |
+| Gruppen-DM | ⚠️ | Erstellbar, kein gesondertes UI |
+| DM vergessen / verlassen | ⚠️ | Kein UI-Button |
+| DM-spezifische Notification-Sounds | ❌ | Nicht implementiert |
+
+---
+
+## E2EE Verschlüsselung
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Vodozemac Rust-Crypto | ✅ | `flutter_vodozemac` initialisiert in `matrix_client.dart` |
+| E2EE in verschlüsselten Räumen | ✅ | Automatisch via SDK |
+| Bootstrap-Flow (SSSS + Cross-Signing) | ✅ | `bootstrap_dialog.dart` — vollständige State-Machine |
+| Cross-Signing Setup | ✅ | Master-, Self- und User-Signing-Key Erstellung |
+| Key Backup (online) | ✅ | SSSS-gesichertes Backup |
+| Schlüssel-Verifikation (SAS/Emoji) | ✅ | Via Bootstrap-Flow |
+| QR-Code-Verifikation | ⚠️ | SDK-Support vorhanden, kein UI |
+| Device-Liste anzeigen | ❌ | Kein UI |
+| Gerät sperren/blockieren | ❌ | Kein UI |
+| Fehlende Schlüssel anfordern | ✅ | `requestMissingSessionKeys()` bei Bad-Encrypted |
+| Entschlüsselungs-Fehler-UI | ✅ | "Nachricht konnte nicht entschlüsselt werden" + Schlüssel-Button |
+| Schlüssel importieren/exportieren | ❌ | Kein UI (Infrastruktur vorhanden) |
+
+---
+
+## Push Notifications
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| FCM Token Registrierung | ✅ | `fcm_push_service.dart` |
+| Pusher auf Homeserver | ✅ | `postPusher()` mit Sygnal-Gateway |
+| Token-Refresh Handling | ✅ | `onTokenRefresh.listen()` |
+| PushService.kt (native FCM) | ✅ | Läuft auch bei geschlossener App |
+| Benachrichtigung bei geschlossener App | 🔧 | APK neu gebaut, noch nicht getestet |
+| Absender-Name in Notification | ✅ | HTTP-Fetch von Matrix API in PushService.kt |
+| Verschlüsselte Nachricht entschlüsseln | ⚠️ | "Neue Nachricht" bei geschlossener App; `decryptAndUpdateNotification` bei Hintergrund-App |
+| Inline Reply in Notification | 🔧 | ReplyReceiver auf getActivity umgestellt — APK gebaut, ungetestet |
+| Antwort wirklich abschicken | 🔧 | `replyFromNotification` MethodChannel — APK gebaut, ungetestet |
+| Gelesen-Button in Notification | ✅ | `ACTION_DISMISS` über `ReplyReceiver.kt` |
+| Notification bei Hintergrund-App | ✅ | Heartbeat-Check verhindert Duplikate |
+| Notification-Kanal Android | ✅ | `pyramid_messages`, HIGH Importance |
+| Stabile Notification-ID | ✅ | `stableId(roomId)` — gleicher Algo in Kotlin + Dart |
+| Windows Notification | ✅ | `local_notifier` (Windows Toast) |
+| Windows Taskbar Flash | ✅ | `WindowsTaskbar.setProgressMode()` |
+| Ausstehende Reply beim App-Öffnen senden | ✅ | `_sendPendingReply()` bei Resume + Sync |
+| Push Rules konfigurieren | ❌ | Kein UI |
+| Raum stumm schalten | ❌ | Kein UI |
+| Nur-Erwähnung-Modus | ✅ | `notifMentionOnlyDmProvider` — Preferences |
+| iOS Push | ❌ | Kein iOS-Build |
+| Web Push | ❌ | Kein Web-Build |
+
+---
+
+## VoIP & Calls
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Matrix WebRTC Legacy-Calls | ✅ | `voip_manager.dart` — CallSession |
+| LiveKit SFU-Calls | ✅ | `livekit_call_manager.dart` |
+| Unified Call-UI | ✅ | `voice_channel.dart` |
+| Audio-Call | ✅ | Mikrofon + Speaker |
+| Video-Call | ✅ | Kamera + Remote-Video |
+| Screen-Sharing | ✅ | `screen_share_picker.dart` |
+| Video-Qualitätsstufen | ✅ | SD/HD/FHD/4K Presets |
+| Mute-Toggle | ✅ | `setMicrophoneEnabled()` |
+| Deafen-Toggle | ✅ | Audio komplett stumm |
+| Kamera-Toggle | ✅ | `setCameraEnabled()` |
+| Kamera-Wechsel (Front/Rück) | ⚠️ | SDK-Support vorhanden |
+| Teilnehmer-Grid | ✅ | Mehrere Participants anzeigen |
+| Lokale Video-Vorschau | ✅ | Overlay-Widget |
+| Klingel-System (to-device) | ⚠️ | Infrastruktur vorhanden, Klingelton fehlt |
+| Incoming-Call-UI | ⚠️ | Kein dediziertes Klingel-Screen |
+| Call-History | ❌ | Nicht implementiert |
+| TURN-Server via Matrix | ⚠️ | `getTurnServer()` — ob konfiguriert unklar |
+| Hintergrund-Foreground-Service | ✅ | `FlutterForegroundService` via webrtc |
+| MatrixRTC Membership-Events | ✅ | `io.pyramid.voice.presence` State-Events |
+| LiveKit-Token-Exchange | ✅ | `livekit_token.dart` |
+
+---
+
+## Settings / Einstellungen
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Settings-Seite (Hauptseite) | ⚠️ | `settings_page.dart` — NUR PLATZHALTER |
+| Settings Modal | ✅ | `settings_modal.dart` — vollständiger Modal |
+| Dark/Light Mode | ✅ | `themeModeProvider` + Toggle |
+| Akzentfarbe (5 Presets) | ✅ | Amber/Coral/Mint/Violet/Cobalt/Lime |
+| Eckenradius Slider | ✅ | `radiusProvider` |
+| UI-Motion Toggle | ✅ | `motionProvider` |
+| UI-Density Toggle | ✅ | `densityProvider` |
+| Desktop Notifications | ✅ | `notifDesktopProvider` |
+| Notification Sound | ✅ | `notifSoundProvider` |
+| Nachrichtenvorschau | ✅ | `notifPreviewProvider` |
+| Nur-Erwähnung-Modus | ✅ | `notifMentionOnlyDmProvider` |
+| Presence anzeigen (Online) | ✅ | `privacyPresenceProvider` |
+| Read Receipts senden | ✅ | `privacyReadReceiptsProvider` |
+| Typing-Indikator senden | ✅ | `privacyTypingProvider` |
+| Profil bearbeiten (Name/Avatar) | ❌ | Kein UI |
+| Geräte-Verwaltung | ❌ | Kein UI |
+| Session-Liste | ❌ | Kein UI |
+| Passwort ändern | ❌ | Kein UI |
+| Account löschen | ❌ | Kein UI |
+| Raumspezifische Benachrichtigungen | ❌ | Kein UI |
+| Sprache / Lokalisierung | ❌ | Nur Systemsprache |
+| Barrierefreiheit | ❌ | Keine Einstellungen |
+
+---
+
+## Benutzerprofil
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Avatar anzeigen (MXC) | ✅ | `mxc_image.dart` überall |
+| Displayname auflösen | ✅ | Fallback auf `@username` |
+| Online-Präsenz senden | ✅ | `setPresence(online)` alle 10s in `app_shell.dart` |
+| Präsenz-Anzeige anderer User | ⚠️ | Infrastruktur, kein UI |
+| Profil-Popover (Hover-Karte) | ✅ | `profile_popover.dart` |
+| Eigenes Profil bearbeiten | ❌ | Kein UI |
+| Avatar hochladen | ❌ | Kein UI |
+| Status-Nachricht | ❌ | Nicht implementiert |
+| User ignorieren / blockieren | ❌ | Kein UI |
+| User melden | ❌ | Kein UI |
+
+---
+
+## Raum-Einstellungen
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Space-Admin Panel (Name/Avatar/Banner) | ✅ | `space_admin_dialog.dart` — Overview-Tab |
+| Power-Level-Editor (Mitglieder) | ✅ | `space_admin_dialog.dart` — Members-Tab |
+| Permissions-Tab (Raum-PLs) | ✅ | `space_admin_dialog.dart` — Permissions-Tab |
+| Kind-Räume verwalten | ✅ | `space_admin_dialog.dart` — Channels-Tab |
+| Raum-Name ändern (normaler Raum) | ❌ | Kein UI |
+| Raum-Thema ändern | ❌ | Kein UI |
+| Raum-Avatar ändern | ❌ | Kein UI |
+| Join-Rules ändern | ❌ | Kein UI |
+| History-Visibility ändern | ❌ | Kein UI |
+| E2EE aktivieren | ❌ | Kein UI |
+| Raum-Alias verwalten | ❌ | Kein UI |
+| Raum verlassen (Button) | ❌ | Kein UI |
+| Raum vergessen (forget) | ❌ | Kein UI |
+| User einladen (aus Chat) | ❌ | Kein UI |
+| Kick / Ban (Moderation) | ❌ | Kein UI |
+
+---
+
+## Suche
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Server-seitige Nachrichtensuche | ✅ | `search_modal.dart` → `/search` API |
+| Lokale Raum-/DM-Suche | ✅ | Filter auf `client.rooms` |
+| Personen-Suche | ✅ | Lokale DM-Partner-Suche |
+| Medien-Filter (Bilder/Videos/Audio) | ✅ | `search_modal.dart` |
+| Paginierung (nextBatch) | ✅ | Infinite scroll |
+| Suchergebnis-Highlighting | ✅ | Suchbegriff hervorheben |
+| Debounced Query (400ms) | ✅ | `debounce` in Suchfeld |
+| Öffentliches Raumverzeichnis | ❌ | Kein UI zum Entdecken |
+| User-Verzeichnis-Suche (global) | ✅ | In `new_dm_dialog.dart` |
+
+---
+
+## Medien
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Bild senden | ✅ | `MatrixImageFile` + Upload |
+| Bild anzeigen (Thumbnail + Vollbild) | ✅ | `MediaViewer` mit Zoom/Pan |
+| Video senden | ✅ | |
+| Video abspielen | ✅ | `media_kit` |
+| Audio senden | ✅ | |
+| Audio abspielen | ✅ | Player mit Progress |
+| Datei senden | ✅ | `MatrixFile` |
+| Datei herunterladen | ✅ | MIME-Icon + Browser-Öffner |
+| Clipboard-Bild einfügen (Windows) | ✅ | FFI + `clipboard_image.dart` |
+| Drag & Drop Upload (Desktop) | ✅ | `desktop_drop` |
+| GIF-Picker (Giphy) | ✅ | Trending + Suche + Favoriten |
+| Sticker-Picker | ✅ | Pack-Browser |
+| Bild-Komprimierung | ✅ | `shrinkImageMaxDimension` |
+| Verschlüsselte Medien | ✅ | Automatisch bei E2EE-Räumen |
+| Sprachnachricht aufnehmen | ❌ | Kein Recorder |
+| Kamera direkt (in App) | ❌ | Nur Gallery-Picker |
+| Dokument-Vorschau | ❌ | Kein PDF-Viewer |
+| Media-Galerie (Raum-Mediathek) | ❌ | Kein UI |
+
+---
+
+## Read Receipts & Typing
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Read Receipts senden | ✅ | `setReadMarker()` (privacy-gesteuert) |
+| Eigene ✓✓ Bestätigung | ✅ | Anzeige auf eigenen Nachrichten |
+| Read-Marker anderer anzeigen | ⚠️ | Position-Marker vorhanden, kein Avatar-Stack |
+| Typing-Indikator senden | ✅ | 7s Auto-Timeout |
+| Typing-Indikator empfangen | ✅ | Anzeige-Platzhalter |
+| Typing-User-Namen anzeigen | ⚠️ | Platzhalter, keine Namen |
+
+---
+
+## Spaces
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Space-Erkennung (`isSpace`) | ✅ | |
+| Spaces-Rail (Sidebar) | ✅ | `spaces_rail.dart` |
+| Space-Filterung der Raumliste | ✅ | Nur Räume der aktiven Space |
+| Space-Admin Panel | ✅ | `space_admin_dialog.dart` |
+| Space erstellen | ✅ | `create_join_dialog.dart` |
+| Kind-Räume hinzufügen | ✅ | In Space-Admin |
+| Kind-Räume entfernen | ✅ | In Space-Admin |
+| Voice-Präsenz in Space | ✅ | `io.pyramid.voice.presence` Events |
+| Space-Banner | ✅ | Mit Crop-Dialog |
+| Verschachtelte Spaces | ⚠️ | Anzeige, kein eigener Sub-Space-Rail |
+| Space beitreten (öffentlich) | ⚠️ | Technisch möglich, kein Discovery-UI |
+
+---
+
+## Windows / Desktop
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Windows Build | ✅ | CMake + MSIX |
+| Windows Notifications | ✅ | `local_notifier` |
+| Taskbar Flash | ✅ | `WindowsTaskbar` |
+| Update-Checker (Gitea API) | ✅ | `update_checker.dart` — 4h Intervall |
+| Update-Banner | ✅ | `update_banner.dart` |
+| Update-Download | ✅ | `update_download_dialog.dart` |
+| APK Auto-Install (Android) | ✅ | Kotlin MethodChannel + FileProvider |
+| PC Update (exe/msix) Download | ⚠️ | Release-Script pusht .zip statt .exe → öffnet Git-Seite |
+| Drag & Drop | ✅ | `desktop_drop` |
+| Clipboard Paste (Bild) | ✅ | FFI Windows API |
+| Resizable Sidebar | ✅ | `panel_layout.dart` — Drag-Divider |
+| Keyboard Shortcuts | ⚠️ | Enter zum Senden, Ctrl+V — kein vollständiges System |
+| System Tray | ❌ | Nicht implementiert |
+| Fenster-Badge (ungelesen) | ⚠️ | Nur Taskbar-Flash, kein Zähler |
+| macOS / Linux | ❌ | Nicht gebaut/getestet |
+
+---
+
+## Sonstige Features
+| Feature | Status | Details / Datei |
+|---------|--------|-----------------|
+| Emoji-Picker | ✅ | Kategorisiert + Suche |
+| Quick-Reaktionen (6 Emojis) | ✅ | Hover-Aktionsleiste |
+| Mitglieder-Panel (Raum) | ✅ | `members/` — Teilnehmerliste |
+| Profil-Popover (Hover) | ✅ | `profile_popover.dart` |
+| Neuer-DM Dialog | ✅ | `new_dm_dialog.dart` |
+| Raum-erstellen Dialog | ✅ | `create_join_dialog.dart` |
+| Nachricht-Auswahl-Modus | ✅ | Long-Press |
+| Reply-Swipe-Geste | ✅ | Rechts-wischen zum Antworten |
+| Immersive-Mode (Android) | ✅ | Status-Bar ausgeblendet |
+| PyramidLoader (Ladeanimation) | ✅ | `pyramid_loader.dart` |
+| Rich-Text-Editor | ❌ | Kein Markdown/Formatting-UI |
+| HTML-Nachrichtenrendering | ❌ | Kein `flutter_html` |
+| Message Forwarding | ❌ | |
+| Nachrichtenübersetzung | ❌ | |
+| Bot-Kommandos (`/`) | ❌ | |
+| Matrix-URI Handler | ❌ | Kein Deep-Link-Handler |
+| Barcode/QR-Scanner | ⚠️ | Nur in Verifikation |
+
+---
+
+## Dokumentations-Vollständigkeit
+
+| Doku-Abschnitt | Vollständig | Anmerkungen |
+|----------------|-------------|-------------|
+| 01 Auth | ✅ | SSO, UIAA, alle Login-Flows |
+| 02 Räume | ✅ | Create, Join, Spaces, Power Levels |
+| 03 Nachrichten | ✅ | Text, Replies, Edits, Threads, Polls |
+| 04 DMs | ✅ | Alle DM-Flows |
+| 05 Medien | ✅ | Upload, Download, alle Dateitypen |
+| 06 E2EE | ✅ | Setup, SAS, Cross-Signing, Key Backup |
+| 07 Push | ✅ | FCM, Push Rules, Pyramid-Architektur |
+| 08 VoIP | ✅ | Legacy m.call, MatrixRTC |
+| 08b LiveKit | ✅ | **KOMPLETT** — Server-Setup bis Flutter-UI |
+| 09 Profil | ✅ | Presence, Account-Data, Tags |
+| 10 Room-Admin | ✅ | Power Levels, Moderation, ACL, Synapse Admin |
+| 11 Suche | ✅ | Event-Suche, User-Suche, Raumverzeichnis |
+| 12 Schnellreferenz | ✅ | Alle Enums, Widget-Patterns, Fehlerhandling |
+
+---
+
+## Prioritäts-Roadmap
+
+### 🔴 Kritisch (bald testen/fixen)
+1. **Notification-Reply testen** — Neue APK (getActivity-Fix) installieren und Reply-Flow verifizieren
+2. **Benachrichtigung bei geschlossener App** — Mit neuer APK testen (PushService.kt Ansatz)
+3. **PC Update-Script** — `.zip` durch `.exe`-Installer ersetzen in `scripts/release.ps1`
+
+### 🟠 Wichtig (nächste Features)
+4. **Nachricht löschen (Redact)** — Long-Press-Menü → `event.redactEvent()`
+5. **Nachricht bearbeiten** — Edit-Modus im Composer → `sendTextEvent(editEventId:...)`
+6. **Raum-Einstellungen** — Name/Thema/Avatar für normale Räume (`room.setName()` etc.)
+7. **Profil bearbeiten** — Displayname + Avatar in Settings
+8. **Registrierung** — Account-Erstellung im Onboarding
+
+### 🟡 Sinnvoll (mittelfristig)
+9. **Einladungen-Screen** — Pending invites sichtbar darstellen
+10. **Kick/Ban UI** — Moderation aus der Mitgliederliste
+11. **Device-Verwaltung** — Eigene Sessions anzeigen + löschen
+12. **Rich-Text-Editor** — Markdown/Formatierung in Nachrichten
+13. **Klingelton bei eingehendem Call** — Audio + dedizierter Klingel-Screen
+14. **Lautlos/Stumm per Raum** — Push-Rules im UI
+
+### 🟢 Nice-to-have
+15. Sprachnachrichten aufnehmen
+16. HTML-Nachrichtenrendering (`flutter_html`)
+17. Matrix-URI Deep-Links
+18. Media-Galerie pro Raum
+19. System Tray (Windows)
+20. Polls / Abstimmungen

docs/matrix-sdk/README.md

@@ -0,0 +1,122 @@
+# Matrix SDK — Pyramid Entwicklungsreferenz
+
+> **Basis:** [`package:matrix`](https://pub.dev/packages/matrix) (Dart/Flutter Matrix SDK)  
+> **Ziel:** Vollständige Landkarte aller Matrix-Funktionen mit Code-Snippets für den Pyramid-App-Bau.  
+> **Referenz-Implementierung:** FluffyChat (https://gitlab.com/famedly/fluffychat)
+
+---
+
+## Navigation
+
+| # | Thema | Beschreibung |
+|---|-------|--------------|
+| [01](01-auth.md) | **Authentifizierung** | Login, Logout, Register, SSO, Token-Management |
+| [02](02-rooms.md) | **Räume & Spaces** | Erstellen, Beitreten, Verlassen, Spaces, Suche |
+| [03](03-messages.md) | **Nachrichten & Events** | Senden, Timeline, Reaktionen, Edits, Threads, Polls |
+| [04](04-dm.md) | **Direct Messages** | DM-Räume finden, starten, verwalten |
+| [05](05-media.md) | **Medien & Dateien** | Upload, Download, Thumbnails, verschlüsselte Medien |
+| [06](06-encryption.md) | **E2EE Verschlüsselung** | Keys, Verifizierung, Cross-Signing, Key-Backup |
+| [07](07-push.md) | **Push & Notifications** | Pusher, Push Rules, FCM, lokale Benachrichtigungen |
+| [08](08-voip.md) | **VoIP & Calls** | MatrixRTC, Legacy m.call, Klingel-Flow |
+| [08b](08b-livekit-streaming.md) | **LiveKit Streaming** ⭐ | **Vollständige Server-Anleitung + Flutter-Implementierung** |
+| [09](09-profile.md) | **Profil & Präsenz** | Avatar, Displayname, Presence, Account-Daten |
+| [10](10-room-admin.md) | **Raum-Administration** | Power Levels, Moderierung, Einstellungen, Bans |
+| [11](11-search.md) | **Suche & Discovery** | Nachrichten-Suche, User-Suche, Raum-Verzeichnis |
+| [12](12-quick-reference.md) | **Schnellreferenz** | Alle Enums, Widget-Patterns, Fehlerhandling |
+| [13](13-server-admin-continuwuity.md) | **Server-Admin Continuwuity** ⭐ | Admin API, Power Levels erzwingen, MSC3083, Diagnose |
+| [CHECKLIST](CHECKLIST.md) | **Feature-Checklist** ⭐ | Implementierungsstand + Roadmap |
+
+---
+
+## Schnellreferenz: Client-Initialisierung
+
+```dart
+import 'package:matrix/matrix.dart';
+
+final client = Client(
+  'MeinApp',                              // App-Name (User-Agent)
+  database: MatrixSdkDatabase(...),       // Persistenz (sqflite)
+  nativeImplementations: NativeImplementationsIsolate(compute), // E2EE
+  logLevel: Level.warning,
+);
+
+// Initialisieren (lädt gespeicherten Session-State)
+await client.init(
+  waitForFirstSync: false,               // UI nicht blockieren
+  waitUntilLoadCompletedLoaded: false,
+);
+```
+
+---
+
+## Architektur-Überblick
+
+```
+Client
+├── rooms: List<Room>               // alle bekannten Räume
+├── userID: String?                 // eigene MXID (@user:server)
+├── accessToken: String?            // Bearer-Token
+├── homeserver: Uri                 // https://matrix.example.org
+│
+├── Room
+│   ├── id: String                  // !roomId:server
+│   ├── getTimeline()               // Event-Stream
+│   ├── sendTextEvent()
+│   ├── sendEvent()
+│   ├── members                     // Map<String, User>
+│   └── states                      // Map<String, Map<String, StrippedStateEvent>>
+│
+├── Event
+│   ├── type: String                // m.room.message, m.reaction, …
+│   ├── content: Map<String, dynamic>
+│   ├── body: String                // text body (decrypted)
+│   └── messageType: String?        // m.text, m.image, m.file, …
+│
+└── User
+    ├── id: String                  // MXID
+    ├── displayName: String?
+    └── avatarUrl: Uri?
+```
+
+---
+
+## Wichtige Streams / Provider-Hooks
+
+```dart
+// Auf Sync-Events reagieren
+client.onSync.stream.listen((SyncUpdate update) { ... });
+
+// Neue/geänderte Räume
+client.onRoomUpdate.stream.listen((String roomId) { ... });
+
+// Verbindungsstatus
+client.onConnectionStateChanged.stream.listen((ConnectionState s) { ... });
+
+// Eigener User geändert
+client.onUserEvent.stream.listen((EventUpdate update) { ... });
+
+// Benachrichtigungs-Events (gefiltert nach Push-Rules)
+client.onNotification.stream.listen((Event event) { ... });
+```
+
+---
+
+## Tipps für Riverpod-Integration
+
+```dart
+// Matrix-Client als Provider
+final matrixClientProvider = FutureProvider<Client>((ref) async {
+  final client = Client('Pyramid', ...);
+  await client.init(waitForFirstSync: false);
+  return client;
+});
+
+// Raumliste reaktiv
+final roomsProvider = StreamProvider<List<Room>>((ref) async* {
+  final client = await ref.watch(matrixClientProvider.future);
+  yield client.rooms;
+  await for (final _ in client.onSync.stream) {
+    yield client.rooms;
+  }
+});
+```

docs/server-incident-2026-05-31.md

@@ -0,0 +1,87 @@
+# Server-Incident: Messaging-Ausfall — 2026-05-31
+
+## Betroffene Nutzer
+`@uta:steggi-matrix.work`, `@circuitslave:steggi-matrix.work`
+
+## Symptome
+- Uta und Circuitslave konnten in verschlüsselten DM-Räumen keine Nachrichten senden
+- Nachrichten von `@todesneutron` kamen nicht an bzw. konnten nicht entschlüsselt werden
+- `@jochen` (Test-Account, FluffyChat) war nicht betroffen
+- Später: Element zeigt „Verbindung unterbrochen / Server offline"
+- Nach Behebung: alle Chats zunächst leer (History nicht sichtbar)
+
+---
+
+## Ursachen (in Reihenfolge des Auftretens)
+
+### 1. Continuwuity 0.5.8 — `room_keys/version` 500-Fehler
+**Endpunkt:** `GET /_matrix/client/unstable/room_keys/version`
+
+Continuwuity 0.5.8 crashte bei dieser Anfrage mit:
+```
+response error: JSON serialization failed: missing field `algorithm` at line 1 column 2
+500 Internal Server Error
+```
+
+Element prüft diesen Endpunkt beim Start, bevor es verschlüsselte Nachrichten sendet.
+Der 500-Fehler verhinderte den korrekten Aufbau des E2E-Zustands → Senden blockiert.
+
+FluffyChat/Pyramid implementieren diesen Check nicht → waren nicht betroffen.
+
+### 2. Zu viele unverifizierte Geräte bei `@todesneutron`
+Durch die Pyramid-Entwicklung wurden 14 Geräte angesammelt (alte FluffyChat-,
+Commet- und Pyramid-Debug-Sessions). Element von Uta/Circuitslave sah all diese
+Geräte als unbekannt und konnte nicht für alle gleichzeitig verschlüsseln.
+
+### 3. Continuwuity 0.5.9-latest — Axum Routing Panic (Folgeschaden)
+Beim Update auf `latest` (0.5.9, Commit `0514491`) trat ein Panic auf:
+```
+thread 'conduwuit:worker' panicked at axum-0.8.9/src/routing/path_router.rs:406:22:
+no route for id. This is a bug in axum.
+```
+
+Ausgelöst durch: `GET /_matrix/client/v3/user/@circuitslave:steggi-matrix.work/filter/ieOT`
+
+Circuitslaves Element hatte nach dem ersten Neustart seinen Filter verloren und
+sendete diese Anfrage in einer Schleife → Server-Worker crashte wiederholt →
+Cloudflare bekam EOF → alle Clients offline.
+
+### 4. Leere Chat-History nach Behebung
+Continuwuity 0.5.9 hat die interne RocksDB-Struktur von 98 auf 100 Column Families
+erweitert. Das invalidierte alle gespeicherten Sync-Token der Clients → Fresh Initial
+Sync → Server schickt nur aktuelle Room-States ohne vollständige Timeline.
+
+**Die Daten waren nicht verloren** — Pagination via `/messages` funktionierte korrekt.
+Durch Hochscrollen in den Räumen wurde die History nachgeladen.
+
+---
+
+## Maßnahmen
+
+| Schritt | Aktion |
+|---|---|
+| Diagnose | Geräteliste, Raumzustand, Server-Logs via SSH geprüft |
+| Geräte aufräumen | 14 → 5 aktive Geräte bei `@todesneutron` |
+| Server-Update | Wechsel auf `continuwuity:main` (Commit `1faa09b`) |
+| Ergebnis | `room_keys/version` gibt gültige Antwort, Filter-Panic behoben |
+| History | Nutzer scrollten in Räumen nach oben → Pagination lud History nach |
+
+---
+
+## Server-Infrastruktur
+
+- **Homeserver:** Continuwuity (Conduit-Fork, Rust) via Docker
+- **Compose-Datei:** `/home/steggi/matrix/docker-compose.yml`
+- **Image (vorher):** `registry.gitlab.com/continuwuity/continuwuity:latest` (0.5.8 → 0.5.9)
+- **Image (jetzt):** `registry.gitlab.com/continuwuity/continuwuity:main` (0.5.9, Commit `1faa09b`)
+- **Tunnel:** Cloudflare (`cloudflared`)
+- **Datenbank:** RocksDB unter `/home/steggi/matrix/db/`
+
+---
+
+## Lektionen
+
+- `latest`-Tag vor produktivem Update testen (0.5.9-latest hatte Routing-Bug)
+- Alte Geräte regelmäßig aus Element/Pyramid abmelden (verhindert E2E-Probleme)
+- `continuwuity:main` ist stabiler als `continuwuity:latest`
+- FluffyChat/Pyramid senden auch ohne Key-Backup-Check → können als Fallback dienen

flutter_launcher_icons.yaml

@@ -0,0 +1,12 @@
+flutter_launcher_icons:
+  android: true
+  ios: true
+  macos:
+    generate: true
+    image_path: "assets/logo.png"
+  windows:
+    generate: true
+    image_path: "assets/logo.png"
+  image_path: "assets/logo.png"
+  adaptive_icon_background: "#1A1B1E"
+  adaptive_icon_foreground: "android/app/src/main/res/drawable/ic_launcher_foreground.xml"

integration_test/android_screen_capture_test.dart

@@ -0,0 +1,52 @@
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:pyramid/core/call_foreground.dart';
+
+/// Android 14+: Bildschirmübertragung darf die App nicht abstürzen lassen
+/// (Bernds Test 2026-10-07: „Teilen“ → App weg → Anruf verloren).
+///
+/// Ablauf wie im Anruf: Zustimmung → Anruf-Dienst mit mediaProjection →
+/// Mitschnitt. Der System-Dialog muss bestätigt werden (auf dem Emulator per
+/// adb, siehe docs/TESTS_UND_BENCHMARKS.md).
+///
+///   flutter test integration_test/android_screen_capture_test.dart -d emulator-5554
+///
+/// PYRAMID_SCREEN_NEGATIVE=1 (per --dart-define) überspringt den Dienst –
+/// Gegenprobe: dann stürzt die App wie früher ab.
+const _negative = bool.fromEnvironment('PYRAMID_SCREEN_NEGATIVE');
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+
+  testWidgets(
+    'Bildschirmübertragung startet ohne Absturz',
+    (tester) async {
+      await tester.pumpWidget(const MaterialApp(home: Scaffold()));
+      if (_negative) {
+        expect(await Helper.requestCapturePermission(), isTrue);
+      } else {
+        expect(
+          await CallForeground.prepareScreenCapture('test'),
+          isTrue,
+          reason: 'Zustimmung oder Dienststart fehlgeschlagen',
+        );
+      }
+      final stream = await navigator.mediaDevices
+          .getDisplayMedia({'video': true, 'audio': false});
+      expect(stream.getVideoTracks(), isNotEmpty);
+      await Future.delayed(const Duration(seconds: 3));
+      for (final t in stream.getTracks()) {
+        await t.stop();
+      }
+      await stream.dispose();
+      await CallForeground.screenCaptureStopped('test');
+      await CallForeground.callEnded('test');
+    },
+    skip: !Platform.isAndroid,
+    timeout: const Timeout(Duration(minutes: 3)),
+  );
+}

integration_test/live_call_test.dart

@@ -0,0 +1,525 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_webrtc/flutter_webrtc.dart' as rtc;
+import 'package:integration_test/integration_test.dart';
+import 'package:matrix/matrix.dart';
+import 'package:pyramid/core/matrix_client.dart';
+import 'package:pyramid/features/call_signaling/call_signaling_service.dart';
+import 'package:pyramid/main.dart' as app;
+import 'package:sqflite_common_ffi/sqflite_ffi.dart';
+import 'package:webrtc_interface/webrtc_interface.dart';
+
+/// Echter 1:1-Anruf zwischen der App (pyramidtest1, Testprofil) und einem
+/// zweiten Matrix-Client im selben Prozess (pyramidtest2, kurzlebiges Gerät,
+/// wird am Ende abgemeldet). Bernds Fehlerbericht 2026-10-08: Ton kam nicht
+/// an, Bildschirm teilen ging weder am PC noch am Handy.
+///
+/// Geprüft wird: Verbindung steht, Ton fließt in BEIDE Richtungen (Bytes),
+/// Bildschirm der Gegenseite wird in der App angezeigt, und die App kann
+/// über den echten Quellen-Auswähler ihren Bildschirm teilen, der bei der
+/// Gegenseite ankommt. (Ob das Mikrofon hörbaren Ton liefert, kann ein
+/// Automat nicht prüfen – dafür gibt es den Mikrofontest und den Sprech-Ring.)
+///
+///   $env:PYRAMID_PROFILE_DIR="$env:USERPROFILE\.pyramid-autopilot\profile1"
+///   flutter test integration_test/live_call_test.dart -d windows
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final profile = Platform.environment['PYRAMID_PROFILE_DIR'];
+  final accounts = _loadAccounts();
+
+  testWidgets(
+    '1:1-Anruf: Ton beide Richtungen, Bildschirm teilen beide Richtungen',
+    (tester) async {
+      Logs().level = Level.verbose;
+      app.main();
+      await _pumpUntil(tester, () => find.byType(MaterialApp).evaluate().isNotEmpty);
+      final container = ProviderScope.containerOf(
+        tester.element(find.byType(MaterialApp).first),
+      );
+      final me = (await tester.runAsync(
+        () => container.read(matrixClientProvider.future),
+      ))!;
+      expect(me.userID, '@pyramidtest1:steggi-matrix.work');
+
+      final partner = (await tester.runAsync(
+        () => _Partner.start(accounts!['user2']!, accounts['pass2']!),
+      ))!;
+      String? roomId;
+      addTearDown(() => tester.runAsync(() async {
+            await partner.dispose(roomId);
+            final r = roomId == null ? null : me.getRoomById(roomId);
+            await r?.leave().catchError((_) {});
+            await r?.forget().catchError((_) {});
+          }));
+
+      // Eigener, unverschlüsselter Testraum (nur für diesen Lauf).
+      roomId = await tester.runAsync(() => partner.client.createRoom(
+            invite: [me.userID!],
+            preset: CreateRoomPreset.privateChat,
+            name: 'Anruftest (automatisch)',
+          ));
+      _log('Raum angelegt: $roomId');
+      await _pumpUntil(
+        tester,
+        () => me.getRoomById(roomId!)?.membership == Membership.invite,
+        what: 'Einladung kommt bei der App an',
+      );
+      await tester.runAsync(() => me.getRoomById(roomId!)!.join());
+      _log('App ist beigetreten');
+      // Die Gegenseite ist Ersteller und damit im Raum; ihr Mitglieder-Cache
+      // wird vom SDK nur bei Bedarf geladen – kurz warten genügt.
+      await _pumpFor(tester, const Duration(seconds: 3));
+
+      final voip = container.read(callSignalingProvider);
+
+      // ═══ Teil 1: Gegenseite ruft an, App nimmt über den echten Knopf an ═══
+      // (prüft die Kandidaten-Pufferung der App mit einem ungepatchten
+      // Anrufer – genau Bernds Fall „lange/kein Verbindungsaufbau“)
+      _log('Teil 1: Gegenseite ruft an');
+      await tester.runAsync(() => partner.run(() => partner.voip.inviteToCall(
+            partner.client.getRoomById(roomId!)!,
+            CallType.kVoice,
+          )));
+      final answerBtn = find.byWidgetPredicate(
+        (w) => w is FloatingActionButton && w.heroTag == 'answer_call',
+      );
+      await _pumpUntil(tester, () => answerBtn.evaluate().isNotEmpty,
+          what: 'Annehmen-Knopf erscheint');
+      await _pumpFor(tester, const Duration(seconds: 2)); // klingeln lassen
+      await tester.tap(answerBtn.first);
+      await _waitConnected(tester, voip, partner);
+
+      await _checkAudio(tester, voip, partner);
+
+      // Stumm über den echten Knopf → Gegenseite sieht „stumm“, Spur ist aus.
+      bool partnerSeesMuted() =>
+          partner.delegate.call?.remoteUserMediaStream?.audioMuted == true;
+      await tester.tap(find.byIcon(Icons.mic_rounded).first);
+      await _pumpUntil(tester, partnerSeesMuted,
+          timeout: const Duration(seconds: 15),
+          what: 'Gegenseite sieht: App ist stumm');
+      expect(voip.isMicMuted, isTrue);
+      expect(
+        voip.currentCall!.localUserMediaStream!.stream!.getAudioTracks().first.enabled,
+        isFalse,
+        reason: 'Mikrofonspur ist trotz Stumm noch an',
+      );
+      await tester.tap(find.byIcon(Icons.mic_off_rounded).first);
+      await _pumpUntil(tester, () => !partnerSeesMuted() && !voip.isMicMuted,
+          timeout: const Duration(seconds: 15),
+          what: 'Stumm wieder aufgehoben');
+      _log('Stumm/Entstummen über den Knopf: ok');
+
+      // Taub → Gegenseite nicht mehr hören UND selbst stumm; danach zurück.
+      await tester.tap(find.byIcon(Icons.headphones_rounded).first);
+      await _pumpUntil(
+        tester,
+        () => voip.isDeafened && partnerSeesMuted(),
+        timeout: const Duration(seconds: 15),
+        what: 'Taub: selbst stumm',
+      );
+      final remoteAudio = voip.currentCall!.getRemoteStreams
+          .expand((w) => w.stream?.getAudioTracks() ?? const <MediaStreamTrack>[]);
+      expect(remoteAudio, isNotEmpty);
+      expect(remoteAudio.every((t) => !t.enabled), isTrue,
+          reason: 'Ton der Gegenseite ist trotz Taub noch an');
+      await tester.tap(find.byIcon(Icons.headset_off_rounded).first);
+      await _pumpUntil(
+        tester,
+        () => !voip.isDeafened && !partnerSeesMuted() && !voip.isMicMuted,
+        timeout: const Duration(seconds: 15),
+        what: 'Taub aufgehoben, Mikro wieder an',
+      );
+      expect(
+        voip.currentCall!.getRemoteStreams
+            .expand((w) => w.stream?.getAudioTracks() ?? const <MediaStreamTrack>[])
+            .every((t) => t.enabled),
+        isTrue,
+      );
+      _log('Taub/Hören über den Knopf: ok');
+
+      // Gegenseite teilt Bildschirm → App zeigt ihn
+      await tester.runAsync(
+        () => partner.run(() => partner.delegate.call!.setScreensharingEnabled(true)),
+      );
+      await _pumpUntil(
+        tester,
+        () =>
+            voip.isRemoteScreensharing &&
+            (voip.remoteRenderer.srcObject?.getVideoTracks().isNotEmpty ?? false),
+        timeout: const Duration(seconds: 30),
+        what: 'Bildschirm der Gegenseite erscheint in der App',
+      );
+      await _pumpFor(tester, const Duration(seconds: 3));
+      final appVideoIn = (await tester.runAsync(
+        () => _rtp(voip.currentCall!.pc!, 'video'),
+      ))!;
+      _log('BILD bei der App (von der Gegenseite): $appVideoIn');
+      expect(appVideoIn.received, greaterThan(0),
+          reason: 'Bildschirm der Gegenseite kommt nicht an');
+      await tester.runAsync(
+        () => partner.run(() => partner.delegate.call!.setScreensharingEnabled(false)),
+      );
+      await _pumpUntil(tester, () => !voip.isRemoteScreensharing,
+          what: 'Bildschirm der Gegenseite verschwindet wieder');
+
+      // App teilt ihren Bildschirm über den echten Auswähler
+      await _pumpUntil(
+        tester,
+        () => find.byIcon(Icons.screen_share_rounded).evaluate().isNotEmpty,
+        what: 'Teilen-Knopf in der Anrufleiste',
+      );
+      await tester.tap(find.byIcon(Icons.screen_share_rounded).first);
+      final tile = find.byWidgetPredicate(
+        (w) => w.runtimeType.toString() == '_SourceTile',
+      );
+      await _pumpUntil(tester, () => tile.evaluate().isNotEmpty,
+          timeout: const Duration(seconds: 20), what: 'Quellen-Auswähler');
+      await tester.tap(tile.first);
+      await _pumpUntil(
+        tester,
+        () {
+          final s = partner.delegate.call?.remoteScreenSharingStream?.stream;
+          return voip.isScreensharing &&
+              s != null &&
+              s.getVideoTracks().isNotEmpty;
+        },
+        timeout: const Duration(seconds: 30),
+        what: 'Bildschirm der App kommt bei der Gegenseite an',
+      );
+      await _pumpFor(tester, const Duration(seconds: 3));
+      final partnerVideoIn = (await tester.runAsync(
+        () => _rtp(partner.delegate.call!.pc!, 'video'),
+      ))!;
+      _log('BILD bei der Gegenseite (von der App): $partnerVideoIn');
+      expect(partnerVideoIn.received, greaterThan(0),
+          reason: 'Bildschirm der App kommt nicht an');
+
+      await tester.runAsync(() => voip.hangup());
+      await _pumpUntil(tester, () => voip.currentCall == null,
+          what: 'aufgelegt (Teil 1)');
+      await _pumpFor(tester, const Duration(seconds: 3));
+
+      // ═══ Teil 2: App ruft an, Gegenseite nimmt an ═══
+      _log('Teil 2: App ruft an');
+      partner.fixCandidates = true; // Gegenseite wie eine gepatchte Pyramid
+      await tester.runAsync(() => voip.startCall(roomId!, video: false));
+      await _waitConnected(tester, voip, partner);
+      await _checkAudio(tester, voip, partner);
+      await tester.runAsync(() => voip.hangup());
+      await _pumpUntil(tester, () => voip.currentCall == null,
+          what: 'aufgelegt (Teil 2)');
+    },
+    skip: profile == null || accounts == null,
+    timeout: const Timeout(Duration(minutes: 5)),
+  );
+}
+
+Future<void> _waitConnected(
+  WidgetTester tester,
+  CallSignalingService voip,
+  _Partner partner,
+) async {
+  final t0 = DateTime.now();
+  await _pumpUntil(
+    tester,
+    () =>
+        voip.currentCall?.state == CallState.kConnected &&
+        partner.delegate.call?.state == CallState.kConnected,
+    timeout: const Duration(seconds: 60),
+    what: 'Anruf verbunden',
+    every5s: () {
+      final a = voip.currentCall;
+      final b = partner.delegate.call;
+      _log('App: ${a?.state} ice=${a?.pc?.iceConnectionState} | '
+          'Gegenseite: ${b?.state} ice=${b?.pc?.iceConnectionState}');
+    },
+  );
+  _log('verbunden nach ${DateTime.now().difference(t0).inMilliseconds} ms');
+}
+
+Future<void> _checkAudio(
+  WidgetTester tester,
+  CallSignalingService voip,
+  _Partner partner,
+) async {
+  await _pumpFor(tester, const Duration(seconds: 4));
+  final appAudio = (await tester.runAsync(
+    () => _rtp(voip.currentCall!.pc!, 'audio'),
+  ))!;
+  final partnerAudio = (await tester.runAsync(
+    () => _rtp(partner.delegate.call!.pc!, 'audio'),
+  ))!;
+  _log('TON App: $appAudio | Gegenseite: $partnerAudio');
+  expect(appAudio.sent, greaterThan(0), reason: 'App sendet keinen Ton');
+  expect(appAudio.received, greaterThan(0), reason: 'App empfängt keinen Ton');
+  expect(partnerAudio.received, greaterThan(0),
+      reason: 'Gegenseite empfängt keinen Ton der App');
+}
+
+class _Rtp {
+  _Rtp(this.sent, this.received);
+  final num sent;
+  final num received;
+  @override
+  String toString() => 'gesendet=$sent B, empfangen=$received B';
+}
+
+Future<_Rtp> _rtp(rtc.RTCPeerConnection pc, String kind) async {
+  num sent = 0;
+  num received = 0;
+  for (final r in await pc.getStats()) {
+    if (r.values['kind'] != kind) continue;
+    if (r.type == 'outbound-rtp') sent += (r.values['bytesSent'] as num?) ?? 0;
+    if (r.type == 'inbound-rtp') received += (r.values['bytesReceived'] as num?) ?? 0;
+  }
+  return _Rtp(sent, received);
+}
+
+/// Zweiter Teilnehmer: eigener Matrix-Client + VoIP im selben Prozess.
+class _Partner {
+  _Partner(this.client, this.delegate, this.voip, this.zone) {
+    _sub = client.onCallEvents.stream.listen((events) {
+      for (final e in events) {
+        if (e.type != EventTypes.CallCandidates || e.senderId == client.userID) {
+          continue;
+        }
+        final list = e.content.tryGetList<Map<String, dynamic>>('candidates');
+        if (list != null) _buffer.addAll(list);
+      }
+    });
+    _timer = Timer.periodic(const Duration(milliseconds: 500), (_) async {
+      final pc = delegate.call?.pc;
+      if (!fixCandidates || pc == null) return;
+      try {
+        if (await pc.getRemoteDescription() == null) return;
+        for (final c in List.of(_buffer)) {
+          final cand = c['candidate'] as String?;
+          if (cand == null || !_applied.add(cand)) continue;
+          await pc.addCandidate(RTCIceCandidate(
+            cand,
+            c['sdpMid']?.toString() ?? '',
+            (c['sdpMLineIndex'] as num?)?.round() ?? 0,
+          ));
+        }
+      } catch (_) {}
+    });
+  }
+  final Client client;
+  final _PartnerDelegate delegate;
+  final VoIP voip;
+  final Zone zone;
+
+  /// Aktion der Gegenseite in ihrer Zone ausführen (Fehler über Completer).
+  Future<T> run<T>(Future<T> Function() f) {
+    final done = Completer<T>();
+    zone.run(() async {
+      try {
+        done.complete(await f());
+      } catch (e, s) {
+        done.completeError(e, s);
+      }
+    });
+    return done.future;
+  }
+
+  /// Gegenseite reicht Kandidaten nach wie die gepatchte App.
+  bool fixCandidates = false;
+  final _buffer = <Map<String, dynamic>>[];
+  final _applied = <String>{};
+  StreamSubscription? _sub;
+  Timer? _timer;
+
+  static Future<_Partner> start(String user, String pass) async {
+    final db = await databaseFactoryFfi.openDatabase(inMemoryDatabasePath);
+    final client = Client(
+      'pyramid-call-partner',
+      database: await MatrixSdkDatabase.init('pyramid-call-partner', database: db),
+    );
+    await client.init(waitForFirstSync: false, waitUntilLoadCompletedLoaded: false);
+    await client.checkHomeserver(Uri.parse('https://steggi-matrix.work'));
+    await client.login(
+      LoginType.mLoginPassword,
+      identifier: AuthenticationUserIdentifier(user: user),
+      password: pass,
+      initialDeviceDisplayName: 'Pyramid-Anruftest (kurzlebig)',
+    );
+    final delegate = _PartnerDelegate();
+    // Eigene Zone: Fehler der Gegenseite sichtbar protokollieren statt sie
+    // im Testrahmen zu verlieren.
+    final zone = Zone.current.fork(
+      specification: ZoneSpecification(
+        handleUncaughtError: (self, parent, z, e, s) =>
+            _log('Gegenseite (abgefangen): ${e.toString().split('\n').first}'),
+      ),
+    );
+    final voip = zone.run(() => VoIP(client, delegate));
+    return _Partner(client, delegate, voip, zone);
+  }
+
+  Future<void> dispose(String? roomId) async {
+    _timer?.cancel();
+    await _sub?.cancel();
+    try {
+      await delegate.call?.hangup(reason: CallErrorCode.userHangup);
+    } catch (_) {}
+    if (roomId != null) {
+      try {
+        await client.leaveRoom(roomId);
+        await client.forgetRoom(roomId);
+      } catch (_) {}
+    }
+    try {
+      client.backgroundSync = false;
+      await client.logout();
+    } catch (_) {}
+  }
+}
+
+class _PartnerDelegate implements WebRTCDelegate {
+  CallSession? call;
+
+  @override
+  MediaDevices get mediaDevices => _PartnerMedia(rtc.navigator.mediaDevices);
+
+  @override
+  Future<RTCPeerConnection> createPeerConnection(
+    Map<String, dynamic> configuration, [
+    Map<String, dynamic> constraints = const {},
+  ]) =>
+      rtc.createPeerConnection(configuration, constraints);
+
+  @override
+  Future<void> handleNewCall(CallSession session) async {
+    call = session;
+    if (session.direction == CallDirection.kIncoming) {
+      // Wie ein Mensch nach kurzem Klingeln annehmen. Sofortiges Annehmen
+      // trifft eine Lücke im SDK: Kandidaten, die WÄHREND answer()
+      // eintreffen, landen in einer Warteschlange, die nie mehr abgearbeitet
+      // wird (CallSession.onCandidatesReceived vs. answer()).
+      unawaited(Future.delayed(const Duration(seconds: 2), () async {
+        try {
+          await session.answer();
+        } catch (e) {
+          _log('Gegenseite: Annehmen fehlgeschlagen: $e');
+        }
+      }));
+    }
+  }
+
+  @override
+  Future<void> handleCallEnded(CallSession session) async {}
+  @override
+  Future<void> handleMissedCall(CallSession session) async {}
+  @override
+  Future<void> handleNewGroupCall(GroupCallSession groupCall) async {}
+  @override
+  Future<void> handleGroupCallEnded(GroupCallSession groupCall) async {}
+  @override
+  Future<void> playRingtone() async {}
+  @override
+  Future<void> stopRingtone() async {}
+  @override
+  Future<void> registerListeners(CallSession session) async {}
+  @override
+  bool get isWeb => false;
+  @override
+  bool get canHandleNewCall => true;
+  @override
+  EncryptionKeyProvider? get keyProvider => null;
+}
+
+/// Wie die App am PC: Bildschirm über eine Desktop-Quelle (erster Monitor).
+class _PartnerMedia extends MediaDevices {
+  _PartnerMedia(this._d);
+  final MediaDevices _d;
+
+  @override
+  Future<MediaStream> getUserMedia(Map<String, dynamic> c) => _d.getUserMedia(c);
+
+  @override
+  Future<MediaStream> getDisplayMedia(Map<String, dynamic> c) async {
+    final sources = await rtc.desktopCapturer
+        .getSources(types: [rtc.SourceType.Screen]);
+    return _d.getDisplayMedia({
+      'video': {
+        'mandatory': {
+          'chromeMediaSource': 'desktop',
+          'chromeMediaSourceId': sources.first.id,
+        },
+        'optional': [],
+      },
+      'audio': false,
+    });
+  }
+
+  @override
+  Future<List<MediaDeviceInfo>> enumerateDevices() => _d.enumerateDevices();
+  @override
+  MediaTrackSupportedConstraints getSupportedConstraints() =>
+      _d.getSupportedConstraints();
+  @override
+  set ondevicechange(Function(dynamic event)? callback) =>
+      _d.ondevicechange = callback;
+  @override
+  Function(dynamic event)? get ondevicechange => _d.ondevicechange;
+  @override
+  // ignore: deprecated_member_use
+  Future<List<dynamic>> getSources() => _d.getSources();
+  @override
+  Future<MediaDeviceInfo> selectAudioOutput([AudioOutputOptions? options]) =>
+      _d.selectAudioOutput(options);
+}
+
+Map<String, String>? _loadAccounts() {
+  final home = Platform.environment['USERPROFILE'] ?? '';
+  final file = File('$home\\.pyramid-autopilot\\test-accounts.txt');
+  if (!file.existsSync()) return null;
+  final map = <String, String>{};
+  for (final line in file.readAsLinesSync()) {
+    final t = line.trim();
+    if (t.isEmpty || t.startsWith('#')) continue;
+    final i = t.indexOf('=');
+    if (i > 0) map[t.substring(0, i)] = t.substring(i + 1);
+  }
+  return map;
+}
+
+Future<void> _pumpFor(WidgetTester tester, Duration d) async {
+  final end = DateTime.now().add(d);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 100));
+  }
+}
+
+void _log(String m) {
+  // ignore: avoid_print
+  print('SCHRITT ${DateTime.now().toIso8601String().substring(11, 19)} $m');
+}
+
+Future<void> _pumpUntil(
+  WidgetTester tester,
+  bool Function() condition, {
+  Duration timeout = const Duration(seconds: 60),
+  String what = '',
+  void Function()? onTimeout,
+  void Function()? every5s,
+}) async {
+  final end = DateTime.now().add(timeout);
+  var next = DateTime.now().add(const Duration(seconds: 5));
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 200));
+    if (condition()) return;
+    if (every5s != null && DateTime.now().isAfter(next)) {
+      every5s();
+      next = DateTime.now().add(const Duration(seconds: 5));
+    }
+  }
+  _log('ZEITÜBERSCHREITUNG: $what');
+  onTimeout?.call();
+  fail('Zeitüberschreitung: $what');
+}

integration_test/live_receipts_invite_test.dart

@@ -0,0 +1,277 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:http/http.dart' as http;
+import 'package:integration_test/integration_test.dart';
+import 'package:matrix/matrix.dart';
+import 'package:pyramid/core/app_state.dart';
+import 'package:pyramid/core/matrix_client.dart';
+import 'package:pyramid/main.dart' as app;
+
+/// Live mit beiden Testkonten (Bernds Fehlerbericht 2026-10-07):
+///  1. ✓✓ erscheint LIVE, sobald der Partner liest – ohne den Chat neu zu
+///     öffnen (vorher zeichnete eine reine Lesebestätigung nichts neu).
+///  2. Einladung lässt sich direkt im Chat annehmen, danach ist der Verlauf
+///     sofort da (vorher leerer Chat bis zum App-Neustart).
+///
+/// Die App läuft mit dem Testprofil (PYRAMID_PROFILE_DIR, pyramidtest1).
+/// pyramidtest2 wird per Client-Server-API mit einem kurzlebigen Gerät
+/// gesteuert, das am Ende abgemeldet wird – andere Sitzungen (z. B. Bernds
+/// Testinstanz mit profile2) bleiben unberührt.
+///
+///   $env:PYRAMID_PROFILE_DIR="$env:USERPROFILE\.pyramid-autopilot\profile1"
+///   flutter test integration_test/live_receipts_invite_test.dart -d windows
+const _hs = 'https://steggi-matrix.work';
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final profile = Platform.environment['PYRAMID_PROFILE_DIR'];
+  final accounts = _loadAccounts();
+
+  testWidgets(
+    'Lesebestätigung live + Einladung im Chat annehmen',
+    (tester) async {
+      tester.view
+        ..physicalSize = const Size(1080, 2340)
+        ..devicePixelRatio = 2.625;
+      addTearDown(tester.view.reset);
+
+      final partner = await tester.runAsync(
+        () => _RestUser.login(accounts!['user2']!, accounts['pass2']!),
+      );
+      addTearDown(() => tester.runAsync(() => partner!.logout()));
+
+      app.main();
+      await _pumpUntil(tester, find.byType(MaterialApp));
+      final container = ProviderScope.containerOf(
+        tester.element(find.byType(MaterialApp).first),
+      );
+      final client = (await tester.runAsync(
+        () => container.read(matrixClientProvider.future),
+      ))!;
+      expect(client.userID, '@pyramidtest1:steggi-matrix.work');
+      await _pumpFor(tester, const Duration(seconds: 4));
+
+      // ── 1. Lesebestätigung live ──
+      final dm = client.rooms.firstWhere(
+        (r) =>
+            r.membership == Membership.join &&
+            r.directChatMatrixID == '@pyramidtest2:steggi-matrix.work',
+      );
+      container.read(activeRoomIdProvider.notifier).state = dm.id;
+      await _pumpFor(tester, const Duration(seconds: 4));
+
+      final text = 'Lesetest ${DateTime.now().millisecondsSinceEpoch}';
+      final eventId = await tester.runAsync(() => dm.sendTextEvent(text));
+      await _pumpUntil(tester, find.textContaining(text));
+      await _pumpFor(tester, const Duration(seconds: 3));
+      expect(
+        find.byIcon(Icons.done_rounded),
+        findsOneWidget,
+        reason: 'eigene neueste Nachricht sollte noch ✓ (ungelesen) zeigen',
+      );
+
+      await tester.runAsync(() => partner!.readReceipt(dm.id, eventId!));
+      // Ohne den Chat neu zu öffnen: ✓ wird zu ✓✓ direkt unter der Nachricht.
+      await _pumpUntil(
+        tester,
+        find.byIcon(Icons.done_rounded),
+        gone: true,
+        timeout: const Duration(seconds: 30),
+      );
+      final msgY = tester.getCenter(find.textContaining(text).first).dy;
+      final readIcons = find.byIcon(Icons.done_all_rounded).evaluate();
+      expect(
+        readIcons.any((e) {
+          final box = e.renderObject as RenderBox;
+          final y = box.localToGlobal(box.size.center(Offset.zero)).dy;
+          return y > msgY && y - msgY < 120;
+        }),
+        isTrue,
+        reason: '✓✓ erscheint nicht live unter der gelesenen Nachricht',
+      );
+
+      // ── 2. Einladung im Chat annehmen ──
+      final welcome = 'Willkommen im Einladungstest ${DateTime.now().millisecondsSinceEpoch}';
+      final inviteRoomId = await tester.runAsync(() async {
+        final id = await partner!.createRoom('Einladungstest');
+        await partner.sendText(id, welcome);
+        await partner.invite(id, client.userID!);
+        return id;
+      });
+      addTearDown(() => tester.runAsync(() => partner!.leave(inviteRoomId!)));
+
+      // Einladung kommt per Sync an → Chat öffnen (wie aus der Benachrichtigung).
+      final end = DateTime.now().add(const Duration(seconds: 30));
+      while (client.getRoomById(inviteRoomId!)?.membership != Membership.invite &&
+          DateTime.now().isBefore(end)) {
+        await _pumpFor(tester, const Duration(milliseconds: 500));
+      }
+      container.read(activeRoomIdProvider.notifier).state = inviteRoomId;
+      await _pumpUntil(tester, find.text('Annehmen'));
+      await tester.tap(find.text('Annehmen'));
+      // Ohne App-Neustart: Verlauf mit der Begrüßung erscheint.
+      await _pumpUntil(
+        tester,
+        find.textContaining(welcome),
+        timeout: const Duration(seconds: 40),
+      );
+      expect(find.text('Annehmen'), findsNothing);
+
+      // ── 3. „Neue Nachrichten“-Trenner MITTEN in einer Gruppe verschwindet ──
+      // (Bernd 2026-10-08: blieb manchmal stehen – bei mehreren Nachrichten
+      // desselben Absenders hintereinander, gelesen bis zur ersten.)
+      container.read(activeRoomIdProvider.notifier).state = null;
+      await _pumpFor(tester, const Duration(seconds: 1));
+      final ids = (await tester.runAsync(() async => [
+            await partner!.sendText(inviteRoomId, 'Gruppe 1'),
+            await partner.sendText(inviteRoomId, 'Gruppe 2'),
+            await partner.sendText(inviteRoomId, 'Gruppe 3'),
+          ]))!;
+      final room = client.getRoomById(inviteRoomId)!;
+      // Erst warten, bis alle drei da sind, dann bis „Gruppe 1“ gelesen melden.
+      final tEnd = DateTime.now().add(const Duration(seconds: 30));
+      while (room.lastEvent?.eventId != ids[2] && DateTime.now().isBefore(tEnd)) {
+        await _pumpFor(tester, const Duration(milliseconds: 300));
+      }
+      await tester.runAsync(() => room.setReadMarker(ids[0], mRead: ids[0]));
+      final fEnd = DateTime.now().add(const Duration(seconds: 30));
+      while (room.fullyRead != ids[0] && DateTime.now().isBefore(fEnd)) {
+        await _pumpFor(tester, const Duration(milliseconds: 300));
+      }
+      expect(room.fullyRead, ids[0], reason: 'Lesemarker kam nicht an');
+      container.read(activeRoomIdProvider.notifier).state = inviteRoomId;
+      await _pumpUntil(tester, find.text('Neue Nachrichten'),
+          timeout: const Duration(seconds: 20));
+      // Nach der Verweildauer (6 s) + Ausblenden muss er weg sein.
+      await _pumpUntil(
+        tester,
+        find.text('Neue Nachrichten'),
+        gone: true,
+        timeout: const Duration(seconds: 15),
+      );
+
+      // Aufräumen: Testraum verlassen + vergessen.
+      await tester.runAsync(() async {
+        final r = client.getRoomById(inviteRoomId);
+        await r?.leave();
+        await r?.forget().catchError((_) {});
+      });
+      container.read(activeRoomIdProvider.notifier).state = null;
+      await _pumpFor(tester, const Duration(seconds: 1));
+    },
+    skip: profile == null || accounts == null,
+    timeout: const Timeout(Duration(minutes: 4)),
+  );
+}
+
+Map<String, String>? _loadAccounts() {
+  final home = Platform.environment['USERPROFILE'] ?? '';
+  final file = File('$home\\.pyramid-autopilot\\test-accounts.txt');
+  if (!file.existsSync()) return null;
+  final map = <String, String>{};
+  for (final line in file.readAsLinesSync()) {
+    final t = line.trim();
+    if (t.isEmpty || t.startsWith('#')) continue;
+    final i = t.indexOf('=');
+    if (i > 0) map[t.substring(0, i)] = t.substring(i + 1);
+  }
+  return map;
+}
+
+/// Minimaler Matrix-Zugang per Client-Server-API (kurzlebiges Gerät).
+class _RestUser {
+  _RestUser(this._token);
+  final String _token;
+  int _txn = 0;
+
+  static Future<_RestUser> login(String user, String pass) async {
+    final res = await http.post(
+      Uri.parse('$_hs/_matrix/client/v3/login'),
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode({
+        'type': 'm.login.password',
+        'identifier': {'type': 'm.id.user', 'user': user},
+        'password': pass,
+        'initial_device_display_name': 'Pyramid-Livetest (kurzlebig)',
+      }),
+    );
+    if (res.statusCode != 200) throw StateError('Login ${res.statusCode}');
+    return _RestUser(jsonDecode(res.body)['access_token'] as String);
+  }
+
+  Future<Map<String, dynamic>> _call(String method, String path,
+      [Object? body]) async {
+    final req = http.Request(method, Uri.parse('$_hs/_matrix/client/v3$path'))
+      ..headers['Authorization'] = 'Bearer $_token'
+      ..headers['Content-Type'] = 'application/json'
+      ..body = jsonEncode(body ?? {});
+    final res = await http.Response.fromStream(await req.send());
+    if (res.statusCode != 200) {
+      throw StateError('$method $path → ${res.statusCode}');
+    }
+    return jsonDecode(res.body) as Map<String, dynamic>;
+  }
+
+  String _enc(String s) => Uri.encodeComponent(s);
+
+  Future<void> readReceipt(String roomId, String eventId) => _call(
+        'POST',
+        '/rooms/${_enc(roomId)}/read_markers',
+        {'m.fully_read': eventId, 'm.read': eventId},
+      );
+
+  Future<String> createRoom(String name) async =>
+      (await _call('POST', '/createRoom', {
+        'name': name,
+        'preset': 'private_chat',
+      }))['room_id'] as String;
+
+  Future<String> sendText(String roomId, String text) async =>
+      (await _call(
+        'PUT',
+        '/rooms/${_enc(roomId)}/send/m.room.message/t${DateTime.now().microsecondsSinceEpoch}${_txn++}',
+        {'msgtype': 'm.text', 'body': text},
+      ))['event_id'] as String;
+
+  Future<void> invite(String roomId, String userId) =>
+      _call('POST', '/rooms/${_enc(roomId)}/invite', {'user_id': userId});
+
+  Future<void> leave(String roomId) async {
+    try {
+      await _call('POST', '/rooms/${_enc(roomId)}/leave');
+      await _call('POST', '/rooms/${_enc(roomId)}/forget');
+    } catch (_) {}
+  }
+
+  Future<void> logout() async {
+    try {
+      await _call('POST', '/logout');
+    } catch (_) {}
+  }
+}
+
+Future<void> _pumpFor(WidgetTester tester, Duration d) async {
+  final end = DateTime.now().add(d);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 100));
+  }
+}
+
+Future<void> _pumpUntil(
+  WidgetTester tester,
+  Finder finder, {
+  bool gone = false,
+  Duration timeout = const Duration(seconds: 60),
+}) async {
+  final end = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 200));
+    final found = finder.evaluate().isNotEmpty;
+    if (found != gone) return;
+  }
+  fail('Zeitüberschreitung: $finder ${gone ? "verschwindet nicht" : "nicht gefunden"}');
+}

integration_test/livekit_token_connect_test.dart

@@ -0,0 +1,67 @@
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:pyramid/core/matrix_client.dart';
+import 'package:pyramid/features/voice_channel/voice_channel_service.dart';
+import 'package:pyramid/main.dart' as app;
+
+/// Echter Beitritt zu LiveKit mit einem vom SERVER ausgestellten Token
+/// (docs/LIVEKIT_TOKEN_MIGRATION.md) – über denselben Weg wie die App
+/// (voiceChannelProvider.startCall), nur mit dem TEST-Konto.
+///
+/// Läuft nur mit gesetztem PYRAMID_PROFILE_DIR (eingeloggtes Testprofil,
+/// z. B. pyramidtest1) – nie gegen Bernds echtes Profil:
+///
+///   $env:PYRAMID_PROFILE_DIR="$env:USERPROFILE\.pyramid-autopilot\profile1"
+///   flutter test integration_test/livekit_token_connect_test.dart -d windows
+///
+/// Betritt einen eigenen Wegwerf-Raum („pyramid-tokentest“), nur Ton, und
+/// legt sofort wieder auf. Ersetzt NICHT den Anruftest auf dem Handy.
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final profile = Platform.environment['PYRAMID_PROFILE_DIR'];
+
+  testWidgets(
+    'LiveKit-Beitritt mit Server-Token: Identität = eigene Matrix-ID',
+    (tester) async {
+      app.main();
+      final end = DateTime.now().add(const Duration(seconds: 90));
+      while (find.byType(MaterialApp).evaluate().isEmpty &&
+          DateTime.now().isBefore(end)) {
+        await tester.pump(const Duration(milliseconds: 200));
+      }
+      final container = ProviderScope.containerOf(
+        tester.element(find.byType(MaterialApp).first),
+      );
+      final client = await tester.runAsync(
+        () => container.read(matrixClientProvider.future),
+      );
+      expect(client!.isLogged(), isTrue, reason: 'Testprofil nicht angemeldet');
+
+      final call = container.read(voiceChannelProvider);
+      await tester.runAsync(() => call.startCall(
+            roomName: 'pyramid-tokentest',
+            roomDisplayName: 'Token-Test',
+            identity: 'wird-vom-server-ignoriert',
+            audioOnly: true,
+            matrixClient: client,
+          ));
+      await tester.pump(const Duration(milliseconds: 500));
+
+      expect(call.error, isNull, reason: 'Beitritt fehlgeschlagen');
+      expect(call.room, isNotNull, reason: 'keine LiveKit-Verbindung');
+      // Der Server bestimmt die Identität aus dem geprüften Matrix-Login –
+      // der vom Client übergebene Wert spielt keine Rolle mehr.
+      expect(call.room!.localParticipant?.identity, client.userID);
+
+      await tester.runAsync(() => call.hangUp());
+      await tester.pump(const Duration(milliseconds: 500));
+      expect(call.room, isNull);
+    },
+    skip: profile == null,
+    timeout: const Timeout(Duration(minutes: 3)),
+  );
+}

integration_test/mobile_ui_screens_test.dart

@@ -0,0 +1,312 @@
+import 'dart:io';
+import 'dart:ui' as ui;
+
+import 'package:flutter/material.dart';
+import 'package:flutter/rendering.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:integration_test/integration_test.dart';
+import 'package:pyramid/core/app_state.dart';
+import 'package:pyramid/core/appearance.dart';
+import 'package:pyramid/core/theme.dart';
+import 'package:pyramid/main.dart' as app;
+import 'package:pyramid/widgets/spring_press.dart';
+
+/// UI-Durchlauf im HANDY-Format mit der echten App (Windows-Build) und einem
+/// TEST-Profil – erzeugt Screenshots unter build/ui_screens/.
+///
+/// Läuft nur mit gesetztem PYRAMID_PROFILE_DIR (eingeloggtes Testprofil, z. B.
+/// pyramidtest1 unter %USERPROFILE%\.pyramid-autopilot\profile1) – nie gegen
+/// Bernds echtes Profil. Testinhalte vorher mit
+/// `test/live_ui_fixture_test.dart` anlegen (DM + Gruppe mit pyramidtest2).
+///
+///   $env:PYRAMID_PROFILE_DIR="$env:USERPROFILE\.pyramid-autopilot\profile1"
+///   flutter test integration_test/mobile_ui_screens_test.dart -d windows
+///
+/// Achtung: Keine zweite Pyramid-Instanz auf demselben Profil laufen lassen
+/// (zwei Clients auf einer olm-DB). Ansichten (Darstellung, Farbmodus, Raum)
+/// werden nur über den App-Zustand umgeschaltet – nichts wird gespeichert.
+///
+/// Simuliert wird ein typisches Handy: 1080×2340 px, Dichte 2,625
+/// (≈ 411×891 dp), Statusleiste oben 24 dp, Gestenleiste unten 16 dp.
+const _otherUser = 'pyramidtest2';
+const _groupName = 'UI-Test Gruppe';
+
+void main() {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final profile = Platform.environment['PYRAMID_PROFILE_DIR'];
+
+  testWidgets(
+    'Handy-UI: Chatliste, Chat, Bild-Vollansicht, Gruppe, Einstellungen',
+    (tester) async {
+      tester.view
+        ..physicalSize = const Size(1080, 2340)
+        ..devicePixelRatio = 2.625
+        ..padding = const FakeViewPadding(top: 63, bottom: 42)
+        ..viewPadding = const FakeViewPadding(top: 63, bottom: 42);
+      addTearDown(tester.view.reset);
+      final size = tester.view.physicalSize / tester.view.devicePixelRatio;
+
+      app.main();
+      await _pumpUntil(
+        tester,
+        find.text(_otherUser),
+        timeout: const Duration(seconds: 90),
+      );
+      final container = ProviderScope.containerOf(
+        tester.element(find.byType(MaterialApp).first),
+      );
+      await _shot(tester, '01_chatliste');
+
+      // ── Direktnachricht: Sprechblasen (Handy-Standard) und Liste ──
+      await tester.tap(find.text(_otherUser).first);
+      // Chat gleitet federnd über die Liste.
+      await tester.pump(const Duration(milliseconds: 90));
+      await _shot(tester, '01b_chat_gleitet_herein');
+      await _pumpFor(tester, const Duration(seconds: 6));
+      await _scrollToNewest(tester);
+      await _shot(tester, '02_chat');
+
+      // Kontakt-Banner aufklappen (Tipp auf den Namen im Kopf) und wieder zu.
+      await tester.tap(find.text(_otherUser).first);
+      await _pumpFor(tester, const Duration(seconds: 1));
+      await _shot(tester, '02c_dm_kopf_aufgeklappt');
+      await tester.tap(find.text(_otherUser).first);
+      await _pumpFor(tester, const Duration(seconds: 1));
+
+      // Antwort-Zitat antippen → springt zur zitierten Nachricht.
+      final quote = find.byWidgetPredicate(
+        (w) => w is SpringPress && w.pressedScale == 0.97,
+      );
+      await tester.scrollUntilVisible(
+        quote.first,
+        300,
+        scrollable: find.byType(Scrollable).first,
+        maxScrolls: 40,
+      );
+      await _pumpFor(tester, const Duration(milliseconds: 600));
+      await _shot(tester, '02e_zitat_vor_dem_tippen');
+      await tester.tap(quote.first, warnIfMissed: false);
+      await _pumpFor(tester, const Duration(milliseconds: 900));
+      await _shot(tester, '02f_sprung_zum_zitat');
+      await _scrollToNewest(tester);
+
+      // ⋮-Menü mit Suchen/Mitglieder.
+      await tester.tap(find.byIcon(Icons.more_vert_rounded).first);
+      await _pumpFor(tester, const Duration(seconds: 1));
+      expect(find.text('Mitglieder'), findsWidgets);
+      await _shot(tester, '02d_menue');
+      await tester.tapAt(Offset(size.width / 2, size.height / 2));
+      await _pumpFor(tester, const Duration(seconds: 1));
+
+      // Antworten → Antwort-Leiste federt auf. (Wischen zum Antworten gibt
+      // es nur auf echten Handys; hier über Lange-Drücken → Antworten.)
+      // Neben die eigene Sprechblase drücken (nicht in den Text – dort
+      // greift am PC die Textauswahl).
+      final ownMsg = tester.getCenter(find.text('Danke, sieht gut aus!').first);
+      await tester.longPressAt(Offset(size.width * 0.15, ownMsg.dy));
+      await _pumpFor(tester, const Duration(milliseconds: 500));
+      await tester.tap(find.byIcon(Icons.reply_rounded).first);
+      await tester.pump(const Duration(milliseconds: 60));
+      await _shot(tester, '02g_antwort_leiste_federt');
+      await _pumpFor(tester, const Duration(milliseconds: 800));
+      await _shot(tester, '02h_antwort_leiste');
+      final closeReply = find.byIcon(Icons.close_rounded);
+      if (closeReply.evaluate().isNotEmpty) {
+        await tester.tap(closeReply.first);
+        await _pumpFor(tester, const Duration(milliseconds: 600));
+      }
+
+      container.read(messageStyleProvider.notifier).state = MessageStyle.list;
+      await _pumpFor(tester, const Duration(seconds: 2));
+      await _shot(tester, '02b_chat_liste');
+      container.read(messageStyleProvider.notifier).state = MessageStyle.auto;
+      await _pumpFor(tester, const Duration(seconds: 2));
+
+      // ── Bild-Vollansicht ──
+      // Größtes Bild im Chat = eines der Testbilder; erst sichtbar scrollen.
+      Future<void> openViewer() async {
+        final image = _largestImage(tester);
+        expect(image, isNotNull, reason: 'kein Bild im Test-Chat gefunden');
+        await tester.ensureVisible(image!);
+        await _pumpFor(tester, const Duration(milliseconds: 600));
+        await tester.tap(image);
+        await _pumpFor(tester, const Duration(seconds: 2));
+        expect(
+          find.byType(InteractiveViewer),
+          findsOneWidget,
+          reason: 'Antippen des Bildes hat die Vollansicht nicht geöffnet',
+        );
+      }
+
+      await openViewer();
+      await _shot(tester, '03_vollansicht');
+
+      // Tippen NEBEN das Bild (ganz unten, unter dem Bild) schließt.
+      await tester.tapAt(Offset(size.width / 2, size.height - 30));
+      await _pumpFor(tester, const Duration(seconds: 2));
+      await _shot(tester, '04_nach_tippen_daneben');
+      expect(
+        find.byType(InteractiveViewer),
+        findsNothing,
+        reason: 'Tippen neben das Bild hat die Vollansicht nicht geschlossen',
+      );
+
+      // Tippen AUFS Bild schließt NICHT (blendet nur die Leiste aus).
+      await openViewer();
+      await tester.tapAt(Offset(size.width / 2, size.height / 2));
+      await _pumpFor(tester, const Duration(seconds: 1));
+      expect(
+        find.byType(InteractiveViewer),
+        findsOneWidget,
+        reason: 'Tippen aufs Bild darf die Vollansicht nicht schließen',
+      );
+
+      // Doppeltipp zoomt hinein, nochmal doppelt wieder heraus.
+      Future<void> doubleTapCenter() async {
+        await tester.tapAt(Offset(size.width / 2, size.height / 2));
+        await tester.pump(const Duration(milliseconds: 80));
+        await tester.tapAt(Offset(size.width / 2, size.height / 2));
+        await _pumpFor(tester, const Duration(seconds: 1));
+      }
+
+      await doubleTapCenter();
+      final viewer = tester.widget<InteractiveViewer>(
+        find.byType(InteractiveViewer),
+      );
+      expect(
+        viewer.transformationController!.value.getMaxScaleOnAxis(),
+        greaterThan(1.5),
+        reason: 'Doppeltipp hat nicht gezoomt',
+      );
+      await _shot(tester, '05_doppeltipp_zoom');
+      await doubleTapCenter();
+
+      // Wischen nach unten schließt.
+      await tester.dragFrom(
+        Offset(size.width / 2, size.height / 2),
+        const Offset(0, 320),
+      );
+      await _pumpFor(tester, const Duration(seconds: 2));
+      expect(
+        find.byType(InteractiveViewer),
+        findsNothing,
+        reason: 'Wischen nach unten hat die Vollansicht nicht geschlossen',
+      );
+      await _shot(tester, '06_nach_wischen');
+
+      // ── Farbmodus Hell (nur Zustand) ──
+      final savedVariant = container.read(themeVariantProvider);
+      container.read(themeVariantProvider.notifier).state = ThemeVariant.light;
+      await _pumpFor(tester, const Duration(seconds: 2));
+      await _shot(tester, '07_chat_hell');
+      container.read(themeVariantProvider.notifier).state = savedVariant;
+      await _pumpFor(tester, const Duration(seconds: 1));
+
+      // ── Gruppenraum (Namen + Avatare in den Sprechblasen) ──
+      container.read(activeRoomIdProvider.notifier).state = null;
+      container.read(activeSpaceIdProvider.notifier).state = 'rooms';
+      await _pumpUntil(
+        tester,
+        find.text(_groupName),
+        timeout: const Duration(seconds: 30),
+      );
+      await tester.tap(find.text(_groupName).first);
+      await _pumpFor(tester, const Duration(seconds: 5));
+      await _scrollToNewest(tester);
+      await _shot(tester, '08_gruppe');
+
+      // ── Einstellungen → Erscheinungsbild ──
+      container.read(activeModalProvider.notifier).state = ModalKind.settings;
+      await _pumpFor(tester, const Duration(seconds: 2));
+      await tester.tap(find.text('Erscheinungsbild').first);
+      await _pumpFor(tester, const Duration(seconds: 2));
+      await _shot(tester, '09_einstellungen_erscheinungsbild');
+      await tester.drag(
+        find.text('Schriftgröße').first,
+        const Offset(0, -500),
+        warnIfMissed: false,
+      );
+      await _pumpFor(tester, const Duration(seconds: 1));
+      await _shot(tester, '10_einstellungen_text_chat');
+      container.read(activeModalProvider.notifier).state = ModalKind.none;
+      await _pumpFor(tester, const Duration(seconds: 1));
+
+      // ── Zurück zur Chatliste: Chat gleitet hinaus, Liste bleibt erhalten ──
+      container.read(activeRoomIdProvider.notifier).state = null;
+      await tester.pump(const Duration(milliseconds: 90));
+      await _shot(tester, '11_zurueck_gleitet_hinaus');
+      await _pumpFor(tester, const Duration(seconds: 1));
+      expect(find.text(_groupName), findsWidgets);
+      await _shot(tester, '12_liste_nach_zurueck');
+    },
+    skip: profile == null,
+    timeout: const Timeout(Duration(minutes: 6)),
+  );
+}
+
+Finder? _largestImage(WidgetTester tester) {
+  Element? best;
+  var bestArea = 150.0 * 150.0;
+  for (final element in find.byType(Image).evaluate()) {
+    final box = element.renderObject;
+    if (box is! RenderBox || !box.hasSize) continue;
+    final area = box.size.width * box.size.height;
+    if (area > bestArea) {
+      bestArea = area;
+      best = element;
+    }
+  }
+  return best == null ? null : find.byElementPredicate((e) => e == best);
+}
+
+/// Ganz nach unten zu den neuesten Nachrichten scrollen.
+Future<void> _scrollToNewest(WidgetTester tester) async {
+  for (var i = 0; i < 6; i++) {
+    final lists = find.byType(Scrollable);
+    if (lists.evaluate().isEmpty) return;
+    await tester.fling(lists.first, const Offset(0, -1500), 3000,
+        warnIfMissed: false);
+    await _pumpFor(tester, const Duration(milliseconds: 500));
+  }
+  await _pumpFor(tester, const Duration(seconds: 2));
+}
+
+Future<void> _pumpFor(WidgetTester tester, Duration duration) async {
+  final end = DateTime.now().add(duration);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 100));
+  }
+}
+
+Future<void> _pumpUntil(
+  WidgetTester tester,
+  Finder finder, {
+  required Duration timeout,
+}) async {
+  final end = DateTime.now().add(timeout);
+  while (DateTime.now().isBefore(end)) {
+    await tester.pump(const Duration(milliseconds: 200));
+    if (finder.evaluate().isNotEmpty) return;
+  }
+  fail('Zeitüberschreitung: $finder nicht gefunden');
+}
+
+/// Speichert, was gerade auf dem (simulierten) Bildschirm ist.
+Future<void> _shot(WidgetTester tester, String name) async {
+  await tester.pump();
+  final renderView = tester.binding.renderViews.first;
+  final layer = renderView.debugLayer! as OffsetLayer;
+  final physical = tester.view.physicalSize;
+  final image = await tester.binding.runAsync(
+    () => layer.toImage(Offset.zero & physical),
+  );
+  final bytes = await tester.binding.runAsync(
+    () => image!.toByteData(format: ui.ImageByteFormat.png),
+  );
+  final file = File('build/ui_screens/$name.png');
+  file.parent.createSync(recursive: true);
+  file.writeAsBytesSync(bytes!.buffer.asUint8List());
+  // ignore: avoid_print
+  print('Screenshot: ${file.path}');
+}

ios/Runner.xcodeproj/project.pbxproj

@@ -431,7 +431,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = AppIcon;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
@@ -488,7 +488,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = AppIcon;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";