docs: rewrite documentation and README from current codebase, add flaw analysis

Remove outdated claims (CRDT, DocRooms, presence, .md files on disk) and
document the actual architecture, API, permissions and known flaws.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

Doku/README.md

@@ -1,134 +1,40 @@
-# 📚 MindSift Technische Dokumentation & Wiki
+# MindSift Technische Dokumentation
 
-Willkommen in der zentralen technischen Dokumentation von **MindSift**. Dieses Wiki dient als verbindliche, tiefgehende Referenz für Entwickler, DevOps-Ingenieure und Systemadministratoren. Es dokumentiert die Architektur, das Datenmodell, APIs, Echtzeit-Protokolle, Kernmodule sowie bekannte technische Schwachstellen der Plattform.
+Referenz für Entwickler und Administratoren. Alle Angaben wurden gegen den Code im Branch `dev` geprüft (Stand Oktober 2026). Abweichungen zwischen Doku und Code melde bitte als Fehler in [flaws.md](flaws.md).
 
----
+## Inhalt
 
-## 🧭 Inhaltsverzeichnis (Wiki-Navigation)
+| Dokument | Inhalt |
+|---|---|
+| [architecture.md](architecture.md) | Aufbau, Technologie-Stack, Start, Konfiguration, Build |
+| [database.md](database.md) | SQLite-Schema, Migrationen, Datenmodell |
+| [api/rest.md](api/rest.md) | Alle REST-Endpunkte |
+| [api/websocket.md](api/websocket.md) | Echtzeit über WebSocket und SSE, Ereignisse |
+| [modules/triage.md](modules/triage.md) | Schnellerfassung und Triage |
+| [modules/tasks.md](modules/tasks.md) | Aufgaben, Kanban, Alarme |
+| [modules/workspace.md](modules/workspace.md) | Outliner-Notizen, Ordner, Tags |
+| [modules/lists.md](modules/lists.md) | Geteilte Listen |
+| [sharing-and-permissions.md](sharing-and-permissions.md) | Rollen, Gruppen, Freigaben |
+| [reverse-proxy.md](reverse-proxy.md) | Nginx, Traefik, Caddy, Cloudflare |
+| [theming.md](theming.md) | Themes und Design-Variablen |
+| [flaws.md](flaws.md) | Bekannte Schwachstellen und technische Schulden |
 
-```
-Doku/
-├── README.md                  # Einstieg, Inhaltsverzeichnis & Gesamtübersicht (dieses Dokument)
-├── architecture.md            # Systemarchitektur, Schichtenmodell, Concurrency & Stack
-├── database.md                # SQLite-Datenbankdesign, Schemas, Indizes & Migrationen
-├── api/
-│   ├── rest.md                # Vollständige REST-API Referenz aller Endpunkte
-│   └── websocket.md           # WebSocket-Echtzeitprotokoll, Rooms & Document Locking
-├── modules/
-│   ├── triage.md              # Modul 1: Triage & Quick-Dump (State Machine & Audio)
-│   ├── tasks.md               # Modul 2: Aufgaben & Kanban-System (Alarme & Scheduler)
-│   ├── workspace.md           # Modul 3: Workspace Outliner-Engine, Wiki-Links & Pure-DB Storage
-│   └── lists.md               # Modul 4: Geteilte Listen (Live-Kollaboration & D&D)
-├── sharing-and-permissions.md # Synchrones Teilen, Rollen, Isolation & Mount-Entkopplung
-├── reverse-proxy.md           # Nginx, Traefik, Caddy, Cloudflare Konfiguration & SSE
-├── theming.md                 # Single-File CSS Theme-Engine & Design-System
-└── flaws.md                   # Technische Schwachstellen, Risiken & zukünftige Optimierungen
-```
+## Überblick in 60 Sekunden
 
-### 📑 Kapitel im Detail
-1. **[Systemarchitektur & Technologie-Stack](architecture.md)**  
-   Schichtenmodell, Go-Backend, React-Frontend, Concurrency-Handling und Thread-Safety.
-2. **[Datenbank-Design & SQLite Schema](database.md)**  
-   Vollständiges relationales Datenmodell, ER-Diagramm, Tabellendefinitionen, Indizes und Migrationsstrategie.
-3. **[REST-API Referenz](api/rest.md)**  
-   Spezifikation aller Endpunkte für Authentifizierung, Gedanken, Aufgaben, Dokumente, Listen, Teams und Webhooks.
-4. **[WebSocket & Echtzeit-Synchronisation](api/websocket.md)**  
-   Gorilla WebSocket Hub, Rooms, Presence-Tracking, Yjs CRDT Kollaboration und SSE Fallback.
-5. **[Kernmodul: Triage & Quick-Dump](modules/triage.md)**  
-   Instant-Capture-Pipeline, Finite State Machine, Gestensteuerung, Spracheingabe und Webhook-Ingestion.
-6. **[Kernmodul: Aufgaben & Kanban-System](modules/tasks.md)**  
-   Multi-Listen-Konzept, 3-Spalten Kanban-Board, Subtasks, Fälligkeiten und Multi-Channel Alarm-Ticker (SMTP, Discord, Webhooks).
-7. **[Kernmodul: Workspace & Outliner-Engine](modules/workspace.md)**  
-   Logseq-inspirierte hierarchische Block-Engine, Zoom-Hoisting, Wiki-Links, Pure-Database Storage und Globales To-Do Rollup.
-8. **[Kernmodul: Geteilte Listen & Kollaboration](modules/lists.md)**  
-   Listen-Typen, Mengen, Kategorien, Live-Checkoff und Drag & Drop Sortierung.
-9. **[Synchrones Teilen & Berechtigungskonzept](sharing-and-permissions.md)**  
-   Rollenmodell (Admin/Member), System-Isolations-Modi (`strict_private`, `teams_only`, `open`), entkoppelte Ordner-Mounts und Notizen-Freigaben.
-10. **[Reverse-Proxy- & Ingress-Handbuch](reverse-proxy.md)**  
-    Produktionsfertige Konfigurationen für Nginx, Traefik, Caddy, Cloudflare und Apache mit WebSocket-Upgrades und SSE-Streaming.
-11. **[Single-File Theming & Design-System](theming.md)**  
-    1-Datei = 1-Theme Philosophie, die 6 CSS-Variablen-Blöcke, Semantische CSS-Klassen und Geometrie-Steuerung.
-12. **[Technische Schwachstellen & Optimierungspotenziale (Flaws)](flaws.md)**  
-    Kritische Analyse von Concurrency-Grenzen, Volltextsuche, Viewport-Anpassung und Skalierungs-Engpässen.
+- **Ein Go-Binary** liefert REST-API, WebSocket/SSE und das eingebettete React-Frontend (`go:embed`). Es gibt genau einen Container und eine SQLite-Datei (`/data/mindsift.db`).
+- **Datenhaltung:** vollständig in SQLite. Es gibt keine `.md`-Dateien auf der Platte; Markdown wird bei Bedarf aus den Blöcken erzeugt (`documents.markdown_cache`, Export als `.md`).
+- **Echtzeit:** ein Hub mit Räumen und Benutzer-Kanälen. Verteilt werden Ereignisse nach REST-Änderungen. Es gibt keine CRDTs, Sperren oder Cursor-Presence.
+- **Auth:** JWT (HS256, 30 Tage) mit `token_version` und Sperrliste, dazu API-Keys (`mindsift_sec_…`) für Webhooks.
+- **Freigaben:** Aufgabenlisten und geteilte Listen mit Rolle Bearbeiter oder Leser, Notizen und Ordner nur lesend.
 
----
+## Entwickeln
 
-## 🏛️ Systemübersicht (High-Level Architektur)
-
-```mermaid
-graph TB
-    subgraph Client ["Client Layer (Browser / PWA)"]
-        UI["React 18 SPA (Vite, TS, Tailwind)"]
-        WSClient["WebSocket Client (Auto-Reconnect)"]
-        Cache["IndexedDB / Offline Queue"]
-    end
-
-    subgraph ReverseProxy ["Reverse Proxy / Gateway"]
-        Traefik["Traefik / Nginx (HTTPS, WSS, Rate Limits)"]
-    end
-
-    subgraph Backend ["Backend Layer (Go 1.23 Engine)"]
-        ChiRouter["Chi Router (REST API)"]
-        WSHub["Gorilla WebSocket Hub & Lock Manager"]
-        AlarmTicker["Alarm Scheduler (Background Ticker)"]
-        StorageEngine["Storage Layer (Domain & Repositories)"]
-    end
-
-    subgraph Storage ["Storage Layer"]
-        SQLite[("SQLite WAL Database (/data/mindsift.db)")]
-    end
-
-    subgraph External ["Externe Schnittstellen"]
-        HomeAssistant["Home Assistant / Webhooks"]
-        Discord["Discord Webhooks"]
-        SMTPServer["SMTP Server (E-Mail Alarme)"]
-    end
-
-    UI -->|HTTPS REST| Traefik
-    WSClient -->|WSS Realtime| Traefik
-    Traefik --> ChiRouter
-    Traefik --> WSHub
-    ChiRouter --> StorageEngine
-    StorageEngine --> SQLite
-    AlarmTicker --> Discord
-    AlarmTicker --> SMTPServer
-    HomeAssistant -->|POST /api/v1/inbox| Traefik
-    HomeAssistant -->|POST /api/v1/webhooks/ingest| Traefik
-```
-
----
-
-## 🛠️ Schnellstart für Entwickler
-
-### Voraussetzungen
-- **Go:** 1.22 oder 1.23+
-- **Node.js:** 20+ (LTS) & npm
-- **Container-Runtime:** Docker oder Podman
-
-### Lokale Entwicklung ohne Container
 ```bash
-# 1. Repository klonen
-git clone https://git.dsit.me/sandrodach/MindSift.git
-cd MindSift
+# Backend (Go 1.23)
+go vet ./... && go test ./...
 
-# 2. Frontend Abhängigkeiten installieren & Dev-Server starten
-cd frontend
-npm install
-npm run dev
-
-# 3. Backend starten (in neuem Terminal)
-cd ..
-go run ./cmd/server
+# Frontend (Node 22)
+cd frontend && npm ci && npx tsc --noEmit && npm run build
 ```
 
-### Container Build & Testlauf (wie in der CI/CD)
-```bash
-# Backend-Tests ausführen
-podman run --rm -v $(pwd):/app:z -w /app golang:1.23 go test -v ./internal/...
-
-# Frontend Typecheck & Build testen
-podman run --rm -v $(pwd):/app:z -w /app/frontend node:20 sh -c "npx tsc --noEmit && npm run build"
-
-# Komplettes Multi-Stage Image bauen
-podman build -t mindsift:dev .
-```
+Das Frontend wird für das Binary nach `cmd/server/dist` gebaut (siehe `Dockerfile`). Die CI läuft unter `.gitea/workflows/build-and-publish.yaml`.

Doku/api/rest.md

@@ -1,185 +1,129 @@
-# 🔌 REST-API Referenz
+# REST-API
 
-Die MindSift REST-API ermöglicht den vollständigen Zugriff auf Gedanken, Aufgaben, Workspace-Notizen, Listen, Benutzerkonten und Smarthome-Automationen.
+Basis: `/api/v1`. Antworten sind JSON; Fehler haben die Form `{"error": "Text"}`. Authentifizierung über `Authorization: Bearer <JWT>` oder `Bearer mindsift_sec_…` bzw. Header `X-API-Key`. Zeitstempel sind ISO-8601 (UTC). Quelle der Wahrheit sind die Routen in [server.go](../../internal/api/server.go).
 
----
+## Öffentlich
 
-## 🔐 1. Authentifizierung
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET | `/health` | Lebenszeichen |
+| GET | `/auth/status` | `needsSetup`, `allowRegistration`, `instanceName`, `demoMode` |
+| POST | `/auth/setup` | Erstes Administratorkonto (`email`, `password`, `displayName`, `instanceName`, `allowRegistration`, `sharingMode`, `seedSampleData`); nur solange es keine Konten gibt |
+| POST | `/auth/register` | Registrierung (`email`, `password`, `displayName`, `inviteCode`); nur mit Code oder wenn freigegeben |
+| POST | `/auth/login` | Anmeldung (`login`/`email`/`username`, `password`) → `{token, user}` |
+| POST | `/auth/quickstart` | Immer `403` (Gastzugang deaktiviert) |
+| POST | `/webhooks/ingest` | Aufgabe per Webhook anlegen, Token als `?token=`, `X-API-Key` oder Bearer. Body: `title`/`content`/`text`/`message`, `priority`, `source`, `tags`, `dueDate`; Klartext-Body wird als Inhalt genommen |
+| GET | `/ws`, `/ws/spaces/{id}`, `/ws/lists/{id}` | WebSocket, siehe [websocket.md](websocket.md) |
+| GET | `/events` | SSE-Fallback |
+| POST | `/events/rooms` | SSE-Räume beitreten/verlassen ([FLAW-02](../flaws.md)) |
 
-MindSift unterstützt zwei Authentifizierungsmethoden:
+## Konto und Allgemeines (angemeldet)
 
-1. **JSON Web Token (JWT Bearer):**  
-   Wird beim Login oder Setup erzeugt und im HTTP-Header mitgesendet:  
-   `Authorization: Bearer <jwt-token>`
-2. **Persönliche API-Schlüssel (Smarthome / Automatisierung):**  
-   Werden unter *Einstellungen ➔ Private Webhooks* erzeugt (Präfix `mindsift_sec_...`):  
-   - Per HTTP-Header: `X-API-Key: mindsift_sec_xxxxxxxxxxxx`
-   - Per Authorization-Header: `Authorization: Bearer mindsift_sec_xxxxxxxxxxxx`
-   - Per Query-Parameter: `?token=mindsift_sec_xxxxxxxxxxxx`
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET | `/auth/me` | Benutzer und Kennzahlen |
+| POST | `/auth/logout` | Token sperren |
+| POST | `/auth/revoke-all` | Alle Sitzungen beenden (`token_version` +1) |
+| PATCH | `/auth/settings` | `displayName`, `email`, `password`, `avatarUrl`, `alarmChannels`, `alarmEmail`, `discordWebhookUrl`, `customWebhookUrl`, `notifyBeforeMinutes` |
+| POST | `/auth/alarms/test` | Test-Alarm (`channel`: `email`/`discord`/`webhook`, optional `target`) |
+| GET | `/users/directory`, `/collaborators` | Benutzerverzeichnis für Freigaben ([FLAW-10](../flaws.md)) |
+| GET | `/stats` | Zähler fürs Dashboard |
+| GET | `/search?q=` | Suche in eigenen Gedanken und Notizen |
+| GET | `/export` | Datenexport als JSON |
+| GET/POST/DELETE | `/keys`, `/keys/{id}` | API-Keys verwalten (Klartext nur bei Erstellung) |
 
----
+## Gedanken, Triage, Aufgaben
 
-## 🚦 2. Status- & Fehler-Codes
+| Methode | Pfad | Zweck |
+|---|---|---|
+| POST | `/inbox` | Schnellerfassung. Body: `content`, `priority`, `source`, `dueDate`, `target` (`inbox`/`task`/`list_item`/`document`), `targetListId`, `taskListId` (snake_case-Varianten werden akzeptiert) |
+| GET | `/thoughts?status=` | Gedanken (`inbox`, `kept`, `converted`, `discarded`, `all`) |
+| GET/PATCH/DELETE | `/thoughts/{id}` | Einzelabruf; Teiländerung (`content`, `isCompleted`, `dueDate`, `priority`, `taskListId`, `kanbanStatus`, `notes`, `subtasks`, `tags`); Löschen |
+| DELETE | `/thoughts/discarded/purge` | Papierkorb leeren |
+| GET | `/triage/deck` | Posteingang (max. 100) |
+| PATCH | `/triage/{id}` | `action`: `keep`/`discard`/`restore`; mit `convertTo`: `task`/`document`/`list_item` |
+| GET | `/tasks?taskListId=` | Aufgaben (optional einer Liste) |
+| POST | `/tasks/reorder`, `/task-lists/{id}/tasks/reorder` | Reihenfolge/Spalte ändern (`items[{id, sortOrder, kanbanStatus}]`) |
+| POST | `/tasks/{id}/unlink` | Verknüpfung zu Notiz-Block lösen |
 
-- `200 OK`: Erfolgreiche Abfrage oder Aktualisierung.
-- `201 Created`: Ressource erfolgreich angelegt.
-- `400 Bad Request`: Ungültiges JSON oder fehlende Pflichtfelder.
-- `401 Unauthorized`: Token ungültig, abgelaufen oder fehlend.
-- `403 Forbidden`: Unzureichende Berechtigungen (z.B. nur Server-Admin oder nur Lesezugriff).
-- `404 Not Found`: Ressource existiert nicht oder gehört einem anderen Benutzer.
-- `409 Conflict`: Ressource gesperrt (z.B. Dokument wird bereits von anderem Benutzer bearbeitet).
+## Aufgabenlisten
 
-Fehlerrückgaben erfolgen im einheitlichen Format:
-```json
-{
-  "error": "Fehlermeldung im Klartext"
-}
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET/POST | `/task-lists` | Listen (`permission` je Liste: `owner`/`editor`/`viewer`); anlegen (`title`, `icon`, `color`, `teamId`) |
+| PUT/DELETE | `/task-lists/{id}` | Ändern (`title`, `icon`, `color`, `teamId`, `columns`) – nicht für Leser; Löschen nur Eigentümer |
+| GET | `/task-lists/{id}/shares` | Freigaben |
+| POST | `/task-lists/{id}/shares` | Nur Eigentümer. Body: `targetType` (`team`/`user`), `targetId`, `permission` (`editor`/`viewer`, Standard `editor`). Erneutes Senden für dasselbe Ziel ändert die Stufe |
+| DELETE | `/task-lists/{id}/shares/{shareId}` | Nur Eigentümer |
+
+Schreibzugriffe von Lesern auf Listen oder deren Aufgaben liefern `403` („Keine Schreibrechte für diese Aufgabenliste (nur Lesen)“).
+
+## Workspace
+
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET/POST/DELETE | `/folders` | Ordnerliste, anlegen (`path`), löschen |
+| POST | `/folders/move` | `sourcePath`, `targetParentPath` |
+| GET/POST | `/workspace/folders/shared` | Geteilte Ordner; anlegen (`name`, `mountPath`) |
+| GET/DELETE | `/workspace/folders/shared/{id}` | Abruf; Löschen |
+| PUT | `/workspace/folders/shared/{id}/mount` | Eigenen Einhängepfad ändern (`mountPath`) |
+| GET/POST/DELETE | `/workspace/folders/shared/{id}/shares[/{shareId}]` | Freigaben (nur Lesen wirksam) |
+| GET | `/workspace/tags`, `/workspace/tags/{tag}` | Tag-Übersicht und -Details |
+| PUT | `/workspace/tags/{tag}/note` | Tag-Seite speichern (`content`) |
+| GET/POST | `/documents` | Notizen auflisten; anlegen (`title`, `icon`, `folderPath`, `blocks`, `tags`, `isPinned`) |
+| GET/PUT/DELETE | `/documents/{id}` | Abruf; Ändern (`title`, `icon`, `folderPath`, `blocks`, `tags`, `isPinned`); Löschen |
+| PATCH | `/documents/{id}/blocks` | Teil-Update der Blöcke (`upserted`, `deletedIds`, Reihenfolge); löst `DOC_BLOCKS_PATCHED` aus |
+| PUT | `/documents/{id}/move` | Ordner wechseln (`folderPath`) |
+| POST | `/documents/{id}/blocks/{blockId}/enhanced-task` | Aus einem Block eine verknüpfte Aufgabe machen (`content`, `checked`) |
+| GET/POST/DELETE | `/documents/{id}/shares[/{userId}]` | Notiz-Freigaben (`userId`/`email`/`teamId`; wirksam nur Lesen) |
+
+Nur der Eigentümer schreibt in eine Notiz; Empfänger erhalten `403`/„nur Lesezugriff“ ([FLAW-17](../flaws.md)).
+
+## Geteilte Listen
+
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET/POST | `/lists` | Listen; anlegen (`title`, `icon`, `listType`) |
+| GET/DELETE | `/lists/{id}` | Abruf mit Einträgen; Löschen |
+| GET/POST/DELETE | `/lists/{id}/shares[/{shareId}]` | Freigaben (`targetType`, `targetId`, `role`: `editor`/`viewer`) |
+| POST | `/lists/{id}/items` | Eintrag (`content`, `category`, `quantity`) |
+| PATCH | `/lists/{id}/items/{itemId}` | Abhaken (`isCompleted`) |
+| PUT | `/lists/{id}/items/{itemId}` | Ändern (`content`, `category`, `quantity`) |
+| DELETE | `/lists/{id}/items/{itemId}` | Löschen |
+| POST/PUT | `/lists/{id}/items/reorder` | Reihenfolge/Kategorie (`items[{id, sortOrder, category, content}]`) |
+| POST | `/lists/{id}/clear-completed` | Erledigte entfernen |
+
+## Gruppen
+
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET/POST | `/teams` | Eigene Gruppen; anlegen (`name`, `description`) – Ersteller wird Gruppen-Admin |
+| PUT/DELETE | `/teams/{id}` | Nur Gruppen-Admin |
+| POST | `/teams/{id}/members` | Mitglied hinzufügen (`userId` oder `email`, `role`) |
+| PUT/DELETE | `/teams/{id}/members/{userId}` | Rolle ändern (`admin`/`member`); entfernen |
+| GET/POST/DELETE | `/organizations`, `/organizations/{id}[/teams]` | Veraltet, ungeschützt ([FLAW-24](../flaws.md)) |
+
+## Administration (`role = admin`)
+
+| Methode | Pfad | Zweck |
+|---|---|---|
+| GET/POST | `/admin/users` | Benutzer auflisten, anlegen (`email`, `password`, `displayName`, `role`) |
+| PATCH/DELETE | `/admin/users/{id}` | `displayName`, `email`, `role`, `isActive`, `discordWebhookUrl`; löschen |
+| PUT | `/admin/users/{id}/password` | Passwort zurücksetzen |
+| GET/POST/DELETE | `/admin/invites[/{id}]` | Einladungen (`email`, `role`, `teamId`, `validDays`) |
+| GET/PUT | `/admin/settings` | `instanceName`, `allowRegistration`, `sharingMode`, SMTP-Felder |
+| POST | `/admin/smtp/test` | Testmail (`toEmail`) |
+
+## Beispiele
+
+```bash
+# Gedanken per API-Key erfassen
+curl -X POST https://mindsift.example.com/api/v1/webhooks/ingest \
+  -H "X-API-Key: mindsift_sec_…" -H "Content-Type: application/json" \
+  -d '{"title":"Milch kaufen #einkauf","priority":"high","dueDate":"2026-11-01"}'
+
+# Aufgabenliste nur lesend freigeben
+curl -X POST https://mindsift.example.com/api/v1/task-lists/tkl_…/shares \
+  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
+  -d '{"targetType":"user","targetId":"usr_…","permission":"viewer"}'
 ```
-
----
-
-## 📋 3. Endpunkte nach Modulen
-
-### 3.1 Authentifizierung & System-Status
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `GET` | `/api/v1/health` | Öffentlich | Liveness-Check (`{"status":"ok"}`) |
-| `GET` | `/api/v1/auth/status` | Öffentlich | Prüft ob Ersteinrichtung nötig ist (`needsSetup: true/false`) |
-| `POST` | `/api/v1/auth/setup` | Öffentlich | Führt First-Boot Setup durch (legt ersten Admin an) |
-| `POST` | `/api/v1/auth/register` | Öffentlich | Registrierung über Einladungscode (`inviteCode`) |
-| `POST` | `/api/v1/auth/login` | Öffentlich | Login via E-Mail oder Benutzername + Passwort |
-| `GET` | `/api/v1/auth/me` | JWT | Gibt das aktuelle Benutzerprofil zurück |
-| `PATCH` | `/api/v1/auth/settings` | JWT | Aktualisiert Profil, Passwort, Theme oder Alarm-Kanäle |
-| `POST` | `/api/v1/auth/alarms/test` | JWT | Sendet Test-Alarm an E-Mail, Discord oder Custom Webhook |
-
-#### Beispiel: `POST /api/v1/auth/login`
-```json
-// Request
-{
-  "login": "sandro",
-  "password": "geheimesPasswort123"
-}
-
-// Response (200 OK)
-{
-  "token": "eyJhbGciOiJIUzI1NiIs...",
-  "user": {
-    "id": "usr_abc123",
-    "email": "sandro@example.com",
-    "username": "sandro",
-    "displayName": "Sandro",
-    "role": "admin",
-    "alarmChannels": ["discord", "webhook"]
-  }
-}
-```
-
----
-
-### 3.2 Triage & Instant Capture
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `POST` | `/api/v1/inbox` | JWT / API-Key | Erfasst einen neuen Quick Dump oder leitet direkt weiter |
-| `GET` | `/api/v1/triage/deck` | JWT | Liefert den Stapel aller noch nicht triagierten Gedanken (`status: 'inbox'`) |
-| `PATCH` | `/api/v1/triage/{id}` | JWT | Führt Triage-Aktion aus (`keep`, `discard`, `restore`) |
-
-#### Beispiel: `POST /api/v1/inbox`
-Ermöglicht flexible Direkt-Zuordnungen:
-```json
-// Request (Quick Dump in Triage-Deck)
-{
-  "content": "Kellerfeuchtigkeit über 68% gestiegen #smarthome #alarm",
-  "priority": "urgent"
-}
-
-// Request (Direkt als Aufgabe anlegen)
-{
-  "content": "Server Backup prüfen #devops",
-  "priority": "high",
-  "target": "task",
-  "dueDate": "2026-10-30"
-}
-```
-*Hinweis:* Wenn `/api/v1/inbox` über einen API-Key aufgerufen wird und kein `source` definiert ist, wird die Quelle automatisch als `"webhook"` markiert!
-
----
-
-### 3.3 Aufgaben & Kanban-System
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `GET` | `/api/v1/tasks` | JWT | Liefert alle Aufgaben des Benutzers (inkl. geteilter Aufgaben) |
-| `POST` | `/api/v1/tasks/reorder` | JWT | Speichert Kanban-Status und Reihenfolge (`sort_order`) |
-| `GET` | `/api/v1/task-lists` | JWT | Liefert alle Aufgabenlisten (eigene & geteilte) |
-| `POST` | `/api/v1/task-lists` | JWT | Erstellt eine neue Aufgabenliste (mit Farbe & Spalten) |
-| `PUT` | `/api/v1/task-lists/{id}` | JWT | Ändert Titel, Farbe, Icon oder Kanban-Spalten |
-| `DELETE` | `/api/v1/task-lists/{id}` | JWT | Löscht Aufgabenliste |
-| `POST` | `/api/v1/task-lists/{id}/shares` | JWT | Teilt Liste mit Team oder Benutzer |
-
----
-
-### 3.4 Workspace & Dokumente
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `GET` | `/api/v1/documents` | JWT | Liefert Liste aller Dokumente des Benutzers (Metadaten) |
-| `POST` | `/api/v1/documents` | JWT | Erstellt neues Notiz-Dokument (mit Blocks oder Markdown) |
-| `GET` | `/api/v1/documents/{id}` | JWT | Lädt komplettes Dokument inklusive aller Blöcke |
-| `PUT` | `/api/v1/documents/{id}` | JWT | Aktualisiert Dokumenttitel, Icon oder Ordnerpfad |
-| `PATCH` | `/api/v1/documents/{id}/blocks` | JWT | Granulares Patching von Dokument-Blöcken (Database-First) |
-| `DELETE` | `/api/v1/documents/{id}` | JWT | Löscht Dokument (Datenbank & physische Datei) |
-| `POST` | `/api/v1/documents/{id}/shares` | JWT | Notiz mit anderem Benutzer teilen (`read` / `write`) |
-| `GET` | `/api/v1/documents/{id}/lock` | JWT | Fragt Bearbeitungs-Sperrstatus ab |
-| `POST` | `/api/v1/documents/{id}/lock` | JWT | Sperrt Dokument für Bearbeitung (30s Lease) |
-| `DELETE` | `/api/v1/documents/{id}/lock` | JWT | Gibt Bearbeitungssperre wieder frei |
-
----
-
-### 3.5 Workspace Ordner & Geteilte Ordner
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `GET` | `/api/v1/folders` | JWT | Liefert alle Ordnerpfade des Benutzers |
-| `POST` | `/api/v1/folders` | JWT | Legt neuen (auch leeren) Ordner an |
-| `POST` | `/api/v1/folders/move` | JWT | Benennt Ordner um oder verschiebt ihn hierarchisch |
-| `DELETE` | `/api/v1/folders` | JWT | Löscht Ordner und verschiebt Notizen |
-| `GET` | `/api/v1/workspace/folders/shared` | JWT | Liefert für den Benutzer freigegebene geteilte Ordner |
-| `POST` | `/api/v1/workspace/folders/shared` | JWT | Erstellt neuen geteilten Ordner |
-| `PUT` | `/api/v1/workspace/folders/shared/{id}/mount` | JWT | Ändert den lokalen Einhängepfad beim Empfänger |
-| `POST` | `/api/v1/workspace/folders/shared/{id}/shares` | JWT | Gibt Ordner für Teams oder Benutzer frei |
-
----
-
-### 3.6 Geteilte Listen (Listen & Einkauf)
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `GET` | `/api/v1/lists` | JWT | Liefert alle geteilten Listen |
-| `POST` | `/api/v1/lists` | JWT | Erstellt neue geteilte Liste |
-| `GET` | `/api/v1/lists/{id}` | JWT | Lädt Liste inklusive aller Einträge |
-| `POST` | `/api/v1/lists/{id}/items` | JWT | Fügt Eintrag hinzu |
-| `PATCH` | `/api/v1/lists/{id}/items/{itemId}` | JWT | Hakt Eintrag ab (`isCompleted: true/false`) |
-| `POST` | `/api/v1/lists/{id}/items/reorder` | JWT | Speichert sortierte Einträge |
-| `POST` | `/api/v1/lists/{id}/clear-completed`| JWT | Löscht alle abgehakten Einträge |
-| `POST` | `/api/v1/lists/{id}/shares` | JWT | Teilt Liste mit Team oder Benutzer |
-
----
-
-### 3.7 Smarthome Ingestion & Externe Webhooks
-
-| Methode | Pfad | Auth | Beschreibung |
-| :--- | :--- | :--- | :--- |
-| `POST` | `/api/v1/webhooks/ingest` | Token / Key | Empfängt externe Webhook-Payloads von Home Assistant / n8n |
-
-#### Beispiel: `POST /api/v1/webhooks/ingest?token=mindsift_sec_...`
-Unterstützt flexible Payloads (JSON oder Plain Text):
-```json
-{
-  "title": "Waschmaschine Keller fertig",
-  "priority": "high",
-  "tags": ["smarthome", "keller"]
-}
-```
-*Live-Aktualisierung:* Sendet automatisch ein `TASK_CREATED` WebSocket-Event an alle Clients des Benutzers, sodass die neue Karte sofort ohne Neuladen im Triage-Deck erscheint!

Doku/api/websocket.md

@@ -1,195 +1,55 @@
-# 📡 WebSocket & Echtzeit-Synchronisation
+# Echtzeit: WebSocket und SSE
 
-MindSift implementiert eine bidirektionale Echtzeit-Synchronisationsschicht auf Basis von WebSockets ([`internal/ws/hub.go`](../../internal/ws/hub.go)). Sie sorgt dafür, dass Änderungen an Aufgaben, Triage-Karten, Notizen und geteilten Einkaufslisten ohne manuelles Neuladen sofort auf allen geöffneten Geräten und bei allen Kollaborationspartnern sichtbar werden.
+Der Server verteilt Änderungen als JSON-Ereignisse an verbundene Clients. Die Ereignisse entstehen **nach** einer REST-Änderung; es gibt keinen Schreibkanal über die Verbindung. Implementierung: [hub.go](../../internal/ws/hub.go), Client: [api.ts](../../frontend/src/lib/api.ts).
 
----
+> Keine CRDTs, keine Sperren, keine Cursor-Presence. Frühere Fassungen dieser Doku beschrieben DocRooms, `clientId`-Echo-Schutz und Yjs; das existiert nicht (mehr).
 
-## 🔌 1. Verbindung & Handshake
+## Transporte
 
-### Verbindungs-Endpunkte
-```
-wss://<domain>/api/v1/ws?token=<jwt-token>
-wss://<domain>/api/v1/ws/lists/<listId>?token=<jwt-token>
-```
+| Transport | Endpunkt | Hinweise |
+|---|---|---|
+| WebSocket | `GET /api/v1/ws` (auch `/ws/lists/{id}`, `/ws/spaces/{id}`) | Ping alle 30 s, Lesefrist 60 s, Nachrichten bis 4 MB |
+| SSE | `GET /api/v1/events` | Kommentar-Ping alle 15 s, Header `X-Accel-Buffering: no` |
 
-### Authentifizierung & Upgrade
-- Die Authentifizierung erfolgt über das JWT-Token im Query-Parameter `?token=...` oder den `Authorization: Bearer`-Header während des HTTP-Upgrade-Requests.
-- Der Server extrahiert die `userID` und registriert die Verbindung im internen `Hub`.
-- Der `Upgrader` akzeptiert alle Origins (`CheckOrigin: return true`), um volle Kompatibilität mit Reverse-Proxies (Traefik, Nginx, Caddy, Cloudflare) und Docker-Netzwerken zu gewährleisten.
+Der Client versucht zuerst WebSocket. Gelingt der Aufbau nicht innerhalb von 2,5 s oder bricht die Verbindung unsauber ab, wechselt er auf SSE und bleibt dabei (Firmen-Proxys). Dort liefert der Server `SSE_CONNECTED` mit einer `sseId`; Räume werden über `POST /api/v1/events/rooms` (`sseId`, `room`, `action`: `join`/`leave`) abonniert.
 
----
+**Authentifizierung:** Token als `?token=<JWT|API-Key>` oder `Authorization`-Header. Ohne gültiges Token wird die Verbindung als `anonymous` akzeptiert ([FLAW-01](../flaws.md), [FLAW-02](../flaws.md)). Das Token wird nur beim Verbinden geprüft.
 
-## 🏛️ 2. Hub-Architektur & Rooms
-
-Der WebSocket-Hub unterteilt Verbindungen in drei Abstraktionsebenen:
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                           WebSocket Hub                         │
-├─────────────────┬─────────────────────────────┬─────────────────┤
-│   allClients    │          userRooms          │      rooms      │
-│  (Alle aktiven  │     (Pro Benutzer-ID)       │   (Pro Liste/   │
-│   Verbindungen) │  Cross-Device Sync für      │     Space)      │
-│                 │  Tasks, Triage & Workspace  │  Geteilte Liste │
-└────────┬────────┴──────────────┬──────────────┴────────┬────────┘
-         ▼                       ▼                       ▼
-   Presence Stats          TASK_CREATED             ITEM_TOGGLED
-   DOC_LOCKED              TASK_UPDATED             ITEM_CREATED
-   DOC_UNLOCKED            DOC_UPDATED              LIST_UPDATED
-```
-
-1. **`allClients` (Global):** Hält jede aktive Client-Verbindung. Ermöglicht Broadcasts systemweiter Ereignisse (z.B. globale Dokument-Sperrungen).
-2. **`userRooms[userID]` (Benutzer-Räume):** Sendet Events an alle Geräte desselben Benutzers (z.B. Desktop und Smartphone). Erzeugt ein Webhook oder Quick Dump auf dem Smartphone einen Eintrag, taucht dieser zeitgleich auf dem Desktop auf.
-3. **`rooms[listID]` (Kollaborations-Räume):** Multiplexing für geteilte Listen. Alle Mitglieder einer Liste empfangen Aktionen (wie Abhaken, Löschen, Umsortieren) in Echtzeit.
-
----
-
-## 📨 3. Nachrichten-Format (Envelope)
-
-Alle WebSocket-Nachrichten werden als JSON mit einheitlicher Hülle übertragen:
+## Nachrichtenformat
 
 ```json
-{
-  "event": "ITEM_TOGGLED",
-  "listId": "lst_12345",
-  "payload": {
-    "itemId": "itm_987",
-    "isCompleted": true,
-    "completedBy": "usr_sandro",
-    "completedByName": "Sandro"
-  },
-  "timestamp": "2026-10-26T13:30:00Z"
-}
+{ "event": "TASK_UPDATED", "listId": "", "payload": { … }, "timestamp": "2026-10-27T12:00:00Z" }
 ```
 
----
+Client → Server versteht der Server nur: `{"event":"JOIN_ROOM","room":"<id>"}` und `{"event":"LEAVE_ROOM","room":"<id>"}`. Räume heißen `doc:<docId>` für Notizen oder `<listId>` für geteilte Listen.
 
----
+## Zustellung
 
-## ⚡ 4. Granulare Workspace-Echtzeitsynchronisation (`/api/v1/ws/docs/{id}`)
+| Kanal | Wer erhält es |
+|---|---|
+| Benutzer-Kanal (`BroadcastToUser`) | alle Verbindungen eines Benutzers |
+| Raum (`BroadcastRoom`, `Broadcast`) | Verbindungen im Raum |
+| Alle (`BroadcastToAll`) | **jede** Verbindung, auch unangemeldete |
 
-MindSift nutzt für die Outliner-Synchronisation eine schlanke, hochgradig reaktive In-Memory-Raumarchitektur (`DocRoom` in [`internal/ws/docroom.go`](../../internal/ws/docroom.go)). Clients verbinden sich mit ihrer eindeutigen `clientId`:
+## Ereignisse
 
-```
-wss://<domain>/api/v1/ws/docs/<docId>?token=<jwt>&clientId=<cli_...>&userName=<Name>&userColor=<Hex>
-```
-
-### 4.1 JSON-Echtzeit-Eventprotokoll
-Die Kommunikation erfolgt über leichtgewichtige JSON-Nachrichten ohne binären CRDT-Overhead:
-
-| Event-Typ | Richtung | Zweck / Payload |
+| Ereignis | Auslöser | Kanal |
 |---|---|---|
-| `doc_state` | Server ➔ Client | Wird direkt beim Verbinden gesendet: Liefert den aktuellen In-Memory-Zustand (`title`, `blocks[]`, `activeCursors[]`). |
-| `block_updated` | Bidirektional | Feingranulare Inhalts- oder Statusänderung eines Blocks (`blockId`, `content`, `level`, `type`, `checked`, `collapsed`). |
-| `block_created` | Bidirektional | Erzeugt einen neuen Block (`block`, `afterBlockId`, `newIndex`). |
-| `block_deleted` | Bidirektional | Löscht einen Block anhand seiner `blockId`. |
-| `block_moved` | Bidirektional | Verschiebt einen Block / Unterbaum (`blockId`, `newIndex`, `level`). |
-| `title_updated` | Bidirektional | Aktualisiert den Dokumententitel (`title`). |
-| `cursor_moved` | Bidirektional | **Ephemere Live-Präsenz & Cursor:** Sendet Benutzer-Avatar, Cursorposition und Textselektion (`clientId`, `userId`, `userName`, `userColor`, `blockId`, `selectionStart`, `selectionEnd`). Wird nicht in SQLite gespeichert! |
-| `client_left` | Server ➔ Client | Wird automatisch ausgelöst, wenn ein Peer die Verbindung trennt, damit Remote-Cursor sofort verschwinden. |
+| `TASK_CREATED` | `POST /inbox` | Benutzer |
+| `TASK_UPDATED` | `PATCH /thoughts/{id}` (Triage: Benutzer) | alle |
+| `TASK_DELETED` | `DELETE /thoughts/{id}` | alle |
+| `TASK_REORDERED` | Aufgaben umsortieren | alle |
+| `TASK_LIST_UPDATED` / `TASK_LIST_DELETED` | Liste ändern, (un)teilen, löschen | alle |
+| `DOC_CREATED`, `DOC_UPDATED`, `DOC_DELETED` | Notiz anlegen/ändern/löschen, Freigaben | berechtigte Benutzer |
+| `DOC_BLOCKS_PATCHED` | `PATCH /documents/{id}/blocks` (`docId`, `updatedBy`, `upserted`, `deletedIds`, `blockOrder`) | Raum `doc:<id>` und berechtigte Benutzer |
+| `WORKSPACE_FOLDERS_UPDATED` | Ordner/Mounts ändern | Benutzer |
+| `LIST_CREATED`, `LIST_UPDATED`, `LIST_DELETED`, `LIST_SHARED`, `LIST_UNSHARED`, `LIST_CLEARED` | Listenverwaltung | Benutzer bzw. Raum der Liste |
+| `ITEM_CREATED`, `ITEM_UPDATED`, `ITEM_TOGGLED`, `ITEM_DELETED`, `ITEM_REORDERED` | Listeneinträge | Raum der Liste |
+| `USER_PRESENCE` | Verbindung auf-/abgebaut (`onlineCount`) | Raum |
+| `SSE_CONNECTED` | Nur SSE, direkt nach Verbindung | Verbindung |
 
-```mermaid
-sequenceDiagram
-    autonumber
-    actor UserA as Admin (Fenster A, cli_1)
-    participant Room as DocRoom (Go RAM)
-    actor UserB as User (Fenster B, cli_2)
-    participant DB as SQLite (blocks, block_tags, documents)
-
-    UserA->>Room: Connect (clientId="cli_1", userName="Admin")
-    Room-->>UserA: doc_state (title, blocks, activeCursors)
-    UserB->>Room: Connect (clientId="cli_2", userName="User")
-    Room-->>UserB: doc_state (title, blocks, activeCursors)
-
-    UserA->>Room: block_updated (clientId="cli_1", blockId="b1", content="Neu")
-    Note over Room: Mutiert RAM-Slice & resetet 1.5s Timer
-    Room-->>UserB: block_updated (clientId="cli_1", blockId="b1", content="Neu")
-    Note over UserA: Echo Filter: cli_1 erhält kein Selbstecho!
-
-    UserB->>Room: cursor_moved (clientId="cli_2", blockId="b1", selStart=3)
-    Room-->>UserA: cursor_moved (clientId="cli_2", blockId="b1")
-    Note over UserA: Farbiger Cursor-Avatar erscheint an b1
-
-    Note over Room: 1.5s Inaktivität ohne neue Tastenanschläge
-    Room->>DB: Debounce-Flush (blocks, Regex #tags -> block_tags, markdown_cache)
-```
-
-### 4.2 Strikter Echo-Schutz (`clientId`)
-- Jeder Client generiert beim Start einen flüchtigen Schlüssel (`clientIdRef`, z. B. `cli_a8f9_l0z3`).
-- Der Go-Hub filtert beim Broadcasten im Raum alle Clients heraus, deren Verbindung oder `clientId` mit dem Absender übereinstimmt:
-  ```go
-  if evt.ClientID != "" && client.clientID == evt.ClientID {
-      continue
-  }
-  ```
-- **Vorteil:** Verhindert Cursor-Resets, Fokus-Verluste und Race Conditions durch Selbstechos während des lokalen Tippens.
-
-### 4.3 1.5-Sekunden Debounce-Flush in SQLite
-- Das Tippen im Editor erfolgt latenzfrei direkt im Arbeitsspeicher des `DocRoom`.
-- Sobald 1,5 Sekunden lang keine neuen Tastenanschläge oder Mutationen eintreffen (oder wenn der letzte Client den Raum verlässt), stößt der Raum einen synchronisierten Flush an:
-  1. Persistiert alle Blöcke in `blocks`.
-  2. Extrahiert alle Hashtags (`#tag`) per Regex und aktualisiert `block_tags`.
-  3. Kompiliert die Blockliste (anhand der `level`-Tiefe) in Standard-Markdown und speichert sie in `documents.markdown_cache`.
-
----
-
-## 🔒 5. Berechtigungen & Bearbeitungsrechte
-
-- **Kollaboration ohne blockierende Locks:** Alle Nutzer mit Schreibrechten (`permission === 'owner'` oder `'write'`) können zeitgleich im selben Dokument tippen. Pessimistische Locks oder Lease-Heartbeats wurden vollständig entfernt.
-- **Schreibschutz:** Verfügt ein Nutzer nur über Leserechte (`permission === 'read'`), ist das Eingabefeld gesperrt (`readOnly`). Er kann das Dokument jedoch in Echtzeit mitlesen und sieht die Cursors der Bearbeiter.
-
----
-
-## 🔄 6. Fallback-Strategie & Proxy-Resilienz (Dual-Transport Architektur)
-
-In restriktiven Firmennetzwerken, hinter Unternehmens-Proxies (z.B. Zscaler, BlueCoat) oder fehlerhaft konfigurierten Reverse-Proxies wird der `Upgrade: websocket`-Header häufig verworfen (`NS_ERROR_CONNECTION_REFUSED`, Code 1006 / 1002 / 1008). 
-
-MindSift löst dieses Problem durch eine **vollwertige Dual-Transport-Architektur** ([FLAW-03](../flaws.md)):
-
-```
-                                  ┌───────────────────────────────┐
-                                  │      MindSift Frontend        │
-                                  └───────────────┬───────────────┘
-                                                  │
-                            ┌─────────────────────┴─────────────────────┐
-                            ▼                                           ▼
-                 Standard: WebSockets                        Fallback: SSE + REST
-            (wss://.../api/v1/ws)                       (https://.../api/v1/events)
-                            │                                           │
-                            │  [Proxy Upgrade Block (Code 1006/Timeout)]│
-                            │ ────────────────────────────────────────> │
-                            ▼                                           ▼
-               ┌────────────────────────┐                  ┌────────────────────────┐
-               │    Gorilla WS Conn     │                  │  Server-Sent Events    │
-               │   Bidirektionaler      │                  │  (text/event-stream)   │
-               │    TCP-WebSocket       │                  │  Standard HTTPS Port   │
-               └────────────┬───────────┘                  └────────────┬───────────┘
-                            │                                           │
-                            └─────────────────────┬─────────────────────┘
-                                                  ▼
-                                   ┌─────────────────────────────┐
-                                   │       Realtime Hub          │
-                                   │   (Multiplexing WS & SSE)   │
-                                   └─────────────────────────────┘
-```
-
-### 1. Automatischer SSE-Fallback (`GET /api/v1/events`)
-- Scheitert der WebSocket-Handshake oder blockiert ein Proxy das Upgrade, wechselt MindSift innerhalb von 3,5 Sekunden automatisch auf einen **Server-Sent Events (SSE) Stream**.
-- Da SSE ein standardmäßiger HTTP/1.1- bzw. HTTP/2-GET-Request über Standard-Port 443/80 ist (`Content-Type: text/event-stream`), wird er von jedem Proxy und jeder Firewall ungehindert durchgeleitet.
-- Header `X-Accel-Buffering: no` und `Cache-Control: no-cache` verhindern Pufferung im Proxy; periodische Ping-Kommentare (`: ping\n\n`) alle 15 Sekunden halten Timeouts fern.
-- Der Client bleibt dadurch **vollständig echtzeitfähig** (`Live (SSE)`).
-
-### 2. REST-Endpunkte für Upstream-Aktionen im SSE-Fallback-Modus
-Da SSE unidirektional (Server ➔ Client) ist, stellt MindSift für Schreibvorgänge im SSE-Modus REST-Äquivalente bereit:
-- `PATCH /api/v1/documents/:id/blocks`: Akzeptiert Block-Mutationen (`upserted`, `deletedIds`, `blockOrder`) und synchronisiert den In-Memory-Raum sowie SQLite.
-- `PUT /api/v1/documents/:id`: Aktualisiert Dokumenttitel und Metadaten.
-- `POST /api/v1/events/rooms`: Erlaubt SSE-Clients, Räumen dynamisch beizutreten (`join`) oder sie zu verlassen (`leave`).
-
-### 3. Verbindungs-Indikator
-- **Grün pulsierend:** Live verbunden über WebSockets (`Live (WebSocket)`).
-- **Türkis pulsierend:** Live verbunden über Server-Sent Events (`Live (Server-Sent Events / Proxy-Stream)`).
-- **Gelb/Amber:** Temporäre Unterbrechung mit automatischem HTTP-Polling-Schutz.
-
-Ausführliche Konfigurationsbeispiele für Nginx, Traefik, Caddy, Cloudflare und Apache finden sich im separaten Handbuch:
-👉 **[Reverse-Proxy-Konfigurationshandbuch](../reverse-proxy.md)**
+## Verhalten im Frontend
 
+- Die globale Verbindung (ein Singleton) leitet jede Nachricht als Browser-Ereignis `mindsift:ws` weiter; Ansichten (`TasksView`, `WorkspaceView`, `SharedListsView`) hören darauf und laden bzw. patchen ihren Zustand.
+- Nach einem Abbruch verbindet sich der Client mit Verzögerung neu.
+- Weil Notizen nur vom Eigentümer geschrieben werden, dient `DOC_BLOCKS_PATCHED` vor allem dazu, Lesenden und weiteren Geräten des Eigentümers Änderungen zu zeigen. Es gibt keine Konfliktauflösung (letzter Schreiber gewinnt).

Doku/architecture.md

@@ -1,142 +1,87 @@
-# 🏛️ Systemarchitektur & Technologie-Stack
+# Architektur
 
-Dieses Dokument beschreibt die interne Architektur von MindSift, die Interaktion zwischen den Systemkomponenten, das Concurrency- und Thread-Safety-Modell sowie die Deployment-Strategie.
-
----
-
-## 🧩 1. Schichten-Architektur
-
-MindSift ist als monolithische, hochperformante Single-Binary-Lösung konzipiert. Das Go-Backend liefert sowohl die REST- und WebSocket-Schnittstellen aus als auch die vorkompilierte React Single Page Application (SPA) als eingebettetes statisches Dateisystem (`embed.FS`).
+## Überblick
 
 ```
-┌────────────────────────────────────────────────────────┐
-│                   Frontend (React 18)                  │
-│   Vite • TypeScript • Tailwind CSS • Lucide • Motion   │
-└───────────────────────────┬────────────────────────────┘
-                            │ HTTPS REST / WSS WebSocket
-┌───────────────────────────▼────────────────────────────┐
-│                  Go Chi Routing Layer                  │
-│       CORS • RealIP • Recoverer • Auth / Role Guard     │
-├───────────────────────────┬────────────────────────────┤
-│     Business Engine       │     Gorilla WebSocket      │
-│  Triage • Tasks • Alarms  │  Rooms • Hub • Doc-Locking │
-├───────────────────────────┴────────────────────────────┤
-│                  Storage Abstraction                   │
-│   sqlite.go (modernc.org/sqlite pure Go, WAL-Mode)     │
-└───────────────────────────┬────────────────────────────┘
-                            │
-              ┌─────────────┴─────────────┐
-              ▼                           ▼
-    /data/mindsift.db           /data/workspace/
-    (SQLite Datenbank)      (Physische .md Dateien)
+Browser (React SPA, PWA-Manifest)
+   │  REST /api/v1/*           Authorization: Bearer <JWT | mindsift_sec_…>
+   │  WebSocket /api/v1/ws     Fallback: SSE /api/v1/events
+   ▼
+Go-Server (chi)  ── internal/api   Handler, Middleware, Alarm-Ticker
+   │                internal/ws    Hub (Räume, Benutzer-Kanäle, SSE)
+   │                internal/auth  JWT, bcrypt, API-Key-Hash
+   ▼                internal/config
+SQLite (modernc.org/sqlite, WAL)  ── internal/storage
 ```
 
----
+Das Frontend liegt per `go:embed` im Binary ([cmd/server/main.go](../cmd/server/main.go)). Unbekannte Pfade liefern `index.html` (SPA-Routing); `index.html`, `sw.js` und `manifest.json` werden mit `no-store` ausgeliefert.
 
-## 🛠️ 2. Technologie-Stack
+## Stack
 
-### Backend (Go 1.23)
-- **HTTP Routing:** [`github.com/go-chi/chi/v5`](https://github.com/go-chi/chi) – Minimalistischer, idiomatisch schneller Router mit Middleware-Ketten.
-- **WebSocket Hub:** [`github.com/gorilla/websocket`](https://github.com/gorilla/websocket) – Verbindungs-Upgrade, Keep-Alive/Ping-Pong und Room-Multiplexing.
-- **Datenbank-Treiber:** [`modernc.org/sqlite`](https://gitlab.com/cznic/sqlite) – CGO-freier, rein in Go übersetzter SQLite-Treiber für einfache plattformübergreifende Kompilierung und Containerisierung ohne GCC-Toolchain.
-- **Authentifizierung:** [`github.com/golang-jwt/jwt/v5`](https://github.com/golang-jwt/jwt) (HMAC-SHA256 Token) und [`golang.org/x/crypto/bcrypt`](https://pkg.go.dev/golang.org/x/crypto/bcrypt) für Passwort-Hashing.
+| Schicht | Technik |
+|---|---|
+| Backend | Go 1.23, `go-chi/chi` v5, `go-chi/cors`, `gorilla/websocket`, `golang-jwt/jwt` v5, `x/crypto/bcrypt` |
+| Datenbank | SQLite über `modernc.org/sqlite` (reines Go, kein CGO), WAL, `foreign_keys=ON` |
+| Frontend | React 18, TypeScript, Vite 5, Tailwind 3, framer-motion (Triage-Karten), lucide-react, prismjs (Code-Blöcke) |
+| Auslieferung | Mehrstufiges Dockerfile (Node 22 → Go 1.23 → Alpine 3.21), Image `git.dsit.me/sandrodach/mindsift` |
 
-### Frontend (React 18 SPA)
-- **Build-Tool:** [Vite 5](https://vitejs.dev/) für schnelles Hot-Module-Replacement (HMR) und optimierte Production-Bundles.
-- **Sprache:** TypeScript 5 mit strikter Typisierung.
-- **Design & Layout:** [Tailwind CSS 3](https://tailwindcss.com/) in Verbindung mit dem MindSift Single-File CSS Theming System.
-- **Icons & Animationen:** [Lucide React](https://lucide.dev/) und [Framer Motion](https://www.framer.com/motion/) für Gesten, Karten-Swipes und Übergänge.
+## Verzeichnisse
 
----
+| Pfad | Inhalt |
+|---|---|
+| `cmd/server/` | `main.go`, eingebettetes `dist/` |
+| `internal/api/` | `server.go` (Routen, Handler, Alarm-Ticker, SMTP/Discord/Webhook-Versand) |
+| `internal/storage/` | `sqlite.go` (Schema, Migrationen, gesamte Datenlogik) |
+| `internal/domain/` | Strukturen (`models.go`), ID-Erzeugung, Tag-Extraktion |
+| `internal/ws/` | `hub.go` |
+| `internal/auth/` | Tokens und Passwörter |
+| `internal/config/` | Umgebungsvariablen |
+| `frontend/src/features/` | `triage`, `workspace`, `lists`, `teams`, `settings`, `capture`, `auth`, `help` |
+| `frontend/src/lib/` | `api.ts` (REST-Client, Transport-Umschaltung WS/SSE), `types.ts`, `markdown.tsx`, `theme.ts` |
+| `frontend/src/themes/` | CSS pro Theme |
 
-## 📁 3. Verzeichnisstruktur des Projekts
+## Start und Laufzeit
+
+1. `config.Load()` liest die Umgebung (siehe unten).
+2. `storage.NewStore()` öffnet SQLite (`busy_timeout`, WAL, max. 8 Verbindungen) und führt `migrate()` aus.
+3. SMTP-Werte aus der Umgebung werden in `system_settings` übernommen, sofern dort noch nichts steht.
+4. Mit Demo-Flag legt `EnsureDemoAccounts` die Konten `admin/admin` und `user/user` an.
+5. `api.NewServer` startet den **Alarm-Ticker** (jede Minute) und baut den Router. Server-Timeouts: Lesen 15 s, Schreiben 30 s, Leerlauf 60 s. Beim Beenden wird sauber heruntergefahren.
+
+## Konfiguration
+
+| Variable | Standard | Bedeutung |
+|---|---|---|
+| `PORT` | `8080` | HTTP-Port |
+| `DATA_DIR` | `./data` (Container: `/data`) | Verzeichnis der Datenbank |
+| `DATABASE_URL` | leer | `sqlite:///pfad/datei.db` oder Pfad; ohne Angabe `DATA_DIR/mindsift.db`. Postgres-URLs werden **nicht** unterstützt (siehe Hinweis) |
+| `JWT_SECRET` | festes Fallback (unsicher!) | Signaturschlüssel der Tokens; unbedingt setzen, siehe [FLAW-04](flaws.md) |
+| `BASE_URL` | `http://localhost:<PORT>` | Basis-URL der Instanz |
+| `ALLOW_REGISTRATION` | `false` | Startwert; die Einstellung im Admin-UI (`system_settings`) hat Vorrang |
+| `LOG_LEVEL` / `DEBUG` | `info` / `false` | `debug`, `info`, `warn`, `error`; `DEBUG=true` erzwingt `debug` |
+| `MINDA_DEMO` (auch `MINDSIFT_DEMO`, `DEMO_MODE`) | `false` | Demo-Konten anlegen |
+| `SMTP_HOST`, `SMTP_PORT`, `SMTP_USER`, `SMTP_PASS`, `SMTP_FROM`, `SMTP_TLS` | leer / `587` / `true` | Mailversand, auch im Admin-UI einstellbar |
+
+Hinweis: `DATABASE_URL` mit `postgres…` führt dazu, dass der Standardpfad in `DATA_DIR` genutzt wird; Postgres ist nicht implementiert.
+
+## Authentifizierung
+
+- **Login** mit E-Mail, Benutzername (aus dem E-Mail-Präfix) oder `login`. Passwörter: bcrypt (`DefaultCost`).
+- **JWT:** HS256, Laufzeit 30 Tage, Claims `userId`, `email`, `displayName`, `tokenVersion`, `jti`. Gültig nur, wenn Token nicht in `revoked_tokens` steht, das Konto aktiv ist und `tokenVersion` mit `users.token_version` übereinstimmt. `token_version` wird bei Passwortänderung, Rollenwechsel, Deaktivierung und „Alle Sitzungen beenden“ erhöht.
+- **Logout** schreibt den Token-Hash in `revoked_tokens`.
+- **API-Keys:** `mindsift_sec_<hex>`, gespeichert als SHA-256, nur das Präfix bleibt sichtbar. Der Key gilt als Bearer-Token oder in `X-API-Key` und authentifiziert als Besitzer ([FLAW-07](flaws.md)).
+- **Registrierung:** nur mit Einladungscode oder wenn `allow_registration` aktiv ist. Das erste Konto entsteht über `/auth/setup` und wird Administrator.
+
+## Hintergrundjob: Alarme
+
+`startAlarmTicker` prüft jede Minute alle offenen, noch nicht gemeldeten Aufgaben mit Fälligkeit. Ist `due_date <= heute` (Serverzeit), sendet er über die Kanäle des Benutzers (`email`, `discord`, `webhook`) und setzt `alarm_sent`, sobald mindestens ein Kanal erfolgreich war. Details und Einschränkungen: [modules/tasks.md](modules/tasks.md), [FLAW-12](flaws.md).
+
+## Build
 
 ```
-MindSift/
-├── cmd/
-│   └── server/
-│       └── main.go               # Einstiegspunkt: Initialisierung, Config, Store, Start
-├── internal/
-│   ├── api/
-│   │   ├── server.go             # HTTP-Routen, Handler-Methoden, Middleware
-│   │   └── server_test.go        # Integrationstests für alle REST- und Ingest-Routen
-│   ├── auth/
-│   │   ├── auth.go               # JWT Validierung, Token-Erstellung, Context-Helpers
-│   │   └── apikey.go             # API-Key Erzeugung (mindsift_sec_...) & SHA-256 Hashing
-│   ├── config/
-│   │   └── config.go             # Environment-Variablen (PORT, DATA_DIR, JWT_SECRET, SMTP)
-│   ├── domain/
-│   │   └── models.go             # Go-Structs für Thought, Document, List, User, Team etc.
-│   ├── storage/
-│   │   ├── sqlite.go             # DB-Schema, CRUD-Operationen, Queries, Migrationen
-│   │   └── storage_test.go       # Unit-Tests für Speicheroperationen
-│   └── ws/
-│       └── hub.go                # WebSocket Client, Room-Management, Locking-Mechanismus
-├── frontend/
-│   ├── src/
-│   │   ├── components/           # Wiederverwendbare UI-Elemente (Modals, Avatar, Menüs)
-│   │   ├── context/              # MobileActionContext (Mobile Bottom Bar State)
-│   │   ├── features/
-│   │   │   ├── auth/             # SetupWizard & Login
-│   │   │   ├── capture/          # InstantCaptureBar (Schnelleingabe)
-│   │   │   ├── help/             # Integrierte Benutzerdokumentation
-│   │   │   ├── lists/            # Geteilte Listen & Einkauf
-│   │   │   ├── settings/         # Benutzer-, Admin- & Theme-Einstellungen
-│   │   │   ├── teams/            # Gruppen & Mitglieder-Management
-│   │   │   ├── triage/           # Triage-Deck, Aufgabenliste, Kanban & TaskModal
-│   │   │   └── workspace/        # Outliner-Editor, Datei-Explorer, Wiki & Rollup
-│   │   ├── lib/                  # api.ts (HTTP/WS Client), types.ts, theme.ts
-│   │   ├── themes/               # Eigenständige Theme CSS-Dateien (dark, light, etc.)
-│   │   ├── App.tsx               # Root-Komponente, Navigation, Top/Bottom Bars
-│   │   └── main.tsx              # React DOM Bootstrap
-│   ├── package.json
-│   └── vite.config.ts
-├── Doku/                         # Dieses technische Wiki
-├── Dockerfile                    # Multi-Stage Build Definition
-└── compose.yaml                  # Docker Compose Vorlage für Produktivbetrieb
+Stage 1  node:22-alpine   npm ci && npm run build            → frontend/dist
+Stage 2  golang:1.23      go vet, go test, go build          → /app/mindsift (dist wird eingebettet)
+Stage 3  alpine:3.21      nur Binary, ca-certificates, tzdata
 ```
 
----
-
-## ⚡ 4. Thread-Safety & Concurrency-Modell
-
-Da SQLite Datei-basiert arbeitet und Go standardmäßig hochgradig nebenläufig (Multi-Threaded via Goroutines) operiert, sind folgende Schutzmaßnahmen implementiert:
-
-### 1. SQLite Pragmas & WAL-Modus
-Im Storage-Layer ([`internal/storage/sqlite.go`](../internal/storage/sqlite.go)) wird die Datenbankverbindung beim Start zwingend mit folgenden DSN-Pragmas konfiguriert:
-```go
-dsn := filepath.Join(dataDir, "mindsift.db") +
-    "?_pragma=busy_timeout(10000)&" +
-    "_pragma=journal_mode(WAL)&" +
-    "_pragma=synchronous(NORMAL)&" +
-    "_pragma=foreign_keys(1)"
-```
-- **`journal_mode(WAL)`:** Write-Ahead Logging erlaubt parallele Leser (`SELECT`), während ein Schreiber (`INSERT`/`UPDATE`) aktiv ist. Leser blockieren niemals Schreiber und Schreiber blockieren niemals Leser.
-- **`busy_timeout(10000)`:** Sollte ein Schreibvorgang kurzzeitig blockiert sein, wartet SQLite bis zu 10.000 ms (10 Sekunden), bevor ein `SQLITE_BUSY` Fehler geworfen wird.
-- **`foreign_keys(1)`:** Erzwingt referenzielle Integrität und automatische Kaskadierungs-Löschungen (`ON DELETE CASCADE`).
-
-### 2. Connection Pool Begrenzung
-SQLite unterstützt nur einen einzigen Schreib-Thread zur gleichen Zeit:
-```go
-db.SetMaxOpenConns(8)
-db.SetMaxIdleConns(4)
-db.SetConnMaxLifetime(time.Hour)
-```
-
-### 3. Cursor-Deadlock-Vermeidung
-> **Kritische Backend-Regel:** Niemals verschachtelte Abfragen bei offenem `*sql.Rows`-Cursor ausführen!  
-In Go hält ein offener Cursor eine Verbindung aus dem Pool besetzt. Führt der Code innerhalb von `for rows.Next()` eine weitere Abfrage auf `s.db` aus, kann der Connection-Pool bei mehreren parallelen Benutzern innerhalb von Millisekunden einfrieren.  
-*Pattern:* Alle Zeilen werden sofort vollständig in ein Go-Slice gelesen, `rows.Close()` wird ausgeführt, und erst danach werden verknüpfte Entitäten geladen.
-
----
-
-## 🌐 5. Deployment & Container-Architektur
-
-MindSift wird als schlanker, autarker Docker-Container ausgeliefert:
-1. **Stage 1 (Frontend Build):** `node:20-alpine` kompiliert TypeScript und generiert statische Assets nach `frontend/dist/`.
-2. **Stage 2 (Backend Build):** `golang:1.23-alpine` bettet `frontend/dist/` via `//go:embed` ein, führt Unit-Tests aus und kompiliert ein statisches Binary (`mindsift-server`).
-3. **Stage 3 (Production Runtime):** `alpine:3.20` mit `ca-certificates` und `tzdata`. Das finale Image ist ca. 45 MB groß und benötigt keine externen Datenbankserver oder Abhängigkeiten.
-
-Alle persistenten Daten befinden sich in einem einzigen Verzeichnis `/data`:
-- `/data/mindsift.db` (SQLite Hauptdatenbank inklusive WAL-Journal und Shared-Memory-Dateien)
-- Notizen und Workspace-Blöcke werden zu 100% in der SQLite-Datenbank persistiert (keine losen Markdown-Dateien auf der Festplatte).
+Die Tests laufen beim Image-Build (`go test -v ./...`); ein Fehler bricht den Build ab. Frontend-Tests existieren nicht ([FLAW-19](flaws.md)).

Doku/database.md

@@ -1,359 +1,83 @@
-# 🗄️ Datenbank-Design & SQLite Schema
+# Datenbank
 
-MindSift verwendet als persistente Datenspeicherung eine lokale SQLite-Datenbank (`/data/mindsift.db`). Dieses Dokument beschreibt das relationale Datenmodell, Tabellenstrukturen, Indizes, Fremdschlüsselbeziehungen und das Migrationskonzept.
+SQLite-Datei `mindsift.db` (Standard: `$DATA_DIR/mindsift.db`), geöffnet mit `journal_mode=WAL`, `synchronous=NORMAL`, `foreign_keys=ON`, `busy_timeout=10000` und höchstens 8 Verbindungen. Das Schema entsteht in `Store.migrate()` ([sqlite.go](../internal/storage/sqlite.go)): zuerst `CREATE TABLE IF NOT EXISTS`, danach eine Liste idempotenter `ALTER TABLE`/`CREATE`-Anweisungen für ältere Datenbanken. IDs sind Text mit Präfix (`usr_…`, `th_…`, `tkl_…`, `lst_…`, `tls_…`, `blk_…`, `doc_…`).
 
----
+Die Datei `migrations/001_init.sql` wird vom Code **nicht** gelesen und ist veraltet ([FLAW-13](flaws.md)).
 
-## 📊 1. Entity-Relationship-Diagramm (ERD)
+## Tabellen
 
-```mermaid
-erDiagram
-    users ||--o{ thoughts : "erstellt"
-    users ||--o{ documents : "besitzt"
-    users ||--o{ lists : "besitzt"
-    users ||--o{ task_lists : "besitzt"
-    users ||--o{ api_keys : "besitzt"
-    users ||--o{ team_members : "ist Mitglied in"
+### Benutzer und Zugang
+| Tabelle | Zweck | Wichtige Spalten |
+|---|---|---|
+| `users` | Konten | `email` (eindeutig), `username`, `password_hash`, `display_name`, `role` (`admin`/`member`), `is_active`, `token_version`, `alarm_channels` (kommagetrennt), `alarm_email`, `discord_webhook_url`, `custom_webhook_url`, `notify_before_minutes`, `avatar_url` |
+| `user_invites` | Einladungscodes | `code`, `email`, `role`, `team_id`, `expires_at`, `used_by` |
+| `revoked_tokens` | Sperrliste ausgeloggter JWTs | `token_hash`, `expires_at` |
+| `api_keys` | Webhook-/API-Schlüssel | `key_prefix`, `key_hash` (SHA-256), `scopes` (nicht ausgewertet), `last_used_at` |
+| `system_settings` | Schlüssel/Wert für Instanz-Einstellungen | `sharing_mode`, `allow_registration`, `instance_name`, `smtp_*` |
 
-    teams ||--o{ team_members : "besteht aus"
-    teams ||--o{ task_list_shares : "erhält Zugriff"
-    teams ||--o{ list_shares : "erhält Zugriff"
-    teams ||--o{ doc_team_shares : "erhält Zugriff"
-    teams ||--o{ workspace_folder_shares : "erhält Zugriff"
+### Gedanken und Aufgaben
+| Tabelle | Zweck | Wichtige Spalten |
+|---|---|---|
+| `thoughts` | Gedanken **und** Aufgaben in einer Tabelle | `status` (`inbox`/`kept`/`converted`/`discarded`), `converted_type` (`task`/`document`/`list_item`/`document_block`), `converted_ref_id`, `priority`, `is_completed`, `due_date` (nur Datum), `task_list_id`, `kanban_status`, `notes`, `subtasks` (JSON), `tags` (JSON), `alarm_sent`, `sort_order`, `source` (`manual`, `voice`, `webhook` …) |
+| `task_lists` | Aufgabenlisten | `user_id` (Eigentümer), `team_id` (Altfeld), `title`, `icon`, `color`, `columns` (JSON, Kanban-Spalten) |
+| `task_list_shares` | Freigaben von Aufgabenlisten | `target_type` (`team`/`user`), `target_id`, **`permission`** (`editor`/`viewer`, Standard `editor`) |
 
-    task_lists ||--o{ thoughts : "gruppiert"
-    task_lists ||--o{ task_list_shares : "wird geteilt mit"
+Eine Aufgabe ist ein `thought` mit `status='kept'` oder `status='converted' AND converted_type='task'`. Aufgaben, die aus einem Notiz-Block entstehen, tragen `converted_type='document_block'` und `converted_ref_id='<docId>:<blockId>'`.
 
-    lists ||--o{ list_items : "enthält"
-    lists ||--o{ list_shares : "wird geteilt mit"
+### Workspace
+| Tabelle | Zweck |
+|---|---|
+| `documents` | Notizen: `title`, `icon`, `folder_path`, `tags` (JSON), `is_archived`, `markdown_cache`, `shared_folder_id`, `sub_folder_path`, Altspalten `content`, `blocks_json` |
+| `blocks` | Outliner-Blöcke: `document_id`, `type`, `content`, `level`, `position` (REAL), `checked`, `collapsed`, `lang` |
+| `block_tags` | `#Hashtags` je Block (`tag`, `document_id`, `block_id`) |
+| `tag_pages` | Freitext-Notiz je Benutzer und Tag |
+| `doc_pins` | Favoriten je Benutzer |
+| `doc_shares`, `doc_team_shares` | Notiz-Freigaben an Benutzer bzw. Gruppen (`permission` effektiv immer `read`) |
+| `workspace_folders` | Explizit angelegte Ordnerpfade |
+| `workspace_shared_folders` | Geteilte Ordner (Entität mit Eigentümer) |
+| `workspace_folder_shares` | Freigaben geteilter Ordner |
+| `workspace_folder_mounts` | Persönlicher Einhängepfad je Empfänger und geteiltem Ordner |
+| `doc_user_folders` | Persönliche Ablage einer geteilten Einzelnotiz je Empfänger |
 
-    documents ||--o{ blocks : "besteht aus"
-    documents ||--o{ block_tags : "indiziert"
-    blocks ||--o{ block_tags : "verknüpft"
-    documents ||--o{ doc_shares : "geteilt mit Benutzern"
-    documents ||--o{ doc_team_shares : "geteilt mit Teams"
-    documents ||--o{ doc_user_folders : "eigene Platzierung"
-    documents ||--o{ doc_pins : "Favorit von"
+Blocktypen: `h1`, `h2`, `h3`, `paragraph`, `text`, `todo`, `bullet`, `code`, `callout`, `divider`, `table`, `progress`.
 
-    workspace_shared_folders ||--o{ workspace_folder_shares : "wird geteilt mit"
-    workspace_shared_folders ||--o{ workspace_folder_mounts : "eingehängt bei"
-    workspace_shared_folders ||--o{ documents : "enthält"
+### Listen
+| Tabelle | Zweck |
+|---|---|
+| `lists` | Geteilte Listen: `title`, `icon`, `list_type` (`shopping`/`checklist`/`vacation`) |
+| `list_shares` | Freigaben: `target_type`, `target_id`, `role` (`editor`/`viewer`) |
+| `list_items` | Einträge: `content`, `category`, `quantity`, `is_completed`, `completed_by(_name)`, `sort_order` |
+
+### Gruppen
+| Tabelle | Zweck |
+|---|---|
+| `teams` | `name`, `description`, `org_id` (Standard `default`) |
+| `team_members` | `team_id`, `user_id`, `role` (`admin`/`member`) |
+| `organizations` | Rudimentär; wird vom UI nicht mehr benötigt ([FLAW-24](flaws.md)) |
+
+## Beziehungen
+
+```
+users 1─n thoughts            thoughts n─1 task_lists (task_list_id, lose)
+users 1─n task_lists          task_lists 1─n task_list_shares ─(team|user)→ teams/users
+users 1─n documents 1─n blocks 1─n block_tags
+documents n─n users           via doc_shares / doc_team_shares (nur Lesen)
+workspace_shared_folders 1─n workspace_folder_shares / workspace_folder_mounts
+users 1─n lists 1─n list_items;  lists 1─n list_shares
+teams 1─n team_members n─1 users
 ```
 
----
+`thoughts.task_list_id` ist keine Fremdschlüsselbeziehung; beim Löschen einer Liste setzt der Code die Verweise auf `''`.
 
-## 📑 2. Detaillierte Tabellen-Spezifikation
+## Migrationen und Aufräumarbeiten beim Start
 
-### 2.1 Benutzerverwaltung, System & Sicherheit
+- Spalten/Tabellen/Indizes werden nachgezogen (`ALTER TABLE … ADD COLUMN`, Fehler werden ignoriert).
+- Veraltete Tabellen werden gelöscht: `spaces`, `space_members`, `space_team_shares`, `document_crdt_state`, `document_crdt_updates`, `document_blocks`, `doc_block_tags`.
+- `users.username` wird aus dem E-Mail-Präfix aufgefüllt.
+- Alle Dokument-, Team- und Ordnerfreigaben werden auf `read` gesetzt (bei **jedem** Start, siehe [FLAW-17](flaws.md)).
+- Standardwerte in `system_settings` (`INSERT OR IGNORE`): `sharing_mode=teams_only`, `allow_registration=false`, `instance_name=MindSift`, SMTP leer.
+- Die Tabelle `teams` wird einmalig ohne Fremdschlüssel auf `organizations` neu aufgebaut.
 
-#### `users`
-Verwaltet Konten, Rollen, Multi-Channel Alarmziele und Benutzerpräferenzen.
-```sql
-CREATE TABLE IF NOT EXISTS users (
-    id TEXT PRIMARY KEY,                       -- Präfix "usr_..."
-    email TEXT UNIQUE NOT NULL,                -- E-Mail-Adresse
-    username TEXT NOT NULL DEFAULT '',         -- Eindeutiger Login-Name
-    password_hash TEXT NOT NULL,               -- bcrypt Hash
-    display_name TEXT NOT NULL,                -- Anzeigename
-    avatar_url TEXT NOT NULL DEFAULT '',       -- Profilbild URL oder leer
-    role TEXT NOT NULL DEFAULT 'member',       -- 'admin' | 'member'
-    is_active INTEGER NOT NULL DEFAULT 1,      -- 1 = aktiv, 0 = gesperrt
-    alarm_channels TEXT NOT NULL DEFAULT 'discord', -- Kommagetrennt: 'email', 'discord', 'webhook'
-    alarm_email TEXT NOT NULL DEFAULT '',      -- Ziel-E-Mail für Alarme
-    discord_webhook_url TEXT NOT NULL DEFAULT '', -- Discord Webhook URL
-    custom_webhook_url TEXT NOT NULL DEFAULT '',  -- HTTP POST JSON Webhook URL
-    notify_before_minutes INTEGER NOT NULL DEFAULT 30, -- Vorwarnzeit in Minuten
-    created_at TEXT NOT NULL,                  -- ISO 8601 String
-    updated_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
-CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);
-```
+## Sicherung
 
-#### `system_settings`
-Globale Instanz-Konfiguration (Key-Value-Tabelle).
-```sql
-CREATE TABLE IF NOT EXISTS system_settings (
-    key TEXT PRIMARY KEY,                      -- 'sharing_mode', 'allow_registration', 'instance_name', 'smtp_...'
-    value TEXT NOT NULL
-);
-```
-
-#### `user_invites`
-Einladungscodes für kontrollierte Benutzer-Registrierungen.
-```sql
-CREATE TABLE IF NOT EXISTS user_invites (
-    id TEXT PRIMARY KEY,                       -- Präfix "inv_..."
-    code TEXT UNIQUE NOT NULL,                 -- Format "MS-XXXXXXXX"
-    email TEXT DEFAULT '',                     -- Optional: an bestimmte E-Mail gebunden
-    role TEXT NOT NULL DEFAULT 'member',       -- Rolle des neuen Kontos ('member', 'admin')
-    created_by TEXT NOT NULL,                  -- Ersteller User-ID
-    used_by TEXT DEFAULT '',                   -- Eingelöste User-ID
-    expires_at TEXT NOT NULL,                  -- Gültig bis (ISO 8601)
-    created_at TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_user_invites_code ON user_invites(code);
-```
-
-#### `api_keys`
-Persönliche API-Schlüssel für externe Skripte, Smarthome und Ingestion.
-```sql
-CREATE TABLE IF NOT EXISTS api_keys (
-    id TEXT PRIMARY KEY,                       -- Präfix "key_..."
-    user_id TEXT NOT NULL,
-    name TEXT NOT NULL,                        -- Bezeichnung (z.B. "Home Assistant")
-    key_prefix TEXT NOT NULL,                  -- Erste 12 Zeichen im Klartext für Anzeige
-    key_hash TEXT UNIQUE NOT NULL,             -- SHA-256 Hash des kompletten Schlüssels
-    scopes TEXT NOT NULL DEFAULT 'ingest,read',
-    last_used_at TEXT NOT NULL DEFAULT '',
-    created_at TEXT NOT NULL,
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-```
-
----
-
-### 2.2 Gruppen & Organisations-Teams
-
-#### `organizations` & `teams` & `team_members`
-```sql
-CREATE TABLE IF NOT EXISTS organizations (
-    id TEXT PRIMARY KEY,                       -- Präfix "org_..."
-    name TEXT NOT NULL,
-    owner_id TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    FOREIGN KEY(owner_id) REFERENCES users(id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS teams (
-    id TEXT PRIMARY KEY,                       -- Präfix "tm_..."
-    org_id TEXT NOT NULL DEFAULT 'default',
-    name TEXT NOT NULL,
-    description TEXT NOT NULL DEFAULT '',
-    created_at TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS team_members (
-    team_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    role TEXT NOT NULL DEFAULT 'member',       -- 'admin' | 'member'
-    joined_at TEXT NOT NULL,
-    PRIMARY KEY (team_id, user_id),
-    FOREIGN KEY(team_id) REFERENCES teams(id) ON DELETE CASCADE,
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-```
-
----
-
-### 2.3 Gedanken, Triage & Aufgaben
-
-In MindSift nutzen Quick Dumps (Triage) und Aufgaben dieselbe Basistabelle **`thoughts`**. Ein Quick Dump ist ein Gedanke mit `status = 'inbox'`, der durch Triage in `status = 'kept'` oder `status = 'converted'` übergeht.
-
-#### `thoughts`
-```sql
-CREATE TABLE IF NOT EXISTS thoughts (
-    id TEXT PRIMARY KEY,                       -- Präfix "th_..."
-    user_id TEXT NOT NULL,
-    content TEXT NOT NULL,                     -- Textinhalt inkl. Hashtags
-    tags TEXT NOT NULL DEFAULT '[]',           -- JSON Array: ["smarthome", "keller"]
-    priority TEXT NOT NULL DEFAULT 'normal',   -- 'low' | 'normal' | 'high' | 'urgent'
-    source TEXT NOT NULL DEFAULT 'manual',     -- 'manual' | 'voice' | 'webhook'
-    status TEXT NOT NULL DEFAULT 'inbox',      -- 'inbox' | 'kept' | 'discarded' | 'converted'
-    is_completed INTEGER NOT NULL DEFAULT 0,   -- 0 = offen, 1 = erledigt
-    converted_type TEXT DEFAULT '',            -- 'task' | 'document' | 'list_item'
-    converted_ref_id TEXT DEFAULT '',          -- Verknüpfte ID (z.B. doc_id oder list_item_id)
-    due_date TEXT DEFAULT '',                  -- Fälligkeitsdatum "YYYY-MM-DD"
-    task_list_id TEXT NOT NULL DEFAULT '',     -- Zugeordnete Aufgabenliste ("" = Standard)
-    kanban_status TEXT NOT NULL DEFAULT 'todo',-- 'todo' | 'in_progress' | 'done' | column.id
-    notes TEXT NOT NULL DEFAULT '',            -- Zusätzliche Notizen / Beschreibung
-    subtasks TEXT NOT NULL DEFAULT '[]',       -- JSON Array von SubTask: [{id, title, isCompleted}]
-    alarm_sent INTEGER NOT NULL DEFAULT 0,     -- 1 = Alarm wurde bereits versendet
-    sort_order INTEGER NOT NULL DEFAULT 0,     -- Manuelle Reorder-Sortierung
-    created_at TEXT NOT NULL,
-    triaged_at TEXT DEFAULT '',
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_thoughts_user_status ON thoughts(user_id, status, created_at DESC);
-CREATE INDEX IF NOT EXISTS idx_thoughts_list_sort ON thoughts(task_list_id, sort_order ASC, created_at DESC);
-```
-
-#### `task_lists` & `task_list_shares`
-```sql
-CREATE TABLE IF NOT EXISTS task_lists (
-    id TEXT PRIMARY KEY,                       -- Präfix "tl_..."
-    user_id TEXT NOT NULL,
-    title TEXT NOT NULL,
-    icon TEXT NOT NULL DEFAULT '📋',
-    color TEXT NOT NULL DEFAULT '#3b82f6',
-    team_id TEXT NOT NULL DEFAULT '',          -- Optional: an Team gebunden
-    columns TEXT NOT NULL DEFAULT '[]',        -- JSON Array von Kanban-Spalten
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS task_list_shares (
-    id TEXT PRIMARY KEY,
-    task_list_id TEXT NOT NULL,
-    target_type TEXT NOT NULL CHECK(target_type IN ('team', 'user')),
-    target_id TEXT NOT NULL,                   -- Team-ID oder User-ID
-    created_at TEXT NOT NULL,
-    created_by TEXT NOT NULL,
-    UNIQUE(task_list_id, target_type, target_id),
-    FOREIGN KEY(task_list_id) REFERENCES task_lists(id) ON DELETE CASCADE
-);
-```
-
----
-
-### 2.4 Workspace: Dokumente, Blöcke & Geteilte Ordner
-
-#### `documents`, `blocks` & `block_tags` (Database-First Outliner Schema)
-Dokumente werden als Kopfdatensatz in `documents` gespeichert, während der Inhalt als feingranulare Blöcke in `blocks` verwaltet wird. Hashtags (#tags) werden per Regex analysiert und in `block_tags` abgelegt. MindSift speichert alle Notizen zu 100% in SQLite (keine physischen `.md`-Dateien auf Festplatte).
-
-```sql
-CREATE TABLE IF NOT EXISTS documents (
-    id TEXT PRIMARY KEY,                       -- Präfix "doc_..."
-    user_id TEXT NOT NULL DEFAULT '',          -- Eigentümer (usr_...)
-    space_id TEXT DEFAULT '',
-    title TEXT NOT NULL DEFAULT '',            -- Dokumenttitel
-    folder_id TEXT NOT NULL DEFAULT '',        -- Ordner-Zuordnung
-    markdown_cache TEXT NOT NULL DEFAULT '',   -- Kompiliertes Standard-Markdown (automatischer Cache)
-    icon TEXT NOT NULL DEFAULT '📄',           -- Emoji-Icon
-    content TEXT NOT NULL DEFAULT '',          -- Plaintext / Text-Repräsentation
-    blocks_json TEXT NOT NULL DEFAULT '[]',    -- Legacy/Zusatz-Cache
-    tags TEXT NOT NULL DEFAULT '[]',           -- JSON Array von Tags
-    folder_path TEXT NOT NULL DEFAULT '',      -- Relativer Ordnerpfad des Eigentümers
-    is_pinned INTEGER NOT NULL DEFAULT 0,      -- Globaler Pin
-    is_archived INTEGER NOT NULL DEFAULT 0,
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_documents_user ON documents(user_id, is_archived, updated_at DESC);
-
-CREATE TABLE IF NOT EXISTS blocks (
-    id TEXT PRIMARY KEY,                       -- Block-ID (z.B. "blk_..." oder "docId-b0")
-    document_id TEXT NOT NULL,                 -- Zugehöriges Dokument (doc_...)
-    content TEXT NOT NULL DEFAULT '',          -- Textinhalt des Blocks
-    level INT NOT NULL DEFAULT 0,              -- Hierarchieebene (0 = Root, 1 = Kind...)
-    position REAL NOT NULL DEFAULT 0,          -- Fließkommazahl für konfliktfreies Einfügen/Sortieren
-    type TEXT NOT NULL DEFAULT 'bullet',       -- 'bullet', 'todo', 'h1', 'h2', 'h3', 'code', 'quote', 'callout', 'divider'
-    checked INTEGER NOT NULL DEFAULT 0,        -- Für Checklisten (0 = offen, 1 = abgehakt)
-    collapsed INTEGER NOT NULL DEFAULT 0,      -- Für eingeklappte Unterbäume (1 = zugeklappt)
-    lang TEXT NOT NULL DEFAULT '',             -- Programmiersprache für Codeblöcke
-    FOREIGN KEY(document_id) REFERENCES documents(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_blocks_doc_pos ON blocks(document_id, position ASC);
-
-CREATE TABLE IF NOT EXISTS block_tags (
-    tag TEXT NOT NULL,                         -- Hashtag (z.B. "meeting", ohne führendes '#')
-    document_id TEXT NOT NULL,                 -- Zugehöriges Dokument
-    block_id TEXT NOT NULL,                    -- Zugehöriger Block
-    PRIMARY KEY(tag, block_id),
-    FOREIGN KEY(document_id) REFERENCES documents(id) ON DELETE CASCADE,
-    FOREIGN KEY(block_id) REFERENCES blocks(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_block_tags_tag ON block_tags(tag);
-CREATE INDEX IF NOT EXISTS idx_block_tags_doc ON block_tags(document_id);
-```
-
-#### Entkoppelte Ordner-Freigabe (`workspace_shared_folders` & `workspace_folder_mounts`)
-Ermöglicht das Teilen kompletter Ordnerstrukturen. Verschiebt ein Empfänger den geteilten Ordner in seiner Hierarchie, wird **nur sein Mount-Pfad** aktualisiert – die Quellstruktur beim Eigentümer und anderen Empfängern bleibt unberührt!
-
-```sql
-CREATE TABLE IF NOT EXISTS workspace_shared_folders (
-    id TEXT PRIMARY KEY,                       -- Präfix "wsf_..."
-    owner_id TEXT NOT NULL,
-    name TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS workspace_folder_shares (
-    id TEXT PRIMARY KEY,
-    folder_id TEXT NOT NULL,
-    target_type TEXT NOT NULL CHECK(target_type IN ('team', 'user')),
-    target_id TEXT NOT NULL,
-    permission TEXT NOT NULL CHECK(permission IN ('read', 'write')),
-    created_by TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    UNIQUE(folder_id, target_type, target_id)
-);
-
-CREATE TABLE IF NOT EXISTS workspace_folder_mounts (
-    user_id TEXT NOT NULL,
-    folder_id TEXT NOT NULL,
-    mount_path TEXT NOT NULL,                  -- Eigener lokaler Pfad des Benutzers (z.B. "Arbeit/Projekte/Team-Docs")
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY(user_id, folder_id)
-);
-
-CREATE TABLE IF NOT EXISTS doc_user_folders (
-    user_id TEXT NOT NULL,
-    doc_id TEXT NOT NULL,
-    folder_path TEXT NOT NULL DEFAULT '',      -- Individuelle Ordnerplatzierung für geteilte Einzelnotizen
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    PRIMARY KEY(user_id, doc_id)
-);
-```
-
----
-
-### 2.5 Geteilte Listen & Listen-Einträge
-
-#### `lists`, `list_items` & `list_shares`
-```sql
-CREATE TABLE IF NOT EXISTS lists (
-    id TEXT PRIMARY KEY,                       -- Präfix "lst_..."
-    user_id TEXT NOT NULL,
-    title TEXT NOT NULL,
-    icon TEXT NOT NULL DEFAULT '🛒',
-    list_type TEXT NOT NULL DEFAULT 'shopping',-- 'shopping', 'packing', 'inventory', 'todo'
-    updated_at TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_lists_user ON lists(user_id, updated_at DESC);
-
-CREATE TABLE IF NOT EXISTS list_shares (
-    id TEXT PRIMARY KEY,
-    list_id TEXT NOT NULL,
-    target_type TEXT NOT NULL CHECK(target_type IN ('team', 'user')),
-    target_id TEXT NOT NULL,
-    role TEXT NOT NULL DEFAULT 'editor' CHECK(role IN ('editor', 'viewer')),
-    created_by TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    UNIQUE(list_id, target_type, target_id),
-    FOREIGN KEY(list_id) REFERENCES lists(id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS list_items (
-    id TEXT PRIMARY KEY,                       -- Präfix "itm_..."
-    list_id TEXT NOT NULL,
-    content TEXT NOT NULL,                     -- Bezeichnung des Eintrags
-    category TEXT NOT NULL DEFAULT '',         -- Regal/Kategorie (z.B. "Kühlregal")
-    quantity TEXT NOT NULL DEFAULT '',         -- Menge (z.B. "2x", "500g")
-    is_completed INTEGER NOT NULL DEFAULT 0,   -- 1 = abgehakt
-    completed_by TEXT NOT NULL DEFAULT '',     -- User-ID des Abhakers
-    completed_by_name TEXT NOT NULL DEFAULT '',-- Name des Abhakers für Live-Badge
-    sort_order INTEGER NOT NULL DEFAULT 0,
-    created_at TEXT NOT NULL,
-    completed_at TEXT NOT NULL DEFAULT '',
-    FOREIGN KEY(list_id) REFERENCES lists(id) ON DELETE CASCADE
-);
-CREATE INDEX IF NOT EXISTS idx_list_items_sync ON list_items(list_id, is_completed, sort_order ASC);
-```
-
----
-
-## 🔄 3. Migrationsstrategie
-
-MindSift setzt auf **idempotente automatische In-Process-Migrationen** beim Serverstart ([`internal/storage/sqlite.go`](../internal/storage/sqlite.go)):
-1. **Schema-Bootstrap:** Ausführung des Basis-Schemas via `CREATE TABLE IF NOT EXISTS`.
-2. **Column & Index Migration Array:** Ein vordefiniertes Array idempotenter DDL-Befehle (z.B. `ALTER TABLE thoughts ADD COLUMN ...`, `CREATE TABLE IF NOT EXISTS doc_user_folders ...`).
-3. **Fehlerbehandlung:** Wenn Spalten bereits existieren (z.B. `"duplicate column name"`), wird der Fehler ignoriert und der Start fortgesetzt.
-4. **Vorteil:** Keine manuellen Migrations-Skripte nötig; Container-Updates können jederzeit ohne Downtime oder Vorbereitung über bestehende Datenbanken ausgerollt werden.
+Die gesamte Instanz besteht aus der Datei `mindsift.db` (plus `-wal`/`-shm` im laufenden Betrieb). Konsistent sichern per `sqlite3 mindsift.db ".backup 'backup.db'"` oder durch Stoppen des Containers und Kopieren des `data/`-Verzeichnisses. Benutzerexport: `GET /api/v1/export` (JSON mit Gedanken, Notizen, Listen, Aufgabenlisten).

Doku/flaws.md

@@ -1,130 +1,173 @@
-# Bekannte Schwachstellen, Risiken & Technische Schulden (Flaws)
+# Bekannte Schwachstellen, Risiken & technische Schulden (Flaws)
 
-Diese Datei dokumentiert eine ehrliche und schonungslose technische Analyse aller bekannten Limitierungen, Architektur-Kompromisse, Skalierungsrisiken und UX-Schwachstellen in **MindSift**. Sie dient als verbindlicher Backlog für zukünftige Refactorings und Architektur-Meilensteine.
+Stand: Code-Review des Branches `dev` (Oktober 2026). Jeder Eintrag wurde gegen den Quellcode geprüft; die Fundstellen sind angegeben. Einträge ohne Live-Test sind als *nicht live verifiziert* markiert.
+
+Schweregrade: **Hoch** (Datenabfluss oder Rechteumgehung möglich), **Mittel** (Fehlfunktion oder Schutz greift nicht), **Niedrig** (Wartbarkeit, Komfort, Hygiene).
 
 ---
 
-## 📌 Übersicht & Risikomatrix
+## Übersicht
 
-| ID | Bereich | Problem / Schwachstelle | Schweregrad | Risiko im Produktivbetrieb |
-|---|---|---|---|---|
-| **FLAW-01** | Workspace Sync | Blockierende Locks / Synchronisations-Konflikte | **Gelöst (v2.2)** | Behoben durch In-Memory DocRooms, Echo-Schutz per `clientId` und 1.5s Debounce-Flush |
-| **FLAW-02** | Storage | Dual-Storage Drift (SQLite vs. Dateisystem) | **Obsolet / Gelöst** | Kein Risiko: MindSift nutzt Pure-DB (keine `.md`-Dateien auf Platte) |
-| **FLAW-03** | Netzwerk / WS | Proxy-Inkompatibilität bei WebSocket-Upgrades & Polling-Fallback | **Gelöst (v2.2)** | Behoben durch Dual-Transport SSE-Fallback & globale Singleton-Verbindung |
-| **FLAW-04** | Datenbank / Suche | Volltextsuche via `LIKE '%query%'` statt SQLite FTS5 | **Mittel** | Performance-Einbrüche bei wachsenden Notizbeständen (>10.000 Blöcke) |
-| **FLAW-05** | Frontend DOM | Fehlende Virtualisierung im Outliner-Baum | **Mittel** | Frame-Drops und Lags bei Dokumenten mit >500 Blöcken auf Mobilgeräten |
-| **FLAW-06** | SQLite Concurrency | Single-Writer-Bottleneck bei hohem parallelem Schreibaufkommen | **Mittel** | `SQLITE_BUSY` Fehler bei vielen gleichzeitigen Team-Nutzern |
-| **FLAW-07** | Benachrichtigungen | Fehlende Dead-Letter-Queue für Webhook- & E-Mail-Alarme | **Niedrig** | Verlorene Benachrichtigungen bei temporärem Ausfall von Drittsystemen |
-| **FLAW-08** | Sicherheit / Auth | Statische JWT-Tokens ohne rotierende Refresh-Tokens & Blacklisting | **Niedrig** | Keine sofortige Sitzungsinvalidierung bei Rechteentzug |
+| ID | Bereich | Kurzbeschreibung | Schwere |
+|---|---|---|---|
+| FLAW-01 | Realtime | `BroadcastToAll` sendet Aufgaben- und Listendaten an alle Verbindungen, auch unauthentifizierte | **Hoch** |
+| FLAW-02 | Realtime | Räume (WS `JOIN_ROOM`, SSE `/events/rooms`, `?listId=`) ohne Berechtigungsprüfung | **Hoch** |
+| FLAW-03 | Aufgaben | `ReorderTasks` ändert beliebige Aufgaben per ID, ohne Zugriffsprüfung (IDOR) | **Hoch** |
+| FLAW-04 | Auth | Fest eincodiertes Fallback-`JWT_SECRET` | **Hoch** |
+| FLAW-05 | Benachrichtigungen | Discord-/Webhook-URLs ungeprüft (SSRF) | Mittel |
+| FLAW-06 | Aufgaben | Jeder Editor einer Aufgabenliste kann sie per `teamId` an weitere Gruppen freigeben | Mittel |
+| FLAW-07 | Auth | API-Key-`scopes` werden nie ausgewertet; ein Key ist ein Vollzugriff | Mittel |
+| FLAW-08 | Auth | Webhook-Ingest mit JWT prüft weder Sperrliste noch `token_version` noch `is_active` | Mittel |
+| FLAW-09 | Auth | Kein Rate-Limit, keine Sperre bei Fehlversuchen, Mindestpasswort 4 Zeichen | Mittel |
+| FLAW-10 | Freigaben | `sharing_mode` wird bei Freigaben nicht durchgesetzt; Benutzerverzeichnis leakt alle Konten | Mittel |
+| FLAW-11 | Workspace | Block-Upsert (`ON CONFLICT(id)`) prüft das Dokument nicht | Mittel |
+| FLAW-12 | Benachrichtigungen | `notify_before_minutes` wirkungslos; Alarm feuert nach Umplanung nie wieder | Mittel |
+| FLAW-13 | Datenbank | Keine Schema-Versionierung; Migrationsfehler werden verschluckt; `migrations/001_init.sql` ist toter Code | Mittel |
+| FLAW-14 | Backend | Fehler von Schreiboperationen werden häufig ignoriert (`_, _ =`) | Mittel |
+| FLAW-15 | Realtime | `WriteTimeout` von 30 s trifft vermutlich auch SSE-Streams *(nicht live verifiziert)* | Mittel |
+| FLAW-16 | Setup | `/auth/setup` ist bis zum ersten Konto offen; Demo-Modus legt `admin/admin` an | Mittel |
+| FLAW-17 | Workspace | Dokument- und Ordnerfreigaben sind per Migration erzwungen schreibgeschützt; tote Schreibpfade | Niedrig |
+| FLAW-18 | Suche | Nur eigene Gedanken und Dokumente, `LIKE` ohne Escaping, keine FTS | Niedrig |
+| FLAW-19 | Qualität | Keine Frontend-Tests, `lint` und `test:run` sind Platzhalter | Niedrig |
+| FLAW-20 | Qualität | Sehr große Dateien, duplizierte Zugriffslogik | Niedrig |
+| FLAW-21 | Repo | `LICENSE` fehlt, obwohl README MIT angibt | Niedrig |
+| FLAW-22 | Netzwerk | Token in der URL (WS/SSE), CORS `*`, `CheckOrigin` immer `true` | Niedrig |
+| FLAW-23 | SQLite | Single-Writer-Engpass bei vielen gleichzeitigen Schreibern | Niedrig |
+| FLAW-24 | Gruppen | Organisations-Endpunkte ohne Berechtigungsprüfung | Mittel |
 
 ---
 
-## 🔍 Detaillierte Analyse & Maßnahmen
+## Details
 
-### FLAW-01: [GELÖST / IMPLEMENTIERT] Granulare Outliner-Synchronisation & Multi-User Kollaboration
-- **Status:** **Gelöst via In-Memory DocRooms, Echo-Schutz & Debounced Persistence**
-- **Betroffene Komponenten:** [`api/websocket.md`](./api/websocket.md), [`modules/workspace.md`](./modules/workspace.md), `internal/ws/docroom.go`, `internal/storage/sqlite.go`, `frontend/src/lib/useDocumentSync.ts`, `frontend/src/features/workspace/OutlinerBlock.tsx`
-- **Ursache (Historisch):** MindSift nutzte früher pessimistisches Dokumentensperren (Lease-Locks mit Heartbeats). Bei parallelem Bearbeiten blockierten sich Nutzer gegenseitig; unausgereifte Sync-Versuche führten zu Selbstechos und Cursor-Jumps.
-- **Implementierte Lösung:**
-  1. **In-Memory DocRooms:** Granularer WebSocket-Raum pro Dokument (`/api/v1/ws/docs/:id`) mit Mutex-geschütztem Block-State im Go-Backend.
-  2. **Strikter Echo-Schutz per `clientId`:** Jede Verbindung besitzt eine eindeutige `clientId`. Der Hub filtert den Sender heraus und leitet Events nur an Peers weiter.
-  3. **Live Presence & Ephemere Cursors:** Cursorposition und Textselektionen (`cursor_moved`) werden flüchtig an Peers gestreamt, ohne SQLite zu belasten.
-  4. **Fokus- & Eingabeschutz (`OutlinerBlock.tsx`):** Remote-Updates werden nur blockiert, wenn `document.hasFocus()` vorliegt. Bei `window.onblur` und `input.onblur` wird sofort (0ms) geflusht; Callbacks werden über `useRef` geführt (keine Stale Closures).
-  5. **1.5s Inaktivitäts-Debounce-Flush:** Nach 1,5s Inaktivität sichert der Raum persistent in SQLite (`blocks`, Regex `#tags` in `block_tags` und kompiliertes Markdown in `documents.markdown_cache`).
-  6. **Vollständige Eliminierung von Locks:** Alle blockierenden Sperren wurden restlos entfernt. Mehrere Nutzer können zeitgleich schreiben.
+### FLAW-01: Broadcast an alle Verbindungen (Datenabfluss)
+- **Fundstellen:** [`internal/ws/hub.go`](../internal/ws/hub.go) `BroadcastToAll`; Aufrufer in [`internal/api/server.go`](../internal/api/server.go): `handleUpdateThought` (`TASK_UPDATED`), `handleDeleteThought` (`TASK_DELETED`), `handleReorderTasks` (`TASK_REORDERED`), `handleUpdateTaskList`, `handleCreateTaskListShare`, `handleDeleteTaskListShare` (`TASK_LIST_UPDATED`), `handleDeleteTaskList`.
+- **Problem:** `BroadcastToAll` schreibt an `allClients` und `sseClients`. Dazu zählen auch Verbindungen mit `userID = "anonymous"`, denn `handleWebSocket` und `handleSSE` liegen außerhalb der Auth-Gruppe und lassen jede Verbindung zu. Der vollständige Aufgabeninhalt (Titel, Notizen, Unteraufgaben) und die Listen samt Mitgliedern gehen so an jeden, der `/api/v1/events` öffnet.
+- **Maßnahme:** Ereignisse an die berechtigten Nutzer adressieren (wie bei `DOC_*` über `GetAuthorizedDocUsers`), unauthentifizierte Verbindungen ablehnen.
+
+### FLAW-02: Räume ohne Berechtigungsprüfung
+- **Fundstellen:** `Hub.readPump` (`JOIN_ROOM`), `handleSSERooms` (Route `/api/v1/events/rooms` liegt **außerhalb** der Auth-Gruppe), `Hub.Register` (Raum aus `?listId=`/`?spaceId=`).
+- **Problem:** Wer eine Raum-ID kennt (`doc:<id>`, Listen-ID), tritt bei und erhält Inhalte wie `DOC_BLOCKS_PATCHED` oder `ITEM_*`. Raum-IDs tauchen in Ereignissen auf und sind nicht geheim. Für den SSE-Beitritt reicht die `sseId`, die der Server selbst im Stream mitsendet.
+- **Maßnahme:** Beitritt nur nach Zugriffsprüfung (`GetDocumentByID`, `GetListByID`); `/events/rooms` hinter `authMiddleware`.
+
+### FLAW-03: `ReorderTasks` ohne Zugriffsprüfung (IDOR)
+- **Fundstelle:** `Store.ReorderTasks` (`UPDATE thoughts SET sort_order … WHERE id = ?`) und `handleReorderTasks`.
+- **Problem:** Die SQL-Anweisung ist weder auf `user_id` noch auf die Liste eingeschränkt. Jeder angemeldete Nutzer kann `sortOrder`, `kanbanStatus` und damit `isCompleted` fremder Aufgaben ändern, sofern er die ID kennt. Die Leser-Prüfung für Aufgabenlisten überspringt Aufgaben, auf die der Nutzer gar keinen Zugriff hat (`GetThoughtByID` liefert dann einen Fehler), und schützt davor nicht.
+- **Maßnahme:** Jede ID gegen `accessibleTaskListIDsQuery` bzw. `user_id` prüfen und bei Verstoß ablehnen.
+
+### FLAW-04: Fallback-JWT-Secret
+- **Fundstelle:** [`internal/config/config.go`](../internal/config/config.go): `getEnv("JWT_SECRET", "mindsift-default-selfhosted-jwt-secret-key-2026")`; `docker-compose.yml` und `.env.example` liefern ebenfalls einen Platzhalter.
+- **Problem:** Wer `JWT_SECRET` nicht setzt (oder den Platzhalter behält), läuft mit einem öffentlich bekannten Schlüssel. Damit lassen sich gültige Tokens für jede Benutzer-ID fälschen. `install.sh` erzeugt zwar ein Secret, andere Installationswege nicht.
+- **Maßnahme:** Start verweigern oder Secret beim ersten Start erzeugen und in `/data` ablegen.
+
+### FLAW-05: SSRF über Alarm-URLs
+- **Fundstellen:** `handleUpdateUserSettings` (keine Validierung), `sendDiscordNotification`, `sendCustomWebhookNotification`.
+- **Problem:** Jeder Nutzer kann beliebige URLs hinterlegen. Der Server sendet POST-Anfragen dorthin, auch an interne Adressen (`http://169.254.169.254`, Docker-Netz, `localhost`). Über `handleTestUserAlarm` lässt sich das sofort auslösen.
+- **Maßnahme:** Nur `https`, Discord-Host prüfen, private/Loopback-Adressen beim Verbinden sperren.
+
+### FLAW-06: Editor kann Aufgabenliste weiterteilen
+- **Fundstelle:** `Store.UpdateTaskList` (`teamID`-Zweig ruft `AddTaskListShare`); `handleUpdateTaskList` prüft nur, dass der Nutzer **kein** Leser ist.
+- **Problem:** `POST /task-lists/{id}/shares` ist Eigentümern vorbehalten. Über `PUT /task-lists/{id}` mit `teamId` kann aber jeder Editor die Liste einer weiteren Gruppe zuweisen (mit Schreibrecht) und die Zuweisung der bisherigen Gruppe aufheben.
+- **Maßnahme:** `teamId`-Änderungen nur für den Eigentümer; das Legacy-Feld `task_lists.team_id` zugunsten von `task_list_shares` abschaffen.
+
+### FLAW-07: API-Key-Scopes ohne Wirkung
+- **Fundstellen:** Tabelle `api_keys.scopes` (Standard `ingest,read`), `authMiddleware`.
+- **Problem:** Ein Key mit Präfix `mindsift_sec_` authentifiziert als der Benutzer, mit allen Rechten: alle `/api/v1`-Routen, bei Admins auch `/admin/*`, außerdem das Anlegen weiterer Keys. Für Webhooks (nur Aufgaben anlegen) ist das überdimensioniert.
+- **Maßnahme:** Scopes auswerten; Keys standardmäßig nur auf `/inbox` und `/webhooks/ingest` beschränken.
+
+### FLAW-08: Webhook-Ingest umgeht Sitzungsprüfung
+- **Fundstelle:** `handleWebhookIngest`, JWT-Zweig.
+- **Problem:** Das Token wird nur kryptografisch validiert. `IsTokenRevoked`, `token_version` und `is_active` werden nicht geprüft; ein ausgeloggtes oder deaktiviertes Konto kann weiter Aufgaben anlegen (bis Token-Ablauf nach 30 Tagen).
+- **Maßnahme:** Dieselbe Prüfkette wie in `authMiddleware` verwenden (gemeinsame Funktion statt Kopien; siehe auch `authenticateUserFromReq`).
+
+### FLAW-09: Kein Schutz gegen Brute-Force
+- **Fundstellen:** `handleLogin`, `handleRegister`, `handleFirstBootSetup`.
+- **Problem:** Weder Rate-Limit noch Sperre; `middleware.RealIP` vertraut `X-Forwarded-For` ungeprüft. Mindestpasswortlänge ist 4 Zeichen. Der Login-Pfad ist so über das Internet raten- und durchprobierbar.
+- **Maßnahme:** Rate-Limit je IP und Konto, längeres Mindestpasswort.
+
+### FLAW-10: `sharing_mode` wird nicht durchgesetzt
+- **Fundstellen:** `Store.GetDiscoverableUsers`, `Store.GetCollaborators`; Share-Handler in `server.go`.
+- **Problem:**
+  1. Der Modus beeinflusst nur `GetDiscoverableUsers`. In `teams_only` liefert die Funktion trotzdem **alle** Benutzer (`if … mode == "open" || mode == "teams_only" { return GetAllUsers() }`).
+  2. `GET /collaborators` ignoriert den Modus komplett und liefert alle aktiven Konten mit E-Mail-Adresse.
+  3. Keine der Share-Funktionen prüft den Modus. `strict_private` und `teams_only` verhindern Freigaben nicht, wenn man die Ziel-ID kennt.
+- **Maßnahme:** Eine zentrale Funktion `canShareWith(owner, target)` und in allen Share-Handlern verwenden; Verzeichnisse darauf einschränken.
+
+### FLAW-11: Block-Upsert prüft das Dokument nicht
+- **Fundstelle:** `Store.PatchDocumentBlocks`, `INSERT INTO blocks … ON CONFLICT(id) DO UPDATE`.
+- **Problem:** `blocks.id` ist global eindeutig. Existiert die ID bereits in einem **anderen** Dokument, überschreibt der Konflikt-Zweig dessen Inhalt, ohne `document_id` zu prüfen. Voraussetzung: Schreibrecht im eigenen Dokument und Kenntnis einer fremden Block-ID.
+- **Maßnahme:** `DO UPDATE … WHERE blocks.document_id = excluded.document_id`; fremde IDs ablehnen.
+
+### FLAW-12: Alarm-Logik
+- **Fundstellen:** `startAlarmTicker`, `GetDueTasksForAlarm`, `UpdateThoughtDetails`, `UserSettingsView`.
+- **Probleme:**
+  - `notify_before_minutes` (Einstellungen: „15 Minuten vorher“ usw.) wird nirgends gelesen. Fälligkeiten haben nur ein Datum (`YYYY-MM-DD`), eine Vorlaufzeit ist damit nicht abbildbar.
+  - Verglichen wird mit `time.Now()` in der Zeitzone des Containers (ohne `TZ` also UTC).
+  - `alarm_sent` wird nie zurückgesetzt. Wird die Fälligkeit nach einem Alarm verschoben, gibt es keinen neuen.
+  - Schlagen alle Kanäle fehl, wird jede Minute erneut gesendet (kein Backoff, keine Dead-Letter-Queue).
+- **Maßnahme:** Fälligkeit mit Uhrzeit speichern, `alarm_sent` bei Änderung von `due_date` zurücksetzen, Wiederholungen begrenzen.
+
+### FLAW-13: Migrationen
+- **Fundstellen:** `Store.migrate` in [`internal/storage/sqlite.go`](../internal/storage/sqlite.go), [`migrations/001_init.sql`](../migrations/001_init.sql).
+- **Probleme:**
+  - Es gibt keine Versionstabelle. Alle `ALTER TABLE`-Anweisungen laufen bei jedem Start erneut; Fehler werden pauschal ignoriert (`_, _ = s.db.Exec(q)`), echte Fehler fallen nicht auf.
+  - Mehrere `UPDATE`/`DROP TABLE`-Bereinigungen laufen bei jedem Start.
+  - `migrations/001_init.sql` wird nur in das Image kopiert, aber nirgends gelesen, und ist gegenüber dem tatsächlichen Schema veraltet.
+- **Maßnahme:** `schema_migrations`-Tabelle mit nummerierten, einmalig ausgeführten Schritten; die SQL-Datei entweder einbetten oder entfernen.
+
+### FLAW-14: Verschluckte Fehler
+- **Fundstellen:** u. a. `PatchDocumentBlocks` (Upserts/Deletes), `AddTaskListShare`, `RemoveTaskListShare`, viele `_, _ = s.db.Exec`.
+- **Problem:** Scheitert ein Schreibzugriff (z. B. `SQLITE_BUSY`), antwortet die API trotzdem mit Erfolg und broadcastet den Stand, der nie gespeichert wurde. Fehler lassen sich nur schwer nachvollziehen.
+- **Maßnahme:** Mehrstufige Änderungen in Transaktionen bündeln und Fehler zurückgeben.
+
+### FLAW-15: WriteTimeout und SSE *(nicht live verifiziert)*
+- **Fundstelle:** [`cmd/server/main.go`](../cmd/server/main.go) `WriteTimeout: 30 * time.Second`.
+- **Problem:** Go beendet nach diesem Zeitraum das Schreiben der Antwort. Für den SSE-Fallback (`ServeSSE`) bedeutet das voraussichtlich einen Verbindungsabbruch alle 30 s. WebSockets sind durch Hijacking nicht betroffen. Der Client verbindet sich neu, daher fällt es kaum auf.
+- **Maßnahme:** Im SSE-Handler `http.ResponseController.SetWriteDeadline(time.Time{})` setzen oder `WriteTimeout` für diese Route aufheben.
+
+### FLAW-16: Ersteinrichtung und Demo-Modus
+- **Fundstellen:** `handleFirstBootSetup`, `Store.EnsureDemoAccounts`, `config.Load` (`MINDA_DEMO`, `MINDSIFT_DEMO`, `DEMO_MODE`).
+- **Probleme:** Solange kein Konto existiert, kann jeder `POST /auth/setup` aufrufen und wird Administrator. Mit gesetztem Demo-Flag entstehen Konten `admin/admin` und `user/user`; versehentlich auf einer öffentlichen Instanz aktiv wäre das eine Komplettübernahme.
+- **Maßnahme:** Setup per einmaligem Token aus dem Server-Log absichern; Demo-Modus nur zusammen mit expliziter Warnung/Bestätigung.
+
+### FLAW-17: Schreibgeschützte Dokumentfreigaben
+- **Fundstellen:** Migration in `Store.migrate` (`UPDATE doc_shares SET permission = 'read' …`, ebenso `doc_team_shares`, `workspace_folder_shares`), `PatchDocumentBlocks`/`UpdateDocument` (nur Eigentümer).
+- **Hinweis:** Das ist offenbar gewollt: Nur der Eigentümer schreibt in ein Dokument, Empfänger lesen. Es gibt daher **kein** kollaboratives Bearbeiten. Das Schema (`CHECK(permission IN ('read','write'))`), die Zweige für `write` im Code und frühere Dokumentation suggerieren etwas anderes. Es gibt weder Sperren noch Konfliktauflösung, noch Cursor-Presence.
+- **Maßnahme:** Entweder Schreibfreigaben mit Konfliktbehandlung ergänzen oder den toten Code und das Schema bereinigen.
+
+### FLAW-18: Suche
+- **Fundstelle:** `Store.SearchAll`.
+- **Probleme:** Durchsucht nur eigene Gedanken (30) und eigene Dokumente (20); geteilte Dokumente, Aufgaben aus geteilten Listen, Einkaufslisten und Blöcke bleiben außen vor. `LIKE '%…%'` ohne Escaping von `%`/`_`, keine Indizes, keine Relevanz.
+- **Maßnahme:** FTS5-Index über Blöcke/Gedanken; Berechtigungen mitberücksichtigen.
+
+### FLAW-19: Keine automatisierten Frontend-Prüfungen
+- **Fundstelle:** [`frontend/package.json`](../frontend/package.json): `"lint": "echo 'Linting passed'"`, `"test:run": "echo 'Frontend checks passed'"`.
+- **Problem:** Die Skripte melden immer Erfolg. Die CI (`.gitea/workflows/build-and-publish.yaml`) prüft daher nur Go-Tests und den Vite-Build. Regressionen im UI (z. B. Berechtigungsanzeigen) fallen nicht auf.
+- **Maßnahme:** `tsc --noEmit` und ESLint als echte Skripte, Komponententests für kritische Pfade.
+
+### FLAW-20: Dateigröße und Duplikate
+- `internal/storage/sqlite.go` (≈ 5.600 Zeilen), `internal/api/server.go` (≈ 3.000), `WorkspaceView.tsx` (≈ 2.300), `TasksView.tsx` (≈ 2.500), `api.ts` (≈ 1.500).
+- Die Zugriffsabfrage für Aufgabenlisten steht dreimal fast identisch im Code (`accessibleTaskListIDsQuery`, `GetTaskLists`, `GetTaskListByID`). Dokumentzugriff ist ähnlich verteilt. Änderungen an Berechtigungen müssen an mehreren Stellen erfolgen und werden leicht vergessen.
+- **Maßnahme:** In Teilmodule zerlegen (Auth, Dokumente, Aufgaben, Listen, Teams), Zugriffsprüfung zentralisieren.
+
+### FLAW-21: Lizenzdatei fehlt
+- README und Badge nennen die MIT-Lizenz und verlinken auf `LICENSE`; die Datei existiert nicht im Repository.
+
+### FLAW-22: Netzwerk-Details
+- `authenticateUserFromReq` akzeptiert das Token als `?token=` (nötig für `WebSocket`/`EventSource`, die keine Header setzen). Tokens landen dadurch in Proxy- und Zugriffslogs.
+- `AllowedOrigins: ["*"]` (Auth läuft über `Authorization`-Header, nicht über Cookies, das Risiko ist daher begrenzt) und `CheckOrigin` liefert immer `true`.
+- Ein einmal verbundener WebSocket/SSE-Stream wird bei Logout oder Token-Widerruf nicht getrennt.
+- **Maßnahme:** Kurzlebiges, einmaliges Stream-Ticket statt Langzeit-JWT in der URL; Origin gegen `BASE_URL` prüfen.
+
+### FLAW-23: SQLite-Schreibengpass
+- Eine SQLite-Datei (WAL, `busy_timeout`, bis zu 8 offene Verbindungen) erlaubt nur einen gleichzeitigen Schreiber. Für Familien und kleine Teams unkritisch; bei vielen aktiven Editoren sind `SQLITE_BUSY`-Fehler möglich, die wegen FLAW-14 stumm bleiben.
+
+### FLAW-24: Organisations-Endpunkte ohne Berechtigungsprüfung
+- **Fundstellen:** `handleDeleteOrganization`, `handleGetOrgTeams`, `handleCreateOrgTeam` (und `Store.DeleteOrganization`) in `server.go` bzw. `sqlite.go`.
+- **Problem:** Diese Handler prüfen weder Eigentümer noch Mitgliedschaft. Jeder angemeldete Nutzer kann mit bekannter ID eine fremde Organisation löschen, deren Gruppen auflisten oder dort Gruppen anlegen. Gruppenbezogene Endpunkte (`/teams/{id}…`) prüfen dagegen korrekt auf Gruppen-Admin. Das Datenmodell kennt Organisationen nur noch rudimentär; im UI werden Gruppen direkt über `POST /teams` angelegt (`orgId` Standard `default`).
+- **Maßnahme:** Organisationen entweder konsequent absichern (Eigentümer/Server-Admin) oder entfernen.
 
 ---
 
-### FLAW-02: [OBSOLET / GELÖST] Dual-Storage Drift (SQLite vs. Dateisystem)
-- **Status:** **Entkräftet & Behoben (Pure Database Architecture)**
-- **Klarstellung:** In früheren Entwürfen wurde angedacht, Notizen zusätzlich als Markdown-Dateien auf dem Dateisystem zu spiegeln. MindSift speichert Notizen und Blöcke jedoch **zu 100% relational in SQLite** (`documents` und `document_blocks`).
-- **Verifikation:**
-  - Es existieren **keine** Markdown-Dateien auf der Festplatte.
-  - Das Go-Backend schreibt keine Dateien in ein Notizverzeichnis.
-  - Unnötige Verzeichniserstellungen (`docDir`/`workspace`) wurden aus `internal/storage/sqlite.go` vollständig entfernt.
-- **Ergebnis:** Es gibt keinen Dual-Storage und somit keinen File-Drift oder externe Dateikonflikte. Notizen verhalten sich vollständig transaktional und konsistent innerhalb der SQLite-Datenbank.
+## Aus der früheren Fassung entfernt
 
----
-
-### FLAW-03: [GELÖST / IMPLEMENTIERT] Proxy-Inkompatibilität bei WebSocket-Upgrades & Polling-Fallback
-- **Status:** **Gelöst & Vollständig Implementiert (Dual-Transport SSE Fallback & Proxy-Resilienz)**
-- **Betroffene Komponenten:** [`api/websocket.md`](./api/websocket.md), [`reverse-proxy.md`](./reverse-proxy.md), [`internal/ws/hub.go`](../internal/ws/hub.go), [`internal/api/server.go`](../internal/api/server.go), [`frontend/src/lib/api.ts`](../frontend/src/lib/api.ts)
-- **Problemursache:** Corporate Proxies (z.B. Zscaler, BlueCoat, strikte Firewalls) oder unvollständig konfigurierte Reverse-Proxies verwerfen den HTTP-Upgrade-Header `Upgrade: websocket` (`NS_ERROR_CONNECTION_REFUSED`, Status 1006 / 1002). Früher fiel der Client dabei auf 2-Sekunden-Polling zurück, was zu Verzögerungen und Last führte.
-- **Implementierte Lösung:**
-  1. **Unidirektionaler Server-Sent Events (SSE) Fallback:**
-     - Neuer Streaming-Endpunkt `GET /api/v1/events` im Go-Backend mit `Content-Type: text/event-stream`, `X-Accel-Buffering: no` und 15s Heartbeat-Pings (`: ping\n\n`).
-     - Standard HTTPS Ports (443/80), wodurch kein Proxy den Datenstrom blockieren kann.
-  2. **Hub-Multiplexing:**
-     - `ws.Hub` verwaltet WebSocket- und SSE-Clients parallel in gemeinsamen Räumen (`rooms`, `userRooms`, `allClients`).
-     - Sämtliche Events (`BroadcastToAll`, `BroadcastToUser`, `BroadcastRoom`) werden transparent an beide Transportarten verteilt.
-  3. **REST-Parität für Outbound CRDT & Awareness:**
-     - `PUT /api/v1/documents/:id/crdt`: Akzeptiert Delta-Updates (`update`) und broadcastet sie an alle Peers.
-     - `POST /api/v1/documents/:id/awareness` und `DELETE /api/v1/documents/:id/awareness`: Übertragen Blockfokus und Cursor ohne WebSocket.
-     - `POST /api/v1/events/rooms`: Erlaubt SSE-Clients dynamisches Room-Joining.
-  4. **Frontend Realtime Transport Manager (`frontend/src/lib/api.ts`):**
-     - Automatischer 3,5s-Watchdog: Schlägt das WebSocket-Upgrade fehl oder wird Code 1006/1002 gemeldet, wechselt MindSift nahtlos auf `EventSource('/api/v1/events')`.
-     - Grüner/türkiser Statusindikator im Header zeigt `Live (WebSocket)` bzw. `Live (Server-Sent Events / Proxy-Stream)`.
-  5. **Reverse-Proxy-Handbuch:**
-     - Vollständige Produktions-Konfigurationen für Nginx, Traefik, Caddy, Cloudflare und Apache unter [`reverse-proxy.md`](./reverse-proxy.md).
-
----
-
-### FLAW-04: Volltextsuche via `LIKE '%query%'`
-- **Betroffene Komponenten:** [`database.md`](./database.md), `internal/api/search.go`, `internal/api/thoughts.go`
-- **Ursache:** Suchabfragen über Gedanken, Notizblöcke und Aufgaben nutzen aktuell einfaches SQL:
-  ```sql
-  WHERE content LIKE '%' || ? || '%'
-  ```
-- **Folgen:** `LIKE '%...'` kann B-Tree-Indizes prinzipbedingt nicht nutzen und erzwingt einen sequentiellen Full Table Scan. Bei Datenbanken mit Zehntausenden Blöcken führt dies zu CPU-Spitzen und trägen Suchreaktionen.
-- **Empfohlene Lösung:**
-  1. Einrichten einer virtuellen SQLite FTS5-Tabelle (`document_blocks_fts`) mit Tokenizer (`unicode61` oder `trigram`).
-  2. Automatische Synchronisierung über SQLite Trigger (`AFTER INSERT`, `AFTER UPDATE`, `AFTER DELETE`).
-
----
-
-### FLAW-05: Fehlende Virtualisierung im Outliner-Baum
-- **Betroffene Komponenten:** [`modules/workspace.md`](./modules/workspace.md), `frontend/src/features/workspace/WorkspaceView.tsx`
-- **Ursache:** Jeder Block im Notizbaum wird als eigenes DOM-Element gerendert. Enthält ein Dokument 500 bis 2000 Blöcke (z. B. lange Projektjournale oder Besprechungsprotokolle), befinden sich tausende verschachtelte `div`- und `contenteditable`-Elemente gleichzeitig im DOM.
-- **Folgen:** Auf älteren Smartphones oder bei schnellem Tippen kommt es zu spürbaren Input-Latenzen und Ruckeln beim Scrollen.
-- **Empfohlene Lösung:**
-  1. Implementierung einer virtuellen Fensterung (Virtual Windowing) für Blöcke außerhalb des Sichtbereichs.
-  2. Automatisches Einklappen (*Collapsing*) tiefer Hierarchieebenen beim initialen Laden langer Dokumente.
-
----
-
-### FLAW-06: SQLite Concurrency & Single-Writer-Bottleneck
-- **Betroffene Komponenten:** [`architecture.md`](./architecture.md), [`database.md`](./database.md), `internal/storage/sqlite.go`
-- **Ursache:** Obwohl SQLite mit `PRAGMA journal_mode = WAL;` parallele Leser erlaubt, kann zu jedem Zeitpunkt immer nur **ein einziger Thread** schreiben. Bei intensiver gleichzeitiger Nutzung (z. B. 20 Teammitglieder tippen gleichzeitig in Listen und Notizen, während im Hintergrund Webhook-Events einlaufen) können Schreib-Transaktionen aufeinander warten.
-- **Folgen:** Risiko von `database is locked (SQLITE_BUSY)`-Fehlern, wenn der Busy-Timeout überschritten wird.
-- **Empfohlene Lösung:**
-  1. Setzen von `PRAGMA busy_timeout = 5000;` (5 Sekunden Wartezeit vor Fehlerwurf).
-  2. Kapselung aller Schreibzugriffe über einen dedizierten Go-Channel / Single-Worker-Pool oder Migration auf PostgreSQL bei größeren Installationen.
-
----
-
-### FLAW-07: Fehlende Dead-Letter-Queue für Benachrichtigungen
-- **Betroffene Komponenten:** [`modules/tasks.md`](./modules/tasks.md), `internal/scheduler/alarm_ticker.go`
-- **Ursache:** Der Alarm-Ticker überprüft minütlich fällige Aufgaben und sendet Webhooks bzw. E-Mails. Schlägt der HTTP-Post an den externen Webhook fehl (z. B. Zielserver vorübergehend offline), wird der Fehler lediglich ins Log geschrieben.
-- **Folgen:** Der Alarm wird nicht erneut versucht und die Benachrichtigung geht dauerhaft verloren.
-- **Empfohlene Lösung:**
-  1. Einführung einer Tabelle `notification_outbox` mit Spalten `retry_count`, `next_retry_at`, `status`.
-  2. Exponentieller Backoff (1m, 5m, 15m, 1h) und Status-Markierung (*failed*, *delivered*).
-
----
-
-### FLAW-08: Statische JWT-Tokens ohne Blacklisting
-- **Betroffene Komponenten:** [`architecture.md`](./architecture.md), `internal/api/auth.go`
-- **Ursache:** Nach dem Login wird ein JWT ausgestellt, das clientseitig im `localStorage` gespeichert wird. Der Server prüft lediglich die kryptografische Signatur des Tokens, führt aber keine serverseitige Sitzungsliste.
-- **Folgen:** Wird einem Benutzer die Berechtigung entzogen oder ändert er sein Passwort, bleibt ein bereits ausgestellter Token bis zu seinem Ablaufdatum (z. B. 7 Tage) gültig.
-- **Empfohlene Lösung:**
-  1. Einführung einer `revoked_tokens`-Tabelle oder einer `token_version`-Spalte in der `users`-Tabelle.
-  2. Implementierung von kurzlebigen Access-Tokens (15 Min.) in Verbindung mit rotierenden Refresh-Tokens in `httpOnly`-Cookies.
-
----
-
-## 🧭 Verwandte Dokumente
-- 🏗️ [Gesamtarchitektur](architecture.md)
-- 💾 [Datenbank-Design & Tabellenschemata](database.md)
-- 🔌 [WebSocket & Live-Protokoll](api/websocket.md)
-- 🧠 [Workspace-Modul (Outliner)](modules/workspace.md)
-- 🛡️ [Rechte & Freigabesystem](sharing-and-permissions.md)
+Die frühere `flaws.md` führte als „gelöst“, was im Code nicht existiert: In-Memory-DocRooms, `clientId`-Echo-Schutz, Cursor-Presence, 1,5-s-Debounce-Flush, `internal/ws/docroom.go`, `frontend/src/lib/useDocumentSync.ts` und Yjs/CRDT. Der Code enthält nur noch `internal/ws/hub.go` (Räume, Benutzer-Kanäle, SSE-Fallback). Die CRDT-Tabellen werden beim Start gelöscht (`DROP TABLE document_crdt_*`). Dokumente werden per REST gespeichert (`PATCH /documents/{id}/blocks`) und als `DOC_BLOCKS_PATCHED` verteilt. Die frühere Aussage zur Token-Versionierung (`token_version`, `revoked_tokens`) trifft dagegen zu und ist in [sharing-and-permissions.md](sharing-and-permissions.md) und [architecture.md](architecture.md) beschrieben.

Doku/modules/lists.md

@@ -1,62 +1,19 @@
-# 🛒 Kernmodul 4: Geteilte Listen & Kollaboration
+# Modul: Geteilte Listen
 
-Das Modul für geteilte Listen ([`SharedListsView.tsx`](../../frontend/src/features/lists/SharedListsView.tsx)) ist auf **Echtzeit-Kollaboration im Alltag** ausgelegt (z.B. gemeinsamer Wocheneinkauf im Supermarkt, Packlisten für Reisen, Inventarlisten oder schnelle Checklisten).
+Einkaufs-, Pack- und Checklisten für gemeinsames Arbeiten. Code: [SharedListsView.tsx](../../frontend/src/features/lists/SharedListsView.tsx); Backend: `*List*`-Handler in [server.go](../../internal/api/server.go), `Store.CreateList` und Verwandte.
 
----
+## Datenmodell
 
-## 🛍️ 1. Listen-Typen & Kategorien
+- `lists`: Eigentümer, `title`, `icon`, `list_type` (`shopping`, `checklist`, `vacation`).
+- `list_items`: `content`, `category`, `quantity`, `is_completed`, `completed_by(_name)`, `sort_order`.
+- `list_shares`: Ziel (Benutzer oder Gruppe) und Rolle `editor` oder `viewer`.
 
-Jede Liste besitzt einen Typ, ein Icon und eine Farb-Codierung:
+## Funktionen
 
-| Listen-Typ | Icon | Einsatzzweck | Typische Kategorien |
-| :--- | :--- | :--- | :--- |
-| `shopping` | 🛒 | Supermarkt- & Lebensmitteleinkauf | Obst & Gemüse, Kühlregal, Vorrat, Drogerie |
-| `packing` | 🎒 | Urlaubs- & Reise-Packlisten | Kleidung, Elektronik, Dokumente, Kosmetik |
-| `inventory` | 📦 | Vorratskammer, Keller, Homelab-Hardware | Regal 1, Gefrierschrank, Server-Rack |
-| `todo` | 📝 | Einfache Gruppen-Checklisten | Heute, Später, Ideen |
-
-### Automatische Kategorisierung & Mengenangaben
-- Einträge können mit einer Mengenangabe (z.B. `3x`, `500g`, `1 Kasten`) versehen werden.
-- Die intelligente Eingabe erkennt Einheiten automatisch oder trennt Mengen über Eingabefelder.
-- Einträge werden übersichtlich nach Kategorien gruppiert. Jede Kategorie kann zur besseren Übersicht eingeklappt werden.
-
----
-
-## ⚡ 2. Echtzeit-Abhaken (Multi-User Live Sync)
-
-Wenn mehrere Familienmitglieder oder Teammitglieder gleichzeitig im Supermarkt unterwegs sind, synchronisiert MindSift jeden Schritt in Echtzeit über WebSockets:
-
-```mermaid
-sequenceDiagram
-    autonumber
-    actor Alice as Alice (im Markt)
-    participant WS as WebSocket Hub
-    actor Bob as Bob (zu Hause)
-
-    Alice->>WS: PATCH /items/123 (isCompleted: true)
-    WS->>Bob: Event: ITEM_TOGGLED (itemId: "123", completedBy: "Alice")
-    Note over Bob: Eintrag wird sofort durchgestrichen<br/>Grünes Badge "von Alice" erscheint
-```
-
-- **Transparenz:** Beim Abhaken speichert MindSift `completed_by_name`. Ein dezentes grünes Pillen-Badge zeigt an, wer den Artikel eingepackt hat.
-- **Erledigte Einträge:** Abgehakte Artikel wandern nach unten in einen einklappbaren Bereich „Erledigt".
-- **Liste leeren:** Ein Klick auf „Erledigte entfernen" löscht alle abgehakten Einträge (`LIST_CLEARED`) für alle Teilnehmer.
-
----
-
-## 🖐️ 3. Drag & Drop Umsortierung
-
-Innerhalb einer Liste können Einträge frei per Drag & Drop sortiert werden:
-1. **Innerhalb einer Kategorie:** Ändert die Reihenfolge (`sort_order`).
-2. **Kategorie-Übergreifend:** Zieht der Benutzer einen Eintrag in eine andere Kategorie (z.B. von „Kühlregal" nach „Obst & Gemüse"), aktualisiert das Frontend optimistisch die Kategorie und sendet das Update ans Backend.
-
----
-
-## 👥 4. Freigaben & Berechtigungen
-
-Listen können über den einheitlichen Freigabe-Dialog ([`UnifiedShareModal.tsx`](../../frontend/src/components/UnifiedShareModal.tsx)) geteilt werden:
-- **Freigabe für Teams:** Alle aktuellen und zukünftigen Mitglieder der gewählten Gruppe erhalten automatisch Zugriff.
-- **Freigabe für Einzelbenutzer:** Gezielter Zugriff für einzelne Personen.
-- **Rollen:**
-  - `editor`: Darf Einträge hinzufügen, bearbeiten, abhaken und löschen.
-  - `viewer`: Nur Lesezugriff (Einträge ansehen, aber nicht verändern).
+- **Kategorien per Hashtag:** `Hafermilch #Kühlregal` landet in der Kategorie „Kühlregal“. Kategorien werden alphabetisch als Abschnitte angezeigt; die Eingabe schlägt vorhandene Hashtags vor.
+- **Menge:** Feld `quantity` (z. B. `2x`, `500g`).
+- **Drag & Drop** ordnet Einträge um; in eine andere Kategorie gezogen, wird der Hashtag im Text angepasst (`items/reorder` mit `category` und `content`).
+- **Abhaken** speichert, wer und wann; Erledigte stehen in einem eigenen Bereich und lassen sich per „Erledigte entfernen“ löschen (`clear-completed`).
+- **Freigabe** über den Dialog `UnifiedShareModal` (Bearbeiten oder Nur Lesen). Ein Leser sieht Änderungen live, ändert aber nichts.
+- **Live-Sync:** Ereignisse `ITEM_*` und `LIST_*` im Raum der Liste ([websocket.md](../api/websocket.md)). Abhaken erscheint bei allen Beteiligten sofort.
+- Aus der Triage lassen sich Gedanken direkt als Eintrag in eine Liste übernehmen.

Doku/modules/tasks.md

@@ -1,86 +1,38 @@
-# 📋 Kernmodul 2: Aufgaben & Kanban-System
+# Modul: Aufgaben, Kanban & Alarme
 
-Das Aufgaben-Modul ([`TasksView.tsx`](../../frontend/src/features/triage/TasksView.tsx)) bietet eine flexible Aufgabenverwaltung mit frei konfigurierbaren Listen, Kanban-Boards, Subtask-Checklisten und einem automatisierten Multi-Channel Alarm-System.
+Code: [TasksView.tsx](../../frontend/src/features/triage/TasksView.tsx), [TaskDetailModal.tsx](../../frontend/src/features/triage/TaskDetailModal.tsx), [ManageColumnsModal.tsx](../../frontend/src/features/triage/ManageColumnsModal.tsx); Backend: `handleUpdateThought`, `handleReorderTasks`, `*TaskList*`-Handler, `startAlarmTicker`.
 
----
+## Datenmodell
 
-## 🗂️ 1. Datenmodell & Listen-Hierarchie
+Eine Aufgabe ist ein `thought` ([database.md](../database.md)) mit `kanbanStatus`, `priority` (`low`/`normal`/`high`/`urgent`), `dueDate` (nur Datum), `notes` (Markdown), `subtasks` (`[{id, title, isCompleted}]`), `tags`, `taskListId` und `sortOrder`. Aufgaben ohne Liste sind persönlich.
 
-Aufgaben basieren technisch auf der Tabelle **`thoughts`** in SQLite. Ein Eintrag gilt als Aufgabe, wenn `status = 'kept'` oder `(status = 'converted' AND converted_type = 'task')` zutrifft.
+## Ansichten
 
-```
-Benutzer (users)
-  └── Aufgabenlisten (task_lists)
-        ├── Eigene Listen (z.B. "Privat", "Homelab")
-        └── Mit Teams geteilte Listen (task_list_shares)
-              └── Aufgaben (thoughts)
-                    ├── Kanban-Status (todo, in_progress, done)
-                    ├── Priorität (low, normal, high, urgent)
-                    ├── Fälligkeitsdatum (dueDate)
-                    ├── Notizen (notes)
-                    └── Subtasks (JSON Array von Teilaufgaben)
-```
+- **Liste** mit Filtern (offen, erledigt, Papierkorb), Gruppierung (z. B. nach Status oder Fälligkeit), Sortierung und Hashtag-Filter.
+- **Kanban:** Spalten pro Liste frei konfigurierbar (Name, Farbe, „Erledigt“-Spalte). Standard: *Zu erledigen*, *In Bearbeitung*, *Wartet auf andere*, *Erledigt*. Eine Karte in eine „Erledigt“-Spalte zu ziehen setzt `isCompleted`.
+- Drag & Drop sortiert in der Liste und zwischen Spalten; ein Klick öffnet das Detail-Fenster (Titel, Status, Priorität, Fälligkeit mit Schnellwahl, Liste, Hashtags, Unteraufgaben mit Fortschrittsbalken, Notizen).
+- Aufgaben lassen sich in eine Notiz umwandeln („Als Notiz vertiefen“). Aufgaben aus Notiz-Checkboxen (`enhanced-task`) bleiben verknüpft: Abhaken wirkt in beide Richtungen (`SyncDocBlockAndTask`), „In Notiz öffnen“ springt zum Block.
 
-### Listen-Sharing & Avatar-Stack
-Aufgabenlisten können für Gruppen/Teams freigegeben werden. Ein Avatar-Stack im Listen-Header und in der Tab-Leiste visualisiert alle Mitglieder, die Zugriff auf die jeweilige Liste haben.
+## Aufgabenlisten und Freigabe
 
----
+- Jede Liste hat Eigentümer, Titel, Symbol, Farbe und eigene Kanban-Spalten.
+- Freigabe an Gruppen oder Benutzer über den Dialog `UnifiedShareModal` (Stufe pro Freigabe):
+  - **Bearbeiter:** darf Aufgaben anlegen, ändern, abhaken, verschieben, löschen sowie Liste umbenennen und Spalten ändern.
+  - **Leser:** sieht alles, kann nichts ändern. Der Server antwortet mit `403`; die Oberfläche blendet Eingaben aus und zeigt „Nur Lesen“.
+  - Gruppenmitglieder mit mehreren Wegen erhalten die höchste Stufe. Nur der Eigentümer legt Freigaben an oder entfernt sie und kann die Liste löschen.
+- Umsetzung: `Store.GetTaskListPermission` liefert `owner`/`editor`/`viewer`/`""`; `ensureTaskListWritable` schützt Schreibpfade.
+- Bekannte Lücken: [FLAW-03](../flaws.md) (Umsortieren per ID), [FLAW-06](../flaws.md) (Editor kann weiterteilen).
 
-## 🖥️ 2. Ansichten: Liste vs. Kanban-Board
+## Alarme
 
-Der Benutzer kann jederzeit nahtlos zwischen zwei Ansichten umschalten:
+Der Ticker läuft jede Minute ([architecture.md](../architecture.md)). Für offene Aufgaben mit `due_date <= heute` und `alarm_sent = 0` sendet er an die Kanäle des Aufgaben-**Eigentümers**:
 
-### 1. Kompakte Listenansicht
-- Optimiert für schnelles Abarbeiten und Tastatursteuerung.
-- Zeigt Checkbox, Titel, Prioritäts-Badge, Herkunfts-Pille (`Webhook`, `Diktat`), Fälligkeitsdatum und Subtask-Zähler (`2/5`).
-- 1-Klick-Prioritäts-Wechsel: Klick auf ein Badge rotiert durch die Prioritäten.
+| Kanal | Ziel | Konfiguration |
+|---|---|---|
+| E-Mail | `alarmEmail` (sonst Konto-Adresse) | SMTP aus Admin-Einstellungen oder Umgebung (Port 465 mit TLS wird direkt unterstützt, sonst STARTTLS über `smtp.SendMail`) |
+| Discord | Webhook-URL | Benutzereinstellungen |
+| Webhook | beliebige URL (JSON: `event`, `title`, `notes`, `dueDate`, `priority`, `timestamp`) | Benutzereinstellungen |
 
-### 2. Kanban-Board (Drag & Drop)
-- Standardmäßig 3 Spalten: **Zu erledigen** (`todo`), **In Arbeit** (`in_progress`) und **Erledigt** (`done`).
-- **Freie Spalten-Konfiguration:** Über das Spalten-Menü können Spalten umbenannt, farblich markiert oder neue Spalten hinzugefügt werden.
-- **Drag & Drop:** Aufgaben können per HTML5 Drag & Drop zwischen Spalten verschoben werden. Das Backend speichert die relative Position (`sort_order`) und den neuen `kanban_status` automatisch.
+Danach wird `alarm_sent = 1` gesetzt, sobald mindestens ein Kanal erfolgreich war.
 
----
-
-## 🎯 3. Prioritäten & Subtasks
-
-### 4-Stufen-Prioritätensystem
-Aufgaben unterstützen vier einheitliche Prioritätsstufen:
-- **Niedrig (`low`):** Dezent grau hinterlegt.
-- **Normal (`normal`):** Akzentfarbe.
-- **Wichtig (`high`):** Gelb hervorgehoben mit Warndreieck (`⚠️ Wichtig`).
-- **Dringend (`urgent`):** Rot pulsierend mit Flammen-Icon (`🔥 Dringend`).
-
-### Subtasks (Teilaufgaben)
-Jede Aufgabe kann eine hierarchische Checkliste von Subtasks enthalten:
-- Gespeichert als JSON in der Spalte `subtasks`.
-- Fortschrittsanzeige im Kartenkopf (z.B. `3/5 erledigt`).
-- Einzelnes Abhaken synchronisiert direkt in die Datenbank.
-
----
-
-## ⏰ 4. Multi-Channel Alarm-Scheduler
-
-MindSift enthält einen serverseitigen Hintergrund-Ticker in Go ([`internal/api/server.go`](../../internal/api/server.go)), der fällige Aufgaben proaktiv an externe Kanäle meldet.
-
-```mermaid
-flowchart TD
-    Ticker["Go Background Ticker (alle 30s)"] --> Query["SELECT thoughts WHERE due_date <= now + Vorwarnzeit AND alarm_sent = 0"]
-    Query --> CheckChannels{"Welche Kanäle sind beim User aktiv?"}
-    
-    CheckChannels -->|email| SendSMTP["E-Mail via SMTP versenden"]
-    CheckChannels -->|discord| SendDiscord["Discord Webhook POST"]
-    CheckChannels -->|webhook| SendCustom["Custom HTTP POST Webhook"]
-    
-    SendSMTP --> MarkSent["UPDATE thoughts SET alarm_sent = 1"]
-    SendDiscord --> MarkSent
-    SendCustom --> MarkSent
-```
-
-### Alarm-Konfiguration
-1. **Vorwarnzeit:** Einstellbar in Minuten (z.B. 15, 30, 60 Minuten vor Fälligkeit).
-2. **Kanal-Multi-Select:** Benutzer können beliebig viele Kanäle parallel aktivieren:
-   - **E-Mail:** Versand über den in den Admin-Einstellungen hinterlegten SMTP-Server.
-   - **Discord:** Benachrichtigung mit formatierter Embed-Karte in einen Discord-Kanal.
-   - **Eigener Webhook:** Beliebige HTTP POST JSON Endpunkte (z.B. Gotify, Ntfy, Home Assistant).
-3. **Schutz vor Doppel-Alarmen:** Sobald ein Alarm abgesetzt wurde, wird `alarm_sent = 1` gesetzt. Wird das Datum der Aufgabe später geändert, setzt der Server `alarm_sent = 0` automatisch zurück.
+Einschränkungen ([FLAW-12](../flaws.md)): Fälligkeiten haben keine Uhrzeit, `notifyBeforeMinutes` wird ignoriert, die Serverzeit gilt, und ein verschobener Termin löst nicht erneut aus. URLs werden nicht geprüft ([FLAW-05](../flaws.md)).

Doku/modules/triage.md

@@ -1,88 +1,36 @@
-# 📥 Kernmodul 1: Triage & Quick-Dump Engine
+# Modul: Schnellerfassung & Triage
 
-Das Triage-Modul von MindSift basiert auf dem *Getting Things Done (GTD)*-Prinzip. Es trennt die **Erfassung von Gedanken** strikt von der **Entscheidung, was damit geschehen soll**.
+Ziel: Gedanken in Sekunden festhalten und später in Ruhe sortieren. Code: [InstantCaptureBar.tsx](../../frontend/src/features/capture/InstantCaptureBar.tsx), [TriageDeck.tsx](../../frontend/src/features/triage/TriageDeck.tsx), Backend `handleCaptureInbox`, `handleTriageAction` und `Store.UpdateThoughtTriage`.
 
----
+## Erfassung
 
-## 💡 1. Das 2-Phasen-Konzept
+- Die Eingabeleiste sitzt im Header; `C` oder `/` fokussiert sie (außer beim Tippen in einem Feld).
+- Ziel (`target`): **Posteingang** (`inbox`, Standard), **Direkt-Aufgabe** (`task`), **Listeneintrag** (`list_item`, mit Zielliste) oder **Direkt-Notiz** (`document`).
+- Mehrzeilige Eingabe wird unterstützt. Spracheingabe nutzt die Web Speech API des Browsers; Quelle `voice` fügt den Tag `#diktat` an.
+- Quelle `webhook` (per API-Key/Webhook) fügt den Tag `#webhook` an. Hashtags im Text werden als Tags extrahiert (`domain.ExtractTags`).
+- Per API: `POST /inbox` und `POST /webhooks/ingest` (siehe [rest.md](../api/rest.md)).
 
-1. **Phase 1: Schnelles Erfassen (Instant Dump)**  
-   Ein Gedanke, ein Anruf, eine Idee oder ein Server-Alarm wird ohne Reibung erfasst. Der Benutzer muss in diesem Moment weder ein Projekt auswählen, noch Fälligkeitsdaten eingeben oder Ordner durchsuchen.
-2. **Phase 2: Fokussierte Triage (Inbox Zero)**  
-   Zu einem späteren Zeitpunkt (z.B. morgens oder beim Feierabend) sichtet der Benutzer den Stapel im Triage-Deck Karte für Karte und trifft für jeden Eintrag eine eindeutige Entscheidung.
+## Triage-Deck
 
----
+Der Posteingang (`status = inbox`) wird Karte für Karte abgearbeitet.
 
-## 🔄 2. Triage State Machine
+| Aktion | Desktop | Mobil | Ergebnis |
+|---|---|---|---|
+| Verwerfen | `H` oder `←` | Wischen links | `status = discarded` (Papierkorb) |
+| Zur Aufgabe | `L` oder `→` | Wischen rechts | `kept`/`converted` als Aufgabe |
+| Aufgabe mit Termin | `T` | Aktionsmenü | wie oben, mit Fälligkeit |
+| In Notiz wandeln | `D` | Aktionsmenü | neues Dokument, Gedanke wird `converted` (`document`) |
+| Später | Leertaste | Aktionsmenü | Karte ans Stapelende |
+| Menü schließen | `Esc` | – | – |
 
-```mermaid
-stateDiagram-v2
-    [*] --> Capture: Gedanke erfasst (Desktop / Mobile / Webhook)
-    
-    Capture --> Inbox: Standard (status: 'inbox')
-    Capture --> Task: Direkt als Aufgabe (target: 'task')
-    Capture --> Document: Direkt als Notiz (target: 'document')
-    Capture --> ListItem: Direkt auf Liste (target: 'list_item')
+Die Umwandlung in eine Notiz übernimmt Titel, Erledigt-Status, Notizen, Unteraufgaben sowie Fälligkeit und Priorität als eingerückte Blöcke. Eine Umwandlung in einen Listeneintrag legt einen Eintrag in der gewählten Liste an und benachrichtigt deren Teilnehmer.
 
-    state Inbox {
-        [*] --> ActiveCard: Oben auf Stapel
-        ActiveCard --> Skipped: Leertaste / Später (Ans Ende)
-        Skipped --> ActiveCard
-    }
+## Zustände eines Gedankens
 
-    ActiveCard --> Discarded: Swipe links / H (Wegwerfen)
-    ActiveCard --> Task: Swipe rechts / L (Als Aufgabe)
-    ActiveCard --> TaskDated: T (Mit Fälligkeitsdatum)
-    ActiveCard --> Document: D (In Notiz umwandeln)
-    ActiveCard --> ListItem: Auf Liste schieben
-
-    Discarded --> Trash: status: 'discarded'
-    Task --> TasksModule: status: 'kept', converted: 'task'
-    TaskDated --> TasksModule: status: 'kept', converted: 'task', dueDate
-    Document --> WorkspaceModule: status: 'converted', converted: 'document'
-    ListItem --> ListsModule: status: 'converted', converted: 'list_item'
+```
+inbox ──keep──▶ kept ──convert──▶ converted (task | document | list_item)
+  │                │
+  └─discard─▶ discarded ──restore──▶ inbox        (Papierkorb leeren: DELETE /thoughts/discarded/purge)
 ```
 
----
-
-## 🖐️ 3. Steuerung & Gesten (Mobile vs. Desktop)
-
-### Desktop-Bedienung (Tastatur-First)
-- `C` oder `/`: Fokussiert sofort die Eingabeleiste oben im Header.
-- `Enter`: Speichert den Gedanken sofort im Deck.
-- `←` oder `H`: Aktive Karte wegwerfen (`discard`).
-- `→` oder `L`: Aktive Karte sofort zur Aufgabe machen (`task`).
-- `T`: Datumsauswahl für Termin-Aufgabe öffnen.
-- `D`: Aktive Karte in eine vollwertige Workspace-Notiz umwandeln.
-- `Leertaste`: Karte überspringen und ans Ende des Stapels schieben („Später").
-
-### Mobile Bedienung (Touch & Swipe)
-- **Mittlerer Plus-Button (`+`):** Öffnet das design-angeglichene Bottom-Sheet mit Spracheingabe, 4 Prioritäts-Buttons (`Niedrig`, `Normal`, `Wichtig`, `Dringend`) und Fälligkeitsdatum.
-- **Wischgeste nach links (Swipe Left):** Roter Indikator erscheint, Karte wird verworfen.
-- **Wischgeste nach rechts (Swipe Right):** Grüner Indikator erscheint, Karte wird sofort zur Aufgabe.
-- **Long-Press (Langes Drücken auf Karte):** Öffnet das Schnell-Aktions-Menü (Auf Liste, Mit Termin, Als Notiz, Später).
-
----
-
-## 🎙️ 4. Spracheingabe (Speech-to-Text)
-
-In der Desktop-Schnelleingabeleiste ([`InstantCaptureBar.tsx`](../../frontend/src/features/capture/InstantCaptureBar.tsx)) sowie im mobilen Triage-Modal ([`App.tsx`](../../frontend/src/App.tsx)) ist ein nativer Browser-Sprachassistent integriert:
-- Verwendet die standardisierte `SpeechRecognition` bzw. `webkitSpeechRecognition` API.
-- Erkennt Sprache auf Deutsch (`lang: 'de-DE'`).
-- Live-Transkription: Gesprochener Text wird in Echtzeit in das Textfeld eingefügt.
-- Haptisches Feedback: Vibrieren beim Starten und Stoppen der Aufnahme.
-- Markiert erfasste Gedanken automatisch mit dem Herkunfts-Attribut `source: 'voice'` (Diktat-Badge).
-
----
-
-## ⚡ 5. Webhook-Ingestion & Smarthome-Pille
-
-MindSift kann externe Alarme (Home Assistant, Zigbee2MQTT, n8n, Proxmox, Monitoring) automatisch ins Triage-Deck einspeisen:
-
-### Herkunftserkennung
-1. Wird ein Gedanke über `/api/v1/inbox` mit `X-API-Key` oder über `/api/v1/webhooks/ingest` eingeliefert, setzt das Backend automatisch `source = "webhook"`.
-2. Im Frontend visualisiert die Triage-Karte eine dezente Webhook-Pille (`<Webhook className="w-3 h-3 text-accent" /> Webhook`).
-3. Diese Kennzeichnung bleibt auch erhalten, wenn die Karte später zu einer Aufgabe umgewandelt wird.
-
-### Live-WebSocket Update
-Nach erfolgreichem Ingest sendet der Server sofort ein `TASK_CREATED` Event über den WebSocket-Hub. Das geöffnete Triage-Deck fügt die neue Alarm-Karte sofort oben in den Stapel ein – ohne dass der Benutzer die Seite neu laden muss.
+Ein Gedanke mit `status = kept` zählt bereits als Aufgabe und erscheint in der Aufgabenansicht.

Doku/modules/workspace.md

@@ -1,104 +1,39 @@
-# 📝 Kernmodul 3: Workspace Outliner-Engine, Wiki-Links & Pure-DB Storage
+# Modul: Workspace (Outliner-Notizen)
 
-Der MindSift Workspace ([`WorkspaceView.tsx`](../../frontend/src/features/workspace/WorkspaceView.tsx)) kombiniert ein **hierarchisches Bullet-Point Notizsystem (inspiriert von Logseq)** mit einem **persönlichen Wiki**, **Live-Kollaboration** und einem **globalen To-Do Rollup Dashboard**.
+Code: [WorkspaceView.tsx](../../frontend/src/features/workspace/WorkspaceView.tsx) (Explorer, Tags, To-Do-Rollup), [DocumentEditor.tsx](../../frontend/src/features/workspace/DocumentEditor.tsx), [OutlinerTree.tsx](../../frontend/src/features/workspace/OutlinerTree.tsx), [OutlinerBlock.tsx](../../frontend/src/features/workspace/OutlinerBlock.tsx), [CodeBlockItem.tsx](../../frontend/src/features/workspace/CodeBlockItem.tsx), [LinkModal.tsx](../../frontend/src/features/workspace/LinkModal.tsx); Backend: Dokument-, Ordner- und Tag-Handler, `Store.PatchDocumentBlocks`.
 
----
+## Datenhaltung
 
-## 🌳 1. Die Logseq-Outliner-Engine
+- Eine Notiz ist ein Datensatz in `documents` plus geordnete Zeilen in `blocks` (`position` als Kommazahl, `level` für die Einrückung). Alles liegt in SQLite; es gibt keine Dateien auf der Platte.
+- Bei jeder Änderung wird `documents.markdown_cache` neu erzeugt; `block_tags` wird aus `#Hashtags` der Blöcke neu aufgebaut.
+- Der Export als `.md` erfolgt im Browser (Button im Editor, Blob-Download).
+- Blocktypen: Überschriften `h1`–`h3`, `paragraph`/`text`, `bullet`, `todo`, `code`, `callout`, `divider`, `table`, `progress`.
 
-Im Gegensatz zu klassischen Fließtext-Editoren basiert der MindSift Workspace auf einer **flachen, relationalen Liste von Blöcken** (`blocks`-Tabelle in SQLite). Jeder Block ist ein gedanklicher Knotenpunkt mit einer flexiblen Einrückungsebene (`level: 0, 1, 2, ...`) und einer fortlaufenden Fließkommaposition (`position`):
+## Editor
 
-```
-• Projekt MindSift v2.0 (level 0)
-  • Architektur-Entscheidung (level 1)
-    - [x] Database-First Blocks implementieren (level 2)
-    - [ ] Performance Benchmark mit 10.000 Blöcken (level 2)
-  • Notizen aus dem Dev-Meeting (level 1)
-    > Wichtig: Keine verschachtelten SQLite Queries ausführen! (level 2)
-```
+- **Outliner:** `Enter` neuer Block, `Tab`/`Shift+Tab` ein-/ausrücken, `Shift+Enter` weicher Umbruch, Blöcke ein-/ausklappen.
+- **Zoom (Hoisting):** Klick auf den Bullet fokussiert den Ast; die Breadcrumb-Leiste führt zurück.
+- **Drag & Drop** verschiebt Blöcke samt Unterästen; auf einen anderen Block gezogen, wird der Block zum Unterpunkt.
+- **Slash-Befehle:** `/todo`, `/link`, `/h1`, `/h2`, `/h3`, `/code`, `/callout`, `/divider` (Liste in `OutlinerBlock.tsx`).
+- **Links:** `[[Notiztitel]]`, Markdown-Links `[Titel](url)` und reine URLs werden als Token dargestellt; `LinkModal` hilft beim Verknüpfen von Notizen.
+- **Einfügen:** Mehrzeiliger Text wird anhand von Markdown-Präfixen und Einrückung in Blöcke zerlegt; Überschriften gruppieren darunterliegenden Text und Code.
+- **Speichern:** Der Editor speichert 800 ms nach der letzten Eingabe das gesamte Dokument (`PUT /documents/{id}`). Der schlanke Block-Endpunkt `PATCH /documents/{id}/blocks` wird derzeit vom To-Do-Rollup beim Abhaken genutzt.
 
-### Tastatur-Navigation & Shortcuts
-- `Enter`: Erstellt einen neuen Block auf derselben Hierarchieebene.
-- `Tab`: Rückt den aktuellen Block ein (wird Kindknoten des vorherigen Blocks).
-- `Shift + Tab`: Rückt den Block um eine Ebene aus (verringert die Tiefe).
-- `Shift + Enter`: Weicher Zeilenumbruch innerhalb desselben Blocks (z.B. für mehrzeilige Notizen oder Code).
-- `Backspace` (auf leerem Block): Löscht den Block sofort. Das Ausrücken erfolgt strikt und kontrolliert über `Shift + Tab`.
-- `/` (Slash-Commands): Öffnet das Umwandlungsmenü (`/todo`, `/link`, `/h1`, `/h2`, `/h3`, `/code`, `/callout`, `/quote`, `/divider`).
-- **Markdown-Tastatur-Kürzel:** Tippen von `[] ` oder `[ ] ` wandelt den Block sofort in ein Todo um; `# `, `## `, `### ` erzeugt Überschriften.
+## Explorer, Tags, To-Dos
 
-### Eingabestabilität & Zombie-Fokus-Schutz (`OutlinerBlock.tsx`)
-1. **Echter Fokus-Check:** Remote-Updates (`block_updated`) werden nur dann abgewehrt, wenn der Block tatsächlich aktiv im Betriebssystem editiert wird:
-   `isFocusedRef.current === true && document.hasFocus()`.
-2. **Sofort-Flush bei Fensterwechsel:** Sobald das Browser-Fenster den Fokus verliert (`window.addEventListener('blur', ...)`), wird ein offener 150ms-Debounce sofort gecancelt und der Text augenblicklich per WebSocket übertragen.
-3. **Stale Closures eliminiert:** Alle Callbacks werden in `useRef` gehalten, sodass asynchrone Debounce-Timer garantiert die aktuellste Komponenten-Referenz verwenden.
+- Ordnerbaum mit Favoriten (`doc_pins`), Verschieben per Drag & Drop (`/documents/{id}/move`, `/folders/move`).
+- **Tags:** Alle `#Hashtags` werden aggregiert (`/workspace/tags`). Eine Tag-Seite zeigt alle Fundstellen gruppiert nach Notiz und kann eine eigene Freitext-Notiz tragen (`tag_pages`).
+- **To-Do-Rollup:** Die Ansicht „To-Dos“ sammelt alle `todo`-Blöcke aller Notizen, filterbar nach Ordner. Abhaken im Rollup ändert den Block in der Notiz.
+- **Enhanced Tasks:** Ein `todo`-Block lässt sich als verknüpfte Aufgabe führen (`/documents/{id}/blocks/{blockId}/enhanced-task`); Erledigt-Status bleibt zwischen Notiz und Aufgabenansicht synchron.
 
-### Zoom-In Hoisting (Fokus-Modus)
-Klickt der Benutzer auf den Bullet-Dot (`•`) eines Blocks, blendet der Editor alle übergeordneten und benachbarten Blöcke aus und zoomt **ausschließlich in diesen Ast** hinein:
-- Der gewählte Punkt wird zur prominenten Überschrift im Fokus-Modus.
-- Eine klickbare Breadcrumb-Leiste oben zeigt den Pfad an (z.B. `Workspace / Projekte / MindSift / Architektur`).
-- Ein Klick auf ein beliebiges Breadcrumb-Element zoomt sofort auf die jeweilige Ebene zurück.
+## Freigabe
 
-### Drag & Drop von Blöcken
-Der Bullet-Dot dient gleichzeitig als Drag-Anfasser. Wird ein Block verschoben, erkennt die Engine automatisch alle untergeordneten Kind-Blöcke (`isDescendantBlock`) und verschiebt den **kompletten Unterbaum** an die neue Zielposition.
+- Einzelne Notizen und ganze **geteilte Ordner** lassen sich an Benutzer oder Gruppen geben. Empfänger haben **nur Leserechte**; nur der Eigentümer schreibt ([sharing-and-permissions.md](../sharing-and-permissions.md), [FLAW-17](../flaws.md)).
+- Empfänger ordnen geteilte Notizen und Ordner in ihrem eigenen Baum ein (`doc_user_folders`, `workspace_folder_mounts`), ohne dass der Eigentümer etwas davon merkt.
+- Änderungen erreichen offene Fenster über `DOC_BLOCKS_PATCHED`/`DOC_UPDATED` ([websocket.md](../api/websocket.md)).
 
----
+## Grenzen
 
-## 🔗 2. Wiki-Links (`[[Link]]`), Web-Links (`/link`) & Hashtags
-
-1. **Interne Wiki-Links:**
-   - Text in doppelten eckigen Klammern (z.B. `[[Reiseplanung 2026]]`) wird automatisch als klickbare Notiz-Pille gerendert.
-   - Klick darauf öffnet die verknüpfte Notiz direkt im Editor.
-2. **Slash-Befehl `/link` & Link-Modal:**
-   - `/link` öffnet ein Modal mit zwei Modi:
-     - **Notiz verknüpfen:** Durchsucht bestehende Notizen und fügt `[[Titel]]` ein.
-     - **Web-Link:** Eingabe von Titel und URL, fügt Standard-Markdown `[Titel](url)` ein.
-3. **Hashtags (`#tag`):**
-   - Hashtags im Fließtext werden automatisch indiziert (`block_tags`-Tabelle).
-   - In der linken Leiste listet der Tag-Explorer alle verwendeten Schlagworte auf. Klick auf ein Tag filtert alle Dokumente und Blöcke, die dieses Tag enthalten.
-
----
-
-## ⚡ 3. Echtzeit-Kollaboration & Automatische Markdown-Kompilierung
-
-MindSift setzt auf eine latenzfreie In-Memory Kollaborations-Architektur ([`internal/ws/docroom.go`](../../internal/ws/docroom.go)):
-
-### Funktionsweise
-1. **In-Memory DocRoom pro geöffnetem Dokument:**
-   - Hält den synchronen Zustand von `title` und `blocks[]` im RAM.
-   - Granulare Mutations-Events (`block_updated`, `block_created`, `block_deleted`, `block_moved`, `title_updated`).
-   - Ephemeres Presence-Tracking (`cursor_moved`, `client_left`) zeigt farbige Benutzer-Avatare im Header und Cursors am aktiven Block an.
-2. **Echo-Schutz:**
-   - Jeder Client identifiziert sich mit einer eindeutigen `clientId`.
-   - Der Server sendet Mutations-Events ausschließlich an andere Clients im selben Raum (`clientId != senderClientId`), um Cursor-Springen und Selbstechos zu verhindern.
-
-### Automatische Markdown-Kompilierung & SQLite Debounce-Flush
-```
-Eingabe im OutlinerBlock
-        │
-        ├──▶ WebSocket (block_updated Event)
-        │         │
-        │         ▼
-        │    Go DocRoom: In-Memory Mutation & Broadcast an Peers
-        │
-        └──▶ 1.5s Inaktivitäts-Debounce (oder Raum-Exit)
-                  │
-                  ▼
-             SQLite Transaktion:
-             1. Persistiert Blöcke in `blocks`
-             2. Regex-Extraktion von #tags in `block_tags`
-             3. Kompiliert Block-Hierarchie zu Standard-Markdown
-                und speichert Cache in `documents.markdown_cache`
-```
-
-1. **Kompiliertes Markdown:** Jeder Block wird gemäß seiner `level`-Tiefe mit 2 Leerzeichen pro Einrückungsebene als sauberes Markdown formatiert (`documents.markdown_cache`).
-2. **Pure Database Architecture:** Alle Daten liegen transaktional und sicher in SQLite. Es werden keine unkontrollierten Dateien auf der Festplatte abgelegt; Notizen können jederzeit per Klick als `.md`-Datei exportiert werden.
-
----
-
-## 📊 4. Globaler To-Do Rollup Dashboard
-
-Über den Tab **„Globale To-Dos"** bietet der Workspace eine aggregierte Übersicht aller im gesamten Wiki verteilten Aufgaben:
-- Scannt in Echtzeit alle unvollendeten `- [ ] ` Checkboxen über alle Ordner und Notizen hinweg.
-- Übersichtliche Gruppierung nach **Ordner ➔ Dokument ➔ Aufgabe**.
-- **Ordner-Filter:** Klick auf einen Ordner isoliert nur dessen Aufgaben für fokussiertes Arbeiten.
-- **2-Wege-Live-Sync:** Wird eine Checkbox im Rollup abgehakt, wird der Block in SQLite sofort auf `checked = 1` aktualisiert und via WebSocket an alle aktiven Clients gebroadcastet.
+- Keine gleichzeitige Mehrbenutzerbearbeitung, keine Cursor-Anzeige, keine Versionshistorie.
+- Keine Virtualisierung langer Dokumente; sehr große Notizen können auf Mobilgeräten träge werden *(nicht gemessen)*.
+- Suche (`/search`) erfasst nur Titel und Inhalt eigener Notizen ([FLAW-18](../flaws.md)).

Doku/reverse-proxy.md

@@ -8,9 +8,9 @@ Dieses Dokument beschreibt die empfohlene Konfiguration von Reverse-Proxies und
 
 | Protokoll | Standard-Port | Benötigte Header & Einstellungen | Zweck |
 | :--- | :--- | :--- | :--- |
-| **WebSockets** | 443 (WSS) / 80 (WS) | `Upgrade $http_upgrade`<br>`Connection "Upgrade"`<br>`proxy_read_timeout 3600s` | Bidirektionale Yjs-CRDT-Synchronisation & Awareness |
+| **WebSockets** | 443 (WSS) / 80 (WS) | `Upgrade $http_upgrade`<br>`Connection "Upgrade"`<br>`proxy_read_timeout 3600s` | Bidirektionale Live-Updates (Aufgaben, Listen, Notizen) |
 | **Server-Sent Events (SSE)** | 443 (HTTPS) / 80 (HTTP) | `X-Accel-Buffering: no`<br>`proxy_buffering off`<br>`proxy_cache off` | Fallback bei blockiertem WebSocket-Upgrade |
-| **REST API & Uploads** | 443 (HTTPS) / 80 (HTTP) | `client_max_body_size 64M` | Notizen, Anhänge & CRDT-Zustandsblöcke |
+| **REST API & Uploads** | 443 (HTTPS) / 80 (HTTP) | `client_max_body_size 64M` | Notizen, Import/Export (JSON) |
 
 ---
 
@@ -38,7 +38,7 @@ server {
     ssl_certificate /etc/letsencrypt/live/mindsift.example.com/fullchain.pem;
     ssl_certificate_key /etc/letsencrypt/live/mindsift.example.com/privkey.pem;
 
-    # Maximale Payload-Größe für Backups und große CRDT-Zustände
+    # Maximale Payload-Größe für große Notizen und Exporte
     client_max_body_size 64M;
 
     # MindSift Frontend & REST API
@@ -132,7 +132,7 @@ Caddy unterstützt WebSockets und HTTP/2 Server-Sent Events von Haus aus vollst
 mindsift.example.com {
     encode gzip zstd
 
-    # Notizen, CRDT & Event-Stream ohne Pufferung weiterleiten
+    # Event-Stream (SSE) ohne Pufferung weiterleiten
     reverse_proxy 127.0.0.1:8080 {
         # Streaming für SSE optimieren
         flush_interval -1
@@ -148,7 +148,7 @@ Wird MindSift hinter dem Cloudflare CDN betrieben:
 1. **WebSockets aktivieren:**
    - Navigiere in das Cloudflare Dashboard: **Network** > **WebSockets** > Schalter auf **ON** stellen.
 2. **Cloudflare Rocket Loader / Auto Minify:**
-   - Deaktiviere "Rocket Loader" für MindSift, da asynchrone Skripteingriffe die Yjs-CRDT-Initialisierung stören können.
+   - Deaktiviere "Rocket Loader" für MindSift, da asynchrone Skripteingriffe den Start der Single-Page-App stören können.
 3. **Cloudflare WAF / Bot Fight Mode:**
    - Stelle sicher, dass `GET /api/v1/events` und `GET /api/v1/ws*` nicht von "Challenge"-Seiten blockiert werden.
 4. **SSE-Unterstützung:**

Doku/sharing-and-permissions.md

@@ -1,93 +1,55 @@
-# 👥 Synchrones Teilen & Berechtigungskonzept
+# Teilen & Berechtigungen
 
-MindSift bietet ein mehrstufiges Kollaborations- und Freigabesystem. Es gewährleistet strikte Datensouveränität und Privatsphäre, ermöglicht aber gleichzeitig reibungslose Zusammenarbeit in Teams, Familien oder Unternehmen.
+## Rollen
 
----
+| Ebene | Werte | Bedeutung |
+|---|---|---|
+| Server | `admin`, `member` | Admins verwalten Benutzer, Einladungen und Einstellungen (`/admin/*`). |
+| Gruppe | `admin`, `member` | Gruppen-Admins ändern/löschen die Gruppe und verwalten Mitglieder. Wer eine Gruppe anlegt, wird Admin. |
+| Ressource | siehe unten | Eigentümer, Bearbeiter, Leser. |
 
-## 🛡️ 1. Globale Rollen & System-Isolation
+## Berechtigungen je Ressource
 
-### Globale Rollen
-- **Server-Admin (`role = 'admin'`):** Vollzugriff auf System-Einstellungen, E-Mail-Konfiguration (SMTP), Benutzerverwaltung, Einladungscodes und System-Statistiken.
-- **Mitglied (`role = 'member'`):** Regulärer Benutzer; arbeitet in seinen eigenen Notizen, Aufgaben und freigegebenen Teams.
+| Ressource | Eigentümer | Bearbeiter | Leser | Freigabe an |
+|---|---|---|---|---|
+| **Aufgabenliste** (`task_list_shares.permission`) | alles, löschen, (un)teilen | Aufgaben anlegen/ändern/abhaken/verschieben/löschen, Liste umbenennen, Spalten ändern | nur ansehen | Benutzer, Gruppen |
+| **Geteilte Liste** (`list_shares.role`) | alles, löschen, (un)teilen | Einträge anlegen/ändern/abhaken/löschen | nur ansehen | Benutzer, Gruppen |
+| **Notiz** (`doc_shares`, `doc_team_shares`) | schreiben | – | nur lesen | Benutzer, Gruppen |
+| **Geteilter Ordner** (`workspace_folder_shares`) | schreiben | – | nur lesen | Benutzer, Gruppen |
 
-### System-Isolations-Modi (`sharing_mode`)
-Der Server-Admin legt global fest, wie Benutzer miteinander interagieren dürfen:
+- **Notizen und Ordner sind absichtlich schreibgeschützt für Empfänger.** Das erzwingt eine Migration beim Start (`permission = 'read'`); Schreibpfade im Code sind tot ([FLAW-17](flaws.md)).
+- Bei Aufgabenlisten und Listen gilt: Hat jemand mehrere Zugriffswege (direkt und über Gruppen), zählt die **höchste** Stufe.
+- Für Gruppen gilt die Freigabe für alle aktuellen und künftigen Mitglieder.
+- Aufgabenlisten besitzen zusätzlich das Altfeld `team_id`: Mitglieder dieser Gruppe haben ohne Freigabezeile Bearbeiterrechte. Eine Gruppenfreigabe über den Dialog setzt `team_id`, falls es noch leer ist.
 
-```
-┌────────────────────────────────────────────────────────────────────────┐
-│                        System-Isolations-Modi                          │
-├──────────────────────┬─────────────────────────┬───────────────────────┤
-│    strict_private    │       teams_only        │         open          │
-│  (Strikt Isoliert)   │  (Teams & Gruppen)      │   (Offene Instanz)    │
-│                      │   [EMPFOHLENER STANDARD]│                       │
-├──────────────────────┼─────────────────────────┼───────────────────────┤
-│ Kein Adressbuch      │ Adressbuch zeigt nur    │ Alle Benutzer sehen   │
-│ Keine Freigaben      │ gemeinsame Teammit-     │ alle anderen Konten   │
-│ Autarke Einzel-Instanz│ glieder                 │ im System             │
-└──────────────────────┴─────────────────────────┴───────────────────────┘
-```
+## Aufgabenlisten teilen (Details)
 
-1. **`strict_private`:** Vollständige Abschottung. Benutzer wissen nicht voneinander. Keine Freigaben möglich.
-2. **`teams_only` (Standard):** Kollaboration ist strikt an Gruppen gebunden. Ein Benutzer kann Objekte nur mit Personen teilen, die mindestens in einer gemeinsamen Gruppe/Team mit ihm sind.
-3. **`open`:** Geeignet für Familien oder kleine Firmen. Jeder Benutzer kann für jeden anderen Benutzer Objekte freigeben.
+1. Eigentümer öffnet „Teilen“ an der Liste, wählt Gruppe oder Benutzer und die Stufe **Bearbeiten** oder **Nur Lesen**.
+2. `POST /task-lists/{id}/shares` speichert `permission`; erneutes Hinzufügen desselben Ziels ändert die Stufe.
+3. `GET /task-lists` liefert je Liste `permission` (`owner`/`editor`/`viewer`). Das Frontend blendet für `viewer` alle Eingabemöglichkeiten aus und zeigt „Nur Lesen“.
+4. Der Server prüft unabhängig davon jeden Schreibzugriff (`403`, `storage.ErrTaskListReadOnly`).
 
----
+Bestehende Freigaben aus der Zeit vor dieser Stufe wurden mit `editor` migriert, behalten also ihr Verhalten.
 
-## 🏢 2. Gruppen & Teams (`teams` & `team_members`)
+## Isolations-Modi (`system_settings.sharing_mode`)
 
-Gruppen strukturieren Benutzer (z.B. „Familie", „Entwicklung", „Marketing"):
-- **Gruppen-Admin:** Darf Mitglieder einladen, Rollen ändern oder die Gruppe löschen.
-- **Gruppen-Mitglied:** Hat Zugriff auf alle mit der Gruppe geteilten Ressourcen (Ordner, Aufgabenlisten, Einkaufslisten, Notizen).
+Werte: `strict_private`, `teams_only` (Standard), `open`. Gedacht ist:
 
-Wird eine Ressource für eine Gruppe freigegeben, erhalten **alle aktuellen und zukünftigen Mitglieder** der Gruppe automatisch Zugriff, ohne dass Einzelberechtigungen gepflegt werden müssen.
+| Modus | Zweck |
+|---|---|
+| `strict_private` | Keine Sichtbarkeit zwischen Benutzern |
+| `teams_only` | Freigaben nur zwischen Mitgliedern gemeinsamer Gruppen |
+| `open` | Jeder kann für jeden freigeben |
 
----
+**Tatsächlich** wird der Modus nur in `GetDiscoverableUsers` ausgewertet, und dort liefert `teams_only` bereits alle Benutzer. `GET /collaborators` ignoriert den Modus, und keine Freigabe-Funktion prüft ihn. Die Einstellung hat derzeit also kaum Wirkung ([FLAW-10](flaws.md)).
 
-## 📁 3. Entkoppelte Ordner-Freigabe (Decoupled Folder Mounts)
+## Entkoppelte Ablage geteilter Notizen und Ordner
 
-### Das traditionelle Problem
-In herkömmlichen Cloud-Systemen (wie Google Drive oder Nextcloud) führt das Verschieben eines geteilten Ordners oft dazu, dass er auch bei allen anderen Teilnehmern den Platz wechselt. Verschiebt ein Kollege den Ordner in sein Unterverzeichnis „Archiv", verschwindet er beim Ersteller aus dem Sichtfeld.
+- **Geteilte Ordner:** Der Ordner existiert einmal (`workspace_shared_folders`); jeder Empfänger hat seinen eigenen Einhängepfad (`workspace_folder_mounts.mount_path`). Verschiebt ein Empfänger den Ordner, ändert sich nur sein Pfad. Der Unterpfad innerhalb des Ordners (`documents.sub_folder_path`) gilt für alle.
+- **Einzelne Notizen:** Jeder Empfänger kann eine geteilte Notiz in einen eigenen Ordner legen (`doc_user_folders`); die Notiz des Eigentümers bleibt unberührt.
 
-### Die MindSift-Lösung: Unabhängige Einhängepunkte (Mounts)
-MindSift entkoppelt die physische Ordner-Identität von der persönlichen Ordner-Hierarchie des Benutzers:
+## Sitzungen und Zugriff
 
-```
-Eigentümer (Alice):
-  Ordner: "Kundenprojekte"
-    └── Geteilter Ordner: "Projekt Phoenix" (wsf_123)
-          ├── spec.md
-          └── roadmap.md
-
-Empfänger (Bob):
-  Ordner: "Meine Aufgaben"
-    └── "Wichtiges"
-          └── Einhängepunkt: "Projekt Phoenix" (wsf_123 eingehängt via mount_path)
-                ├── spec.md
-                └── roadmap.md
-```
-
-#### Wie es technisch funktioniert:
-1. Der geteilte Ordner existiert als Entität in `workspace_shared_folders`.
-2. Beim Eigentümer liegt der Ordner unter seinem Pfad.
-3. Jeder Empfänger erhält in `workspace_folder_mounts` seinen **eigenen lokalen `mount_path`**.
-4. **Unabhängiges Verschieben:** Schiebt Bob den Ordner an eine andere Stelle in seinem Dateibaum, wird **ausschließlich sein persönlicher `mount_path`** aktualisiert. Alice und andere Teammitglieder bemerken davon nichts.
-5. **Inhaltliche Synchronisation:** Verschiebt, erstellt oder bearbeitet jemand eine Notiz *innerhalb* des geteilten Ordners, wird der relative Unterpfad (`sub_folder_path`) synchronisiert, sodass alle dieselbe interne Dokumentstruktur sehen.
-
----
-
-## 📄 4. Entkoppelte Notizen-Freigabe (`doc_user_folders`)
-
-Dasselbe Prinzip gilt für einzeln geteilte Dokumente:
-- Erhält Benutzer Bob eine einzelne Notiz von Alice freigegeben, kann Bob diese Notiz in jeden beliebigen seiner eigenen Ordner einsortieren.
-- Seine persönliche Zuordnung wird in der Tabelle `doc_user_folders` (`user_id`, `doc_id`, `folder_path`) gespeichert.
-- Die Original-Notiz von Alice verbleibt an ihrem ursprünglichen Platz.
-
----
-
-## 📋 5. Geteilte Aufgaben- & Einkaufslisten
-
-- **Aufgabenlisten (`task_list_shares`):** Freigabe für Teams oder Einzelbenutzer mit Lese- oder Schreibrechten.
-- **Geteilte Listen (`list_shares`):**
-  - Rolle `editor`: Einträge hinzufügen, ändern, abhaken und löschen.
-  - Rolle `viewer`: Nur Lesezugriff (Echtzeit-Ansicht).
-- **Einheitlicher Freigabe-Dialog:** [`UnifiedShareModal.tsx`](../../frontend/src/components/UnifiedShareModal.tsx) bündelt alle Freigabeoptionen (Teams, Benutzer, Berechtigungsstufen) in einer konsistenten Benutzeroberfläche.
+- Tokens werden bei Passwortänderung, Rollenwechsel, Deaktivierung und „Alle Sitzungen beenden“ ungültig (`token_version`); ausgeloggte Tokens landen in `revoked_tokens`.
+- Registrierung nur per Einladungscode oder, wenn vom Admin freigeschaltet, offen. Das erste Konto wird immer Administrator.
+- Bekannte Lücken in der Zugriffskontrolle: [FLAW-01](flaws.md), [FLAW-02](flaws.md), [FLAW-03](flaws.md), [FLAW-06](flaws.md), [FLAW-07](flaws.md), [FLAW-08](flaws.md), [FLAW-24](flaws.md).

Doku/theming.md

@@ -6,7 +6,7 @@ MindSift implementiert ein radikal einfaches, modulares Theming-System. Anstatt
 
 ## 💡 1. Philosophie: 1 Datei = 1 komplettes Theme
 
-Jedes Theme liegt im Verzeichnis [`frontend/src/themes/`](../../frontend/src/themes/) und definiert alle visuellen Eigenschaften über standardisierte CSS-Variablen. 
+Jedes Theme liegt im Verzeichnis [`frontend/src/themes/`](../frontend/src/themes/) und definiert alle visuellen Eigenschaften über standardisierte CSS-Variablen. 
 
 ### Trennung von Struktur und Design
 - **React-Komponenten** definieren ausschließlich semantische Klassen (wie `.panel-surface`, `.input-field`, `.btn-primary`, `text-main`, `bg-canvas`).
@@ -78,17 +78,17 @@ Jede Theme-Datei gliedert sich in sechs exakt definierte Bereiche:
 
 | Theme-ID | Datei | Stil & Charakter | Standard-Geometrie |
 | :--- | :--- | :--- | :--- |
-| `dark` | [`theme-dark.css`](../../frontend/src/themes/theme-dark.css) | Standard Dark Slate / Monochrom | Streng eckig (`0px` Cards, `2px` Buttons) |
-| `light` | [`theme-light.css`](../../frontend/src/themes/theme-light.css) | Daylight Clean White / Minimalistisch | Modern dezent (`4px` Cards, `4px` Buttons) |
-| `high-contrast` | [`theme-high-contrast.css`](../../frontend/src/themes/theme-high-contrast.css) | Reines Schwarz/Weiß mit AAA-Kontrast | Streng eckig (`0px`, kräftige Rahmen) |
-| `soft` | [`theme-soft.css`](../../frontend/src/themes/theme-soft.css) | Warmes Soft Slate mit Indigo-Akzent | Weich gerundet (`12px` Cards, `8px` Buttons) |
-| *Template* | [`theme-template.css`](../../frontend/src/themes/theme-template.css) | Vollständig dokumentierte Kopiervorlage | Frei anpassbar |
+| `dark` | [`theme-dark.css`](../frontend/src/themes/theme-dark.css) | Standard Dark Slate / Monochrom | Streng eckig (`0px` Cards, `2px` Buttons) |
+| `light` | [`theme-light.css`](../frontend/src/themes/theme-light.css) | Daylight Clean White / Minimalistisch | Modern dezent (`4px` Cards, `4px` Buttons) |
+| `high-contrast` | [`theme-high-contrast.css`](../frontend/src/themes/theme-high-contrast.css) | Reines Schwarz/Weiß mit AAA-Kontrast | Streng eckig (`0px`, kräftige Rahmen) |
+| `soft` | [`theme-soft.css`](../frontend/src/themes/theme-soft.css) | Warmes Soft Slate mit Indigo-Akzent | Weich gerundet (`12px` Cards, `8px` Buttons) |
+| *Template* | [`theme-template.css`](../frontend/src/themes/theme-template.css) | Vollständig dokumentierte Kopiervorlage | Frei anpassbar |
 
 ---
 
 ## 🔌 4. Tailwind-Bridge & Semantische Klassen
 
-In [`frontend/src/index.css`](../../frontend/src/index.css) und `tailwind.config.js` sind die semantischen Utility-Klassen definiert, die sich automatisch an das gewählte Theme anpassen:
+In [`frontend/src/index.css`](../frontend/src/index.css) und `tailwind.config.js` sind die semantischen Utility-Klassen definiert, die sich automatisch an das gewählte Theme anpassen:
 
 - `.panel-surface`: Wendet `--bg-panel`, `--border-color` und `--radius-card` an.
 - `.input-field`: Wendet `--bg-input`, `--border-color`, `--radius-input` und `--text-main` an.
@@ -105,5 +105,5 @@ Um ein neues Theme (z.B. „Nordic Blue" oder „Cyberpunk") hinzuzufügen:
 1. Kopiere `frontend/src/themes/theme-template.css` nach `frontend/src/themes/theme-meintheme.css`.
 2. Ändere den Selektor `:root[data-theme="template"]` in `:root[data-theme="meintheme"]`.
 3. Passe Farben und Rundungen nach Belieben an.
-4. Importiere die CSS-Datei in [`frontend/src/lib/theme.ts`](../../frontend/src/lib/theme.ts) und trage das Theme im `AVAILABLE_THEMES`-Array ein.
+4. Importiere die CSS-Datei in [`frontend/src/lib/theme.ts`](../frontend/src/lib/theme.ts) und trage das Theme im `AVAILABLE_THEMES`-Array ein.
 5. Das neue Theme steht sofort in den Kontoeinstellungen und im Profil-Dropdown zur Verfügung!

README.md

@@ -5,236 +5,194 @@
 
 [![Self-Hosted](https://img.shields.io/badge/100%25-Self--Hosted-2563eb?style=flat-square)](#)
 [![Docker](https://img.shields.io/badge/Deployment-Single%20Container-2496ed?style=flat-square&logo=docker&logoColor=white)](#-schnellstart)
-[![Markdown](https://img.shields.io/badge/Datenhoheit-Pure%20Markdown%20%26%20Outliner-18181b?style=flat-square)](#)
-[![License](https://img.shields.io/badge/Lizenz-MIT-22c55e?style=flat-square)](LICENSE)
+[![SQLite](https://img.shields.io/badge/Daten-SQLite-003b57?style=flat-square&logo=sqlite&logoColor=white)](#-deine-daten-gehören-dir)
 
-**MindSift** ist deine zentrale, kompromisslos schnelle Schaltstelle für spontane Gedanken, strukturierte Aufgaben mit Kanban-Board, hierarchische Outliner-Notizen mit Zoom-Fokus und gemeinsame Echtzeit-Listen — ablenkungsfrei gestaltet, lokal als Standard-Markdown gespeichert und zu 100 % unter deiner eigenen Kontrolle.
-
-<br />
+**MindSift** ist eine selbst gehostete Schaltstelle für spontane Gedanken, Aufgaben mit Kanban-Board, hierarchische Outliner-Notizen und gemeinsame Listen. Alles läuft als ein einzelner Container mit eingebetteter SQLite-Datenbank, auf deinem eigenen Server.
 
 <p align="center">
-  <img src="screenshots/Triage_desktop.png" alt="MindSift Triage Desktop" width="85%" style="border-radius: 8px; box-shadow: 0 4px 20px rgba(0,0,0,0.3);" />
+  <img src="screenshots/Triage_desktop.png" alt="MindSift Triage Desktop" width="85%" />
 </p>
 
-[Philosophie](#-die-philosophie) • [Funktionen](#-was-mindsift-auszeichnet) • [Schnellstart](#-schnellstart) • [Für wen?](#-für-wen-ist-mindsift-gemacht)
+[Philosophie](#-die-philosophie) • [Funktionen](#-funktionen) • [Schnellstart](#-schnellstart) • [Betrieb](#-betrieb--konfiguration) • [Entwicklung](#-entwicklung) • [Dokumentation](#-dokumentation)
 
 </div>
 
 ---
 
-## 💡 Die Philosophie: *Erst raus aus dem Kopf – später sortieren*
+## 💡 Die Philosophie
 
-Klassische Produktivitäts- und Notiz-Apps scheitern im Alltag oft an derselben Hürde: **Sie verlangen Struktur im falschen Moment.**  
-Wenn dir mitten im Gespräch, unterwegs auf dem Smartphone oder kurz vor Feierabend ein wichtiger Gedanke kommt, willst du keinen Ordner suchen, keine Datenbankfelder ausfüllen und keine starren Formulare bedienen. Du willst den Gedanken in drei Sekunden festhalten – und sicher sein, dass er verlässlich da ist, wenn du Zeit hast.
+Die meisten Notiz- und Aufgaben-Apps verlangen Struktur im falschen Moment: Wenn dir ein Gedanke kommt, willst du keinen Ordner suchen und keine Felder ausfüllen. MindSift trennt deshalb **Erfassen** und **Organisieren**:
 
-**MindSift trennt das Erfassen radikal vom Organisieren:**
-
-1. **Sofort abladen (Quick Dump):** In die globale Eingabeleiste tippen, `Enter` drücken, Kopf wieder frei. Du kannst Gedanken aber auch direkt beim Eintippen gezielt einer Aufgabenliste, Einkaufsliste oder Notiz zuweisen.
-2. **Spielerisch sichten (Triage):** In ruhigen Momenten sichtest du deinen Stapel Karte für Karte – am Desktop per Tastaturkürzel oder auf dem Smartphone per Wischgeste. Mit einer Taste nach links verwerfen, auf „Später“ vertagen oder direkt in eine Aufgabe, Notiz oder Liste umwandeln.
-3. **Strukturiert vertiefen:** Aus losen Ideen werden vernetzte Outliner-Dokumente, hierarchische Unteraufgaben im Kanban-Board oder geteilte Listen für Familie, WG und Team.
+1. **Abladen:** In die Eingabeleiste tippen, `Enter`, fertig. Wer will, weist den Gedanken gleich einer Aufgabe, Liste oder Notiz zu.
+2. **Sichten (Triage):** Später gehst du den Stapel Karte für Karte durch: verwerfen, zur Aufgabe machen, in eine Notiz oder Liste verwandeln.
+3. **Vertiefen:** Aus losen Ideen werden Aufgaben mit Unteraufgaben, vernetzte Outliner-Notizen oder geteilte Listen für Familie und Team.
 
 ---
 
-## ✨ Was MindSift auszeichnet
+## ✨ Funktionen
 
-### ⚡ Quick-Dump & Triage-Deck (Das 3-Sekunden-Prinzip)
+### ⚡ Schnellerfassung & Triage
 
-* **Blitz-Erfassung:** Die Schnelleingabeleiste sitzt prominent im Header – jederzeit blitzschnell per Mausklick oder Tastendruck (`C` oder `/`) fokussierbar.
-* **Tastatur-Triage am Desktop:**
-  * `H` oder `←`: Wegwerfen / Erledigt
-  * `L` oder `→`: Sofort zur Aufgabe machen
-  * `T`: Termin-Aufgabe mit Fälligkeitsdatum
-  * `D`: In Workspace-Notiz umwandeln
-  * `Leertaste`: Später (ans Ende des Stapels schieben)
-* **Mobile-First & Touch-optimiert:** Unterwegs kannst du Gedanken per Wischgeste (Swipe nach links zum Verwerfen, Swipe nach rechts zum Behalten) sortieren.
+* Eingabeleiste im Kopf der App, jederzeit mit `C` oder `/` fokussierbar; auch per Spracheingabe (Browser-Funktion).
+* Ziel beim Erfassen wählbar: Posteingang, Aufgabe, Listeneintrag oder Notiz.
+* **Triage-Deck:** `H`/`←` verwerfen, `L`/`→` zur Aufgabe, `T` Aufgabe mit Termin, `D` in Notiz verwandeln, Leertaste = später. Auf dem Smartphone per Wischgeste.
+* Papierkorb mit Wiederherstellen.
 
 <p align="center">
-  <img src="screenshots/Mobile_Triage.png" alt="MindSift Mobile Triage" width="280px" style="border-radius: 12px; box-shadow: 0 4px 16px rgba(0,0,0,0.25);" />
+  <img src="screenshots/Mobile_Triage.png" alt="MindSift Mobile Triage" width="280px" />
 </p>
 
----
+### ✅ Aufgaben & Kanban
 
-### 📝 Workspace: Der hierarchische Outliner mit Zoom-Fokus
-
-Der MindSift-Workspace vereint die Übersicht eines klassischen Dokumenten-Explorers mit der Leichtigkeit eines hierarchischen Outliners (inspiriert von Logseq und Roam).
+* Listen- und Kanban-Ansicht, Spalten pro Aufgabenliste frei konfigurierbar.
+* Prioritäten, Fälligkeitsdatum, Hashtags, Unteraufgaben mit Fortschrittsbalken, Markdown-Notizen.
+* Filter, Gruppierung und Sortierung; Drag & Drop in Liste und Board.
+* **Aufgabenlisten teilen** mit Benutzern oder Gruppen, wahlweise als **Bearbeiter** oder **nur lesend**.
+* **Alarme** bei Fälligkeit per E-Mail, Discord oder eigenem Webhook.
 
 <p align="center">
-  <img src="screenshots/workspace_desktop.png" alt="MindSift Workspace Outliner" width="90%" style="border-radius: 8px; box-shadow: 0 4px 20px rgba(0,0,0,0.3);" />
+  <img src="screenshots/aufgaben_desktop.png" alt="MindSift Aufgaben und Kanban-Board" width="90%" />
 </p>
 
-* **Jeder Gedanke ein Bullet-Point:**
-  * `Enter`: Neuer Bullet-Point auf derselben Ebene
-  * `Tab` / `Shift + Tab`: Unterordnen (einrücken) und ausrücken
-  * `Shift + Enter`: Weicher Zeilenumbruch innerhalb desselben Blocks
-* **🔍 Fokus-Modus & Zoom-in (Hoisting):**
-  * Klicke auf einen Bullet-Punkt (`•`), um **isoliert in diesen Ast hineinzuzoomen**.
-  * Der gewählte Punkt wird zur prominenten Überschrift, sodass du dich ohne jede Ablenkung auf genau dieses Thema konzentrieren kannst.
-  * Eine klickbare Breadcrumb-Leiste oben zeigt deinen aktuellen Pfad und führt dich mit einem Klick zurück in übergeordnete Ebenen oder ins Hauptdokument.
-* **Intuitives Drag & Drop für Bullet-Points:**
-  * Verschiebe Absätze und ganze Gedankenbäume mühelos mit der Maus.
-  * **Unterpunkte per Drop erstellen:** Ziehst du einen Bullet-Point direkt auf einen anderen Aufzählungspunkt, wird er automatisch als Unter-Bullet eingerückt. Eingeklappte Eltern-Punkte klappen beim Hineinlegen automatisch auf.
-  * Untergeordnete Unterpunkte werden beim Ziehen automatisch als zusammenhängender Ast mitbewegt.
-* **Live-Kollaboration & Presence-Tracking:**
-  * Gleichzeitiges, latenzfreies Bearbeiten von Dokumenten im Team ohne blockierende Sperren.
-  * Farbige Avatare im Header und Live-Cursors am aktiven Block visualisieren genau, wer gerade wo tippt.
-  * Strikter Echo-Schutz verhindert Cursor-Springen und Flackern beim Tippen.
-* **Slash-Befehle (`/`):** Tippe einfach `/` für `/todo`, `/link` (Notizen & Web-Links verknüpfen), `/h1`, `/h2`, `/h3`, `/code`, `/callout`, `/quote` oder `/divider`.
-* **Vernetzung & Hashtags:** Verlinke Notizen untereinander mit Wiki-Links (`[[Notiztitel]]`) und tagge Gedanken mit `#Hashtags`.
-* **Explorer mit Ordnern & Favoriten:** Organisiere Dokumente hierarchisch in Ordnern, verschiebe Notizen per Drag & Drop und hefte deine wichtigsten Dokumente als Favoriten ganz oben an.
-* **100 % Pure-DB & Markdown-Export:** Alle Notizen und Blöcke werden transaktional und sicher in SQLite gespeichert. Beim Speichern wird automatisch ein sauberer Markdown-Cache generiert, und Dokumente können jederzeit mit einem Klick als `.md`-Datei exportiert werden.
+### 📝 Workspace: Outliner-Notizen
 
----
-
-### ✅ Aufgabenlisten & Kanban-Board
-
-Behalte offene Aufgaben, Projekte und Termine im Blick – wahlweise als strukturierte Liste oder als visuelles Kanban-Board.
+* Jeder Gedanke ein Bullet: `Enter`, `Tab`/`Shift+Tab`, Ein-/Ausklappen, Drag & Drop ganzer Äste.
+* **Zoom-Fokus** per Klick auf den Bullet, Breadcrumbs zum Zurücknavigieren.
+* Blocktypen und Slash-Befehle: `/todo`, `/link`, `/h1`–`/h3`, `/code` (mit Syntax-Hervorhebung), `/callout`, `/divider`.
+* Wiki-Links `[[Notiz]]`, Links und `#Hashtags`; Tag-Seiten bündeln alle Fundstellen.
+* Ordner, Favoriten, **To-Do-Rollup** über alle Notizen und Export einer Notiz als `.md`.
+* Einfügen von mehrzeiligem Markdown wird in Blöcke zerlegt.
+* **Teilen:** Notizen und ganze Ordner lassen sich Benutzern oder Gruppen **zum Lesen** freigeben. Empfänger sortieren sie in ihren eigenen Baum ein.
 
 <p align="center">
-  <img src="screenshots/aufgaben_desktop.png" alt="MindSift Aufgaben und Kanban-Board" width="90%" style="border-radius: 8px; box-shadow: 0 4px 20px rgba(0,0,0,0.3);" />
+  <img src="screenshots/workspace_desktop.png" alt="MindSift Workspace Outliner" width="90%" />
 </p>
 
-* **Flexible Ansichten (Liste & Kanban):** Wechsle mit einem Klick zwischen kompakter Listenansicht und dem interaktiven Kanban-Board (*Zu erledigen*, *In Arbeit*, *Wartend*, *Erledigt*).
-* **Unteraufgaben (Subtasks):**
-  * Gliedere komplexe Aufgaben in beliebig viele Teilaufgaben.
-  * Ein visueller Fortschrittsbalken und eine Prozentanzeige zeigen dir auf einen Blick, wie weit die Aufgabe gediehen ist.
-* **Freies Drag & Drop:**
-  * Sortiere Aufgaben vertikal in deiner bevorzugten Reihenfolge.
-  * Im Kanban-Board verschiebst du Karten per Drag & Drop direkt zwischen Status-Spalten oder ordnest sie innerhalb einer Spalte um.
-  * Kein mühsames Suchen nach Greifern: Klicke und ziehe eine Aufgabe einfach direkt mit der Maus – ein kurzer Klick ohne Ziehen öffnet das Detail-Modal zum Bearbeiten.
-* **Prioritäten & Termine:** Hebe dringende oder wichtige Aufgaben mit Farbcodes und Icons hervor (🔥 Dringend, ⚠️ Wichtig). Setze Fälligkeitsdaten und filtere nach Hashtags.
-* **Geteilte Aufgabenlisten:** Erstelle separate Listen für Beruf, Homelab oder Familie und teile sie gezielt mit Gruppen, Teams oder einzelnen Nutzern.
+### 🛒 Geteilte Listen
 
----
-
-### 🛒 Geteilte Listen (Einkauf & Checklisten)
-
-Ob Wochenmarkt, Baumarkt oder Urlaubs-Packliste – erstelle geteilte Listen, die für gemeinsames Arbeiten in Echtzeit optimiert sind.
+* Einkaufs-, Pack- und Checklisten mit Kategorien per Hashtag (`Hafermilch #Kühlregal`), Mengenangaben und Drag & Drop zwischen Kategorien.
+* Freigabe an Benutzer und Gruppen (Bearbeiter oder Leser); abgehakte Einträge erscheinen bei allen in Echtzeit.
 
 <p align="center">
-  <img src="screenshots/Listen_desktop.png" alt="MindSift Geteilte Listen" width="90%" style="border-radius: 8px; box-shadow: 0 4px 20px rgba(0,0,0,0.3);" />
+  <img src="screenshots/Listen_desktop.png" alt="MindSift Geteilte Listen" width="90%" />
 </p>
 
-* **Automatische Hashtag-Kategorien:**
-  * Tagge Artikel einfach mit einem Hashtag (z. B. `Hafermilch #Kühlregal` oder `Bananen #Obst`).
-  * MindSift sortiert die Kategorien automatisch alphabetisch und zeigt sie in übersichtlichen Sektionen mit Kacheln an.
-  * **Hashtag-Autovervollständigung:** Bereits beim Tippen eines `#` schlägt dir die Eingabe existierende Hashtags vor (case-insensitive) – mit Tastaturnavigation und Sofort-Übernahme per `Enter`.
-* **Mengenangaben & Schnell-Eingabe:** Erfasse Mengen (`2x`, `500g`) direkt im Eingabefeld.
-* **Drag & Drop zwischen Kategorien:** Ziehe Einträge mit der Maus nach oben oder unten oder schiebe sie direkt in einen anderen Hashtag-Bereich – der Hashtag im Text wird automatisch aktualisiert.
-* **Gemeinsam teilen mit Gruppen & Teams:**
-  * Über das einheitliche Teilen-Modal kannst du jede Liste mit deinen Teams, Arbeitsgruppen oder Einzelpersonen freigeben.
-  * Avatare und Freigabe-Badges im Header zeigen dir transparent, wer Zugriff hat.
-* **Echtzeit-WebSocket-Synchronisation:** Wird ein Artikel im Supermarkt abgehakt, hakt er sich bei allen Beteiligten im selben Augenblick live ab.
-* **Eckiges Abhaken & Aufräumen:** Erledigte Punkte wandern in einen separaten Bereich und können mit einem Klick aufgeräumt werden.
+### 🏢 Benutzer, Gruppen, Administration
 
----
+* Geführte Ersteinrichtung, Rollen *Admin* und *Mitglied*, Einladungscodes, optional offene Registrierung.
+* Gruppen mit Gruppen-Admins für Freigaben.
+* Admin-Bereich: Benutzer, Einladungen, Instanzname, SMTP, Freigabe-Modus.
+* Vier Themes (Dark, Light, High-Contrast, Soft), installierbar als PWA.
 
-### 📋 Globale To-Dos: Das automatische Notizen-Rollup
+### 🔌 Integrationen
 
-* **Automatische Erfassung:** MindSift durchsucht alle Workspace-Notizen und sammelt sämtliche Checkboxen (`- [ ]`) in einem zentralen Rollup-Dashboard.
-* **Ordner-Filter:** Isoliere Aufgaben bestimmter Projekte mit einem Klick.
-* **2-Wege-Echtzeit-Sync:** Hakst du ein To-Do im Rollup ab, wird die physische Markdown-Datei auf der Festplatte augenblicklich als `- [x]` aktualisiert.
-
----
-
-### 🏢 Benutzer, Gruppen & Administration
-
-* **Geführte Ersteinrichtung:** Beim ersten Start führt dich ein Assistent durch die Einrichtung deines Administrator-Kontos.
-* **Eigenständiger Gruppen-Bereich:** Verwalte eigene Gruppen und Teams direkt über das Benutzer-Menü oben rechts.
-* **Gruppen-Administration:** Wer eine Gruppe anlegt oder zum Gruppen-Admin ernannt wird, hat die volle Kontrolle über die Mitglieder dieser Gruppe.
-* **Server-Sicherheit:** Schalte die öffentliche Registrierung ab und lade neue Mitglieder kontrolliert per Einladungscode ein.
+* **Webhook / API-Key:** `POST /api/v1/webhooks/ingest` legt Aufgaben aus Smarthome, Skripten oder Automationen an.
+* Persönliche API-Keys, Datenexport als JSON.
 
 ---
 
 ## 🚀 Schnellstart
 
-MindSift läuft als leichtgewichtiger, einzelner Container und bringt Webserver, API, SQLite-Datenbank und Frontend direkt mit.
+MindSift läuft als einzelner Container mit Webserver, API, Datenbank und Frontend.
 
-### Option 1: Der 1-Zeiler (Empfohlen)
-
-Führe diesen Befehl im Terminal deines Servers aus. Er erstellt das Verzeichnis, lädt die Konfiguration, generiert ein sicheres JWT-Geheimnis und startet den Container:
+### Option 1: Installationsskript
 
 ```bash
 curl -fsSL https://git.dsit.me/sandrodach/MindSift/raw/branch/dev/install.sh | bash
 ```
 
----
+Das Skript legt ein Verzeichnis an, lädt `docker-compose.yml` und `.env.example`, erzeugt ein `JWT_SECRET` und startet den Container.
 
-### Option 2: Schneller Start mit zwei `curl`-Befehlen
-
-Falls du die Dateien direkt ohne Skript herunterladen möchtest:
+### Option 2: Docker Compose
 
 ```bash
 mkdir -p mindsift && cd mindsift
 curl -fsSL https://git.dsit.me/sandrodach/MindSift/raw/branch/dev/docker-compose.yml -o docker-compose.yml
 curl -fsSL https://git.dsit.me/sandrodach/MindSift/raw/branch/dev/.env.example -o .env
+# In .env: JWT_SECRET durch einen langen Zufallswert ersetzen!
 docker compose up -d
 ```
 
----
-
-### Option 3: Manuelle `docker-compose.yml`
-
-Erstelle eine Datei namens `docker-compose.yml`:
+Minimal:
 
 ```yaml
 services:
   mindsift:
     image: git.dsit.me/sandrodach/mindsift:dev
-    container_name: mindsift
     restart: unless-stopped
-    ports:
-      - "8080:8080"
-    volumes:
-      - ./data:/data
+    ports: ["8080:8080"]
+    volumes: ["./data:/data"]
     environment:
-      - PORT=8080
-      - DATA_DIR=/data
-      - JWT_SECRET=hier-ein-langes-sicheres-zufalls-geheimnis-eintragen
-      - ALLOW_REGISTRATION=false
-      # Optional: Mailserver für E-Mail-Alarme (auch im Admin-UI einstellbar)
-      - SMTP_HOST=
-      - SMTP_PORT=587
-      - SMTP_USER=
-      - SMTP_PASS=
-      - SMTP_FROM=
-      - SMTP_TLS=true
+      - JWT_SECRET=hier-ein-langer-zufaelliger-wert
+      - BASE_URL=https://mindsift.example.com
 ```
 
-Starte den Container:
+### Ersteinrichtung
+
+Rufe `http://localhost:8080` auf. Beim ersten Start führt ein Assistent durch das Anlegen des Administrator-Kontos.
+
+> ⚠️ **Setze `JWT_SECRET`.** Ohne Angabe nutzt der Server einen öffentlich bekannten Standardwert, mit dem sich Anmelde-Tokens fälschen lassen. Rufe die Instanz außerdem direkt nach dem Start auf, damit kein Fremder das erste Konto anlegt.
+
+---
+
+## ⚙️ Betrieb & Konfiguration
+
+| Variable | Standard | Zweck |
+|---|---|---|
+| `PORT` | `8080` | HTTP-Port |
+| `DATA_DIR` | `/data` (Container) | Ablage der Datenbank `mindsift.db` |
+| `JWT_SECRET` | unsicherer Standard | **Pflicht in Produktion**, Signaturschlüssel |
+| `BASE_URL` | `http://localhost:8080` | Öffentliche URL |
+| `ALLOW_REGISTRATION` | `false` | Offene Registrierung (im Admin-UI änderbar) |
+| `LOG_LEVEL` / `DEBUG` | `info` / `false` | Logging |
+| `SMTP_HOST`, `SMTP_PORT`, `SMTP_USER`, `SMTP_PASS`, `SMTP_FROM`, `SMTP_TLS` | leer | E-Mail-Alarme (auch im Admin-UI) |
+| `MINDA_DEMO` | `false` | Legt Demo-Konten `admin/admin`, `user/user` an. **Nie auf öffentlichen Servern!** |
+
+* **Reverse-Proxy:** WebSocket-Upgrade und ungepufferte SSE-Streams müssen durchgereicht werden. Beispiele für Nginx, Traefik, Caddy und Cloudflare: [Doku/reverse-proxy.md](Doku/reverse-proxy.md).
+* **Datensicherung:** Alle Daten liegen in `data/mindsift.db` (+ `-wal`/`-shm`). Sichere sie mit `sqlite3 mindsift.db ".backup 'backup.db'"` oder bei gestopptem Container. Zusätzlich gibt es einen JSON-Export pro Benutzer.
+* **Updates:** Neues Image ziehen und Container neu starten (`docker compose pull && docker compose up -d`). Das Schema wird beim Start automatisch angepasst.
+
+---
+
+## 🛠 Entwicklung
+
+Voraussetzungen: Go 1.23, Node 22.
 
 ```bash
-docker compose up -d
+# Backend: Vet und Tests
+go vet ./... && go test ./...
+
+# Frontend
+cd frontend
+npm ci
+npm run dev                # Vite-Entwicklungsserver
+npx tsc --noEmit           # Typprüfung
+npm run build              # Produktions-Build
 ```
 
----
+Für das Binary wird das gebaute Frontend nach `cmd/server/dist` kopiert (`go:embed`); das mehrstufige `Dockerfile` erledigt das und führt Vet und Tests beim Image-Build aus.
 
-### 🌐 Ersteinrichtung aufrufen
-
-Öffne deinen Browser unter **`http://localhost:8080`** (bzw. die IP deines Servers).  
-MindSift erkennt den Erststart automatisch und führt dich durch den Einrichtungs-Assistenten zum Erstellen des Administrator-Kontos.
+**Stack:** Go (chi, gorilla/websocket, JWT, modernc SQLite) · React 18, TypeScript, Vite, Tailwind.
 
 ---
 
-## 👥 Für wen ist MindSift gemacht?
+## 📚 Dokumentation
 
-* **Für Macher & Wissensarbeiter**, die tagsüber dutzende Gedanken, Links und Aufgaben festhalten müssen, ohne aus dem Arbeitsfluss gerissen zu werden.
-* **Für Outliner-Fans**, die die Flexibilität von Logseq schätzen, aber ihre Notizen in einer klaren Ordnerstruktur auf dem eigenen Server haben wollen.
-* **Für Familien & WGs**, die gemeinsame Einkaufs- und Packlisten ohne Werbe-Apps und fremde Clouds synchronisieren möchten.
-* **Für Homelab- & Self-Hosting-Begeisterte**, die volle Datenhoheit, saubere Markdown-Dateien und automatisierte Webhooks auf eigener Hardware schätzen.
+Die technische Doku liegt unter [Doku/](Doku/README.md): Architektur, Datenbank, REST- und Echtzeit-API, Module, Freigaben und Berechtigungen, Themes. Bekannte Schwachstellen und offene Punkte stehen in [Doku/flaws.md](Doku/flaws.md).
 
 ---
 
 ## 🔒 Deine Daten gehören dir
 
-* **100 % Self-Hosted:** Keine fremden Cloud-Dienste, keine Telemetrie, kein Tracking.
-* **Kein Vendor-Lock-in:** Alle Notizen liegen als relationale Daten in SQLite und werden automatisch als Standard-Markdown kompiliert. Dokumente lassen sich jederzeit mit einem Klick als `.md`-Datei exportieren oder als SQLite-Dump sichern.
+* Selbst gehostet, keine Telemetrie, keine Fremddienste. Ausgehende Verbindungen gibt es nur zu den Alarm-Zielen, die du selbst einrichtest (SMTP, Discord, Webhook).
+* Alle Inhalte liegen in einer einzigen SQLite-Datei; Notizen lassen sich als Markdown exportieren, alle Daten eines Benutzers als JSON.
 
 ---
 
 ## 📄 Lizenz
 
-Veröffentlicht unter der **MIT-Lizenz** – siehe [LICENSE](LICENSE).
+Im Repository liegt derzeit keine `LICENSE`-Datei; die Lizenz ist damit nicht festgelegt.
 
 <div align="center">
-<sub>Gebaut für maximale Klarheit, Geschwindigkeit und digitale Souveränität.</sub>
-</div>
+<sub>Gebaut für Klarheit, Geschwindigkeit und digitale Souveränität.</sub>
+</div>

cmd/server/main.go

@@ -5,6 +5,7 @@ import (
 	"embed"
 	"io/fs"
 	"log/slog"
+	"net"
 	"net/http"
 	"os"
 	"os/signal"
@@ -58,9 +59,15 @@ func main() {
 
 	srv := api.NewServer(cfg, store, wsHub, staticFS)
 
+	serverCtx, serverCancel := context.WithCancel(context.Background())
+	defer serverCancel()
+
 	httpServer := &http.Server{
-		Addr:         ":" + cfg.Port,
-		Handler:      srv.Router(),
+		Addr:    ":" + cfg.Port,
+		Handler: srv.Router(),
+		BaseContext: func(l net.Listener) context.Context {
+			return serverCtx
+		},
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 30 * time.Second,
 		IdleTimeout:  60 * time.Second,
@@ -79,7 +86,12 @@ func main() {
 	<-stop
 
 	slog.Info("Shutting down MindSift server gracefully...")
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	serverCancel()
+	wsHub.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
-	_ = httpServer.Shutdown(ctx)
+	if err := httpServer.Shutdown(ctx); err != nil {
+		slog.Warn("HTTP server shutdown finished with error", "error", err)
+	}
 }

frontend/public/icon.svg

@@ -1,5 +1,14 @@
 <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
-  <rect width="512" height="512" rx="128" fill="#0b0f19"/>
-  <circle cx="256" cy="256" r="164" fill="none" stroke="#8ab4f8" stroke-width="36"/>
-  <path d="M184 266 L236 318 L338 194" fill="none" stroke="#c58af9" stroke-width="40" stroke-linecap="round" stroke-linejoin="round"/>
+  <rect width="512" height="512" rx="128" fill="#8ab4f8"/>
+  <g transform="translate(80, 80) scale(14.666)" fill="none" stroke="#0b0f19" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"/>
+    <path d="M12 5a3 3 0 1 1 5.997.125 4 4 0 0 1 2.526 5.77 4 4 0 0 1-.556 6.588A4 4 0 1 1 12 18Z"/>
+    <path d="M15 13a4.5 4.5 0 0 1-3-4 4.5 4.5 0 0 1-3 4"/>
+    <path d="M17.599 6.5a3 3 0 0 0 .399-1.375"/>
+    <path d="M6.003 5.125A3 3 0 0 0 6.401 6.5"/>
+    <path d="M3.477 10.896a4 4 0 0 1 .585-.396"/>
+    <path d="M19.938 10.5a4 4 0 0 1 .585.396"/>
+    <path d="M6 18a4 4 0 0 1-1.967-.516"/>
+    <path d="M19.967 17.484A4 4 0 0 1 18 18"/>
+  </g>
 </svg>

frontend/src/App.tsx

@@ -127,6 +127,8 @@ export const App: React.FC = () => {
   const [activeTab, setActiveTab] = useState<ActiveTab>('triage');
   const [previousTab, setPreviousTab] = useState<ActiveTab>('triage');
   const [selectedDocId, setSelectedDocId] = useState<string | null>(null);
+  const [selectedBlockId, setSelectedBlockId] = useState<string | null>(null);
+  const [selectedTaskId, setSelectedTaskId] = useState<string | null>(null);
   const [captureFocusCount, setCaptureFocusCount] = useState(0);
   const [refreshRevision, setRefreshRevision] = useState(0);
 
@@ -143,6 +145,7 @@ export const App: React.FC = () => {
   const [mobileVoiceActive, setMobileVoiceActive] = useState(false);
   const [isVoiceCaptured, setIsVoiceCaptured] = useState(false);
   const mobileRecognitionRef = useRef<any>(null);
+  const mobileBaseVoiceRef = useRef('');
 
   const toggleMobileVoice = () => {
     const SpeechRecognition =
@@ -157,6 +160,7 @@ export const App: React.FC = () => {
       return;
     }
     try {
+      mobileBaseVoiceRef.current = mobileTriageContent.replace(/\s*\[…\]$/, '').trim();
       const recognition = new SpeechRecognition();
       recognition.lang = 'de-DE';
       recognition.continuous = false;
@@ -170,10 +174,8 @@ export const App: React.FC = () => {
         for (let i = 0; i < event.results.length; i++) {
           transcript += event.results[i][0].transcript;
         }
-        setMobileTriageContent((prev) => {
-          const base = prev.replace(/\s*\[…\]$/, '').trim();
-          return base ? `${base} ${transcript}` : transcript;
-        });
+        const base = mobileBaseVoiceRef.current;
+        setMobileTriageContent(base ? `${base} ${transcript}` : transcript);
         setIsVoiceCaptured(true);
       };
       recognition.onerror = () => setMobileVoiceActive(false);
@@ -249,13 +251,6 @@ export const App: React.FC = () => {
           id: 'triage-nav',
           title: 'Bereiche wechseln',
           items: [
-            {
-              id: 'goto-tasks',
-              label: 'Aufgaben & Kanban',
-              icon: <CheckSquare className="w-4 h-4" />,
-              badge: stats.tasksOpenCount,
-              onClick: () => setActiveTab('tasks'),
-            },
             {
               id: 'goto-workspace',
               label: 'Notizen & Workspace',
@@ -263,6 +258,13 @@ export const App: React.FC = () => {
               badge: stats.docsCount,
               onClick: () => setActiveTab('workspace'),
             },
+            {
+              id: 'goto-tasks',
+              label: 'Aufgaben & Kanban',
+              icon: <CheckSquare className="w-4 h-4" />,
+              badge: stats.tasksOpenCount,
+              onClick: () => setActiveTab('tasks'),
+            },
             {
               id: 'goto-lists',
               label: 'Einkaufslisten',
@@ -297,18 +299,18 @@ export const App: React.FC = () => {
               variant: 'accent',
               onClick: () => setActiveTab('triage'),
             },
-            {
-              id: 'goto-tasks',
-              label: 'Zu den Aufgaben',
-              icon: <CheckSquare className="w-4 h-4" />,
-              onClick: () => setActiveTab('tasks'),
-            },
             {
               id: 'goto-workspace',
               label: 'Zum Workspace',
               icon: <FileText className="w-4 h-4" />,
               onClick: () => setActiveTab('workspace'),
             },
+            {
+              id: 'goto-tasks',
+              label: 'Zu den Aufgaben',
+              icon: <CheckSquare className="w-4 h-4" />,
+              onClick: () => setActiveTab('tasks'),
+            },
             {
               id: 'goto-lists',
               label: 'Zu den Listen',
@@ -549,11 +551,17 @@ export const App: React.FC = () => {
     refreshAll();
   };
 
-  const handleOpenDocument = (docId: string) => {
+  const handleOpenDocument = (docId: string, blockId?: string) => {
     setSelectedDocId(docId);
+    setSelectedBlockId(blockId || null);
     setActiveTab('workspace');
   };
 
+  const handleOpenTask = useCallback((taskId: string) => {
+    setSelectedTaskId(taskId);
+    setActiveTab('tasks');
+  }, []);
+
   const handleTriggerAddButton = () => {
     triggerHaptic(20);
     if (window.innerWidth < 640) {
@@ -567,7 +575,11 @@ export const App: React.FC = () => {
   const handleLogout = async () => {
     triggerHaptic(20);
     disconnectWebSocket();
-    clearToken();
+    try {
+      await api.logout();
+    } catch {
+      clearToken();
+    }
     setUser(null);
     setShowProfileMenu(false);
     setActiveTab('triage');
@@ -632,9 +644,12 @@ export const App: React.FC = () => {
               <Brain className="w-4 h-4" />
             </div>
             <div className="flex items-center gap-1.5">
-              <span className="font-bold text-base text-main tracking-tight">
-                {authStatus.instanceName || 'MindSift'}
-              </span>
+              <div className="flex flex-col">
+                <span className="font-bold text-base text-main tracking-tight leading-none">
+                  {authStatus.instanceName || 'MindSift'}
+                </span>
+                <span className="text-[9px] text-muted font-mono leading-tight mt-0.5">v0.1</span>
+              </div>
               <span className="text-[11px] font-semibold text-accent bg-accent/15 px-1.5 py-0.5 rounded-md">
                 {activeTabLabelMap[activeTab]}
               </span>
@@ -694,9 +709,12 @@ export const App: React.FC = () => {
             <div className="w-7 h-7 bg-accent text-on-accent rounded-btn flex items-center justify-center">
               <Brain className="w-4 h-4" />
             </div>
-            <span className="font-bold text-sm sm:text-base text-main tracking-tight leading-none">
-              {authStatus.instanceName || 'MindSift'}
-            </span>
+            <div className="flex flex-col">
+              <span className="font-bold text-sm sm:text-base text-main tracking-tight leading-none">
+                {authStatus.instanceName || 'MindSift'}
+              </span>
+              <span className="text-[10px] text-muted font-mono leading-tight mt-0.5">v0.1</span>
+            </div>
           </div>
 
           {/* Quick-Capture Input Bubble directly in Header (above Tabs) */}
@@ -862,24 +880,6 @@ export const App: React.FC = () => {
               </span>
             </button>
 
-            <button
-              onClick={() => {
-                triggerHaptic(10);
-                setActiveTab('tasks');
-              }}
-              className={`tab-btn ${activeTab === 'tasks' ? 'tab-btn-active' : ''}`}
-            >
-              <CheckSquare className="w-4 h-4" />
-              <span className={`relative inline-flex items-center ${stats.tasksOpenCount > 0 ? 'pr-2' : ''}`}>
-                <span>Aufgaben</span>
-                {stats.tasksOpenCount > 0 && (
-                  <span className="absolute -top-1.5 -right-1 min-w-[15px] h-[15px] px-0.5 rounded-full text-[9px] font-bold leading-none bg-accent text-on-accent flex items-center justify-center shadow-sm pointer-events-none">
-                    {stats.tasksOpenCount}
-                  </span>
-                )}
-              </span>
-            </button>
-
             <button
               onClick={() => {
                 triggerHaptic(10);
@@ -898,6 +898,24 @@ export const App: React.FC = () => {
               </span>
             </button>
 
+            <button
+              onClick={() => {
+                triggerHaptic(10);
+                setActiveTab('tasks');
+              }}
+              className={`tab-btn ${activeTab === 'tasks' ? 'tab-btn-active' : ''}`}
+            >
+              <CheckSquare className="w-4 h-4" />
+              <span className={`relative inline-flex items-center ${stats.tasksOpenCount > 0 ? 'pr-2' : ''}`}>
+                <span>Aufgaben</span>
+                {stats.tasksOpenCount > 0 && (
+                  <span className="absolute -top-1.5 -right-1 min-w-[15px] h-[15px] px-0.5 rounded-full text-[9px] font-bold leading-none bg-accent text-on-accent flex items-center justify-center shadow-sm pointer-events-none">
+                    {stats.tasksOpenCount}
+                  </span>
+                )}
+              </span>
+            </button>
+
             <button
               onClick={() => {
                 triggerHaptic(10);
@@ -950,6 +968,7 @@ export const App: React.FC = () => {
                 onRefreshStats={refreshAll}
                 onOpenDocument={handleOpenDocument}
                 refreshTrigger={refreshRevision}
+                initialSelectedTaskId={selectedTaskId}
               />
             )}
 
@@ -957,7 +976,9 @@ export const App: React.FC = () => {
               <WorkspaceView
                 currentUser={user}
                 initialDocId={selectedDocId}
+                initialBlockId={selectedBlockId}
                 onStatsChange={refreshAll}
+                onOpenTask={handleOpenTask}
               />
             )}
 
@@ -1024,27 +1045,27 @@ export const App: React.FC = () => {
           <span className="text-[10px] leading-tight">Triage</span>
         </button>
 
-        {/* Col 2: Aufgaben */}
+        {/* Col 2: Workspace */}
         <button
           type="button"
           onClick={() => {
             triggerHaptic(10);
-            setActiveTab('tasks');
+            setActiveTab('workspace');
           }}
           className={`min-h-[48px] rounded-xl flex flex-col items-center justify-center gap-0.5 transition-colors relative cursor-pointer active:scale-95 ${
-            activeTab === 'tasks' ? 'text-accent font-semibold' : 'text-muted hover:text-main'
+            activeTab === 'workspace' ? 'text-accent font-semibold' : 'text-muted hover:text-main'
           }`}
-          title="Aufgaben"
+          title="Workspace"
         >
           <div className="relative">
-            <CheckSquare className="w-5 h-5" />
-            {stats.tasksOpenCount > 0 && (
+            <FileText className="w-5 h-5" />
+            {(stats.docsTodosOpenCount ?? 0) > 0 && (
               <span className="absolute -top-1.5 -right-2.5 min-w-[16px] h-[16px] px-1 rounded-full text-[9px] font-bold leading-none bg-accent text-on-accent flex items-center justify-center shadow-xs pointer-events-none">
-                {stats.tasksOpenCount}
+                {stats.docsTodosOpenCount}
               </span>
             )}
           </div>
-          <span className="text-[10px] leading-tight">Aufgaben</span>
+          <span className="text-[10px] leading-tight">Workspace</span>
         </button>
 
         {/* Col 3 (EXACT CENTER): + Quick-Add FAB */}
@@ -1066,27 +1087,27 @@ export const App: React.FC = () => {
           </button>
         </div>
 
-        {/* Col 4: Workspace */}
+        {/* Col 4: Aufgaben */}
         <button
           type="button"
           onClick={() => {
             triggerHaptic(10);
-            setActiveTab('workspace');
+            setActiveTab('tasks');
           }}
           className={`min-h-[48px] rounded-xl flex flex-col items-center justify-center gap-0.5 transition-colors relative cursor-pointer active:scale-95 ${
-            activeTab === 'workspace' ? 'text-accent font-semibold' : 'text-muted hover:text-main'
+            activeTab === 'tasks' ? 'text-accent font-semibold' : 'text-muted hover:text-main'
           }`}
-          title="Workspace"
+          title="Aufgaben"
         >
           <div className="relative">
-            <FileText className="w-5 h-5" />
-            {(stats.docsTodosOpenCount ?? 0) > 0 && (
+            <CheckSquare className="w-5 h-5" />
+            {stats.tasksOpenCount > 0 && (
               <span className="absolute -top-1.5 -right-2.5 min-w-[16px] h-[16px] px-1 rounded-full text-[9px] font-bold leading-none bg-accent text-on-accent flex items-center justify-center shadow-xs pointer-events-none">
-                {stats.docsTodosOpenCount}
+                {stats.tasksOpenCount}
               </span>
             )}
           </div>
-          <span className="text-[10px] leading-tight">Workspace</span>
+          <span className="text-[10px] leading-tight">Aufgaben</span>
         </button>
 
         {/* Col 5: Listen */}

frontend/src/components/UnifiedShareModal.tsx

@@ -24,6 +24,7 @@ export interface UnifiedShareModalProps {
   teams: Team[];
   collaborators: User[];
   allowRoleSelection?: boolean; // Default true (editor vs viewer)
+  fixedPermission?: 'editor' | 'viewer'; // When allowRoleSelection is false, force fixedPermission (default 'viewer' for documents, 'editor' for tasks/lists)
   onAddShare: (targetType: 'team' | 'user', targetId: string, permission: 'editor' | 'viewer') => Promise<void>;
   onRemoveShare: (shareId: string) => Promise<void>;
 }
@@ -40,13 +41,17 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
   teams,
   collaborators,
   allowRoleSelection = true,
+  fixedPermission,
   onAddShare,
   onRemoveShare,
 }) => {
+  const effectiveFixedPerm = fixedPermission || 'viewer';
   const [shareType, setShareType] = useState<'team' | 'user'>('team');
   const [selectedTeamId, setSelectedTeamId] = useState('');
   const [selectedUser, setSelectedUser] = useState<User | null>(null);
-  const [selectedPermission, setSelectedPermission] = useState<'editor' | 'viewer'>('editor');
+  const [selectedPermission, setSelectedPermission] = useState<'editor' | 'viewer'>(
+    allowRoleSelection ? 'editor' : effectiveFixedPerm
+  );
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -63,7 +68,8 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
 
     setLoading(true);
     try {
-      await onAddShare(shareType, targetId, selectedPermission);
+      const permToUse = allowRoleSelection ? selectedPermission : effectiveFixedPerm;
+      await onAddShare(shareType, targetId, permToUse);
       setSelectedTeamId('');
       setSelectedUser(null);
     } catch (err: any) {
@@ -196,7 +202,7 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
                     </option>
                   ))}
                 </select>
-                {allowRoleSelection && (
+                {allowRoleSelection ? (
                   <select
                     value={selectedPermission}
                     onChange={(e) => setSelectedPermission(e.target.value as 'editor' | 'viewer')}
@@ -206,6 +212,20 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
                     <option value="editor" className="bg-panel text-main">Bearbeiten</option>
                     <option value="viewer" className="bg-panel text-main">Nur Lesen</option>
                   </select>
+                ) : (
+                  <span className="inline-flex items-center gap-1 text-[11px] text-muted px-2 py-1 bg-panel rounded border border-border shrink-0 self-center">
+                    {effectiveFixedPerm === 'editor' ? (
+                      <>
+                        <Check className="w-3 h-3 text-accent" />
+                        Bearbeiten
+                      </>
+                    ) : (
+                      <>
+                        <Lock className="w-3 h-3 text-faint" />
+                        Nur Lesen
+                      </>
+                    )}
+                  </span>
                 )}
               </div>
             ) : (
@@ -220,7 +240,7 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
                     placeholder="Benutzer suchen (Name oder @Benutzername)…"
                   />
                 </div>
-                {allowRoleSelection && (
+                {allowRoleSelection ? (
                   <select
                     value={selectedPermission}
                     onChange={(e) => setSelectedPermission(e.target.value as 'editor' | 'viewer')}
@@ -230,6 +250,20 @@ export const UnifiedShareModal: React.FC<UnifiedShareModalProps> = ({
                     <option value="editor" className="bg-panel text-main">Bearbeiten</option>
                     <option value="viewer" className="bg-panel text-main">Nur Lesen</option>
                   </select>
+                ) : (
+                  <span className="inline-flex items-center gap-1 text-[11px] text-muted px-2 py-1 bg-panel rounded border border-border shrink-0 self-center">
+                    {effectiveFixedPerm === 'editor' ? (
+                      <>
+                        <Check className="w-3 h-3 text-accent" />
+                        Bearbeiten
+                      </>
+                    ) : (
+                      <>
+                        <Lock className="w-3 h-3 text-faint" />
+                        Nur Lesen
+                      </>
+                    )}
+                  </span>
                 )}
               </div>
             )}

frontend/src/features/capture/InstantCaptureBar.tsx

@@ -52,6 +52,8 @@ export const InstantCaptureBar: React.FC<InstantCaptureBarProps> = ({
   const inputRef = useRef<HTMLTextAreaElement>(null);
   const containerRef = useRef<HTMLFormElement>(null);
   const recognitionRef = useRef<any>(null);
+  const baseVoiceTextRef = useRef('');
+  const hasVoiceInputRef = useRef(false);
 
   const adjustHeight = (el?: HTMLTextAreaElement | null) => {
     const targetEl = el || inputRef.current;
@@ -131,6 +133,9 @@ export const InstantCaptureBar: React.FC<InstantCaptureBarProps> = ({
     }
 
     try {
+      baseVoiceTextRef.current = content.replace(/\s*\[…\]$/, '').trim();
+      hasVoiceInputRef.current = true;
+
       const recognition = new SpeechRecognition();
       recognition.lang = 'de-DE';
       recognition.continuous = false;
@@ -146,10 +151,8 @@ export const InstantCaptureBar: React.FC<InstantCaptureBarProps> = ({
         for (let i = 0; i < event.results.length; i++) {
           transcript += event.results[i][0].transcript;
         }
-        setContent((prev) => {
-          const base = prev.replace(/\s*\[…\]$/, '').trim();
-          return base ? `${base} ${transcript}` : transcript;
-        });
+        const base = baseVoiceTextRef.current;
+        setContent(base ? `${base} ${transcript}` : transcript);
       };
 
       recognition.onerror = () => {
@@ -180,7 +183,8 @@ export const InstantCaptureBar: React.FC<InstantCaptureBarProps> = ({
       overrideListId || targetListId || (lists.length > 0 ? lists[0].id : '');
     const capturedPriority = priority;
     const capturedDueDate = dueDate;
-    const capturedSource = isListening ? 'voice' : 'manual';
+    const capturedSource = hasVoiceInputRef.current || isListening ? 'voice' : 'manual';
+    hasVoiceInputRef.current = false;
 
     // Optimistically clear input immediately so the UI feels instant (<10ms) in all browsers
     setContent('');

frontend/src/features/lists/SharedListsView.tsx

@@ -8,6 +8,7 @@ import {
   Sparkles,
   X,
   Hash,
+  ShoppingCart,
 } from 'lucide-react';
 import { ListItem, SharedList, ListShare, Team, User, WSMessage } from '../../lib/types';
 import { api, buildWebSocketURL, triggerHaptic, createRealtimeConnection, RealtimeTransport } from '../../lib/api';
@@ -84,6 +85,8 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
   const [newItemText, setNewItemText] = useState('');
   const [newItemQty, setNewItemQty] = useState('');
   const [isSubmittingItem, setIsSubmittingItem] = useState(false);
+  const [editingQtyItemId, setEditingQtyItemId] = useState<string | null>(null);
+  const [editingQtyValue, setEditingQtyValue] = useState('');
 
   const [wsConnected, setWsConnected] = useState(false);
   const [realtimeTransport, setRealtimeTransport] = useState<RealtimeTransport>('none');
@@ -173,7 +176,7 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
               return { ...l, items: deduplicateItems([newItem, ...l.items]) };
             })
           );
-        } else if (msg.event === 'ITEM_TOGGLED' && msgListId) {
+        } else if ((msg.event === 'ITEM_TOGGLED' || msg.event === 'ITEM_UPDATED') && msgListId) {
           const updatedItem: ListItem = msg.payload;
           setLists((prev) =>
             prev.map((l) => {
@@ -272,6 +275,26 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
     }
   };
 
+  const handleSaveQuantity = async (itemId: string, quantity: string) => {
+    setEditingQtyItemId(null);
+    if (!activeList) return;
+    const trimmed = quantity.trim();
+    try {
+      const updated = await api.updateListItem(activeList.id, itemId, { quantity: trimmed });
+      setLists((prev) =>
+        prev.map((l) => {
+          if (l.id !== activeList.id) return l;
+          return {
+            ...l,
+            items: l.items.map((i) => (i.id === itemId ? { ...i, quantity: updated.quantity } : i)),
+          };
+        })
+      );
+    } catch (err: any) {
+      console.error('Fehler beim Aktualisieren der Menge', err);
+    }
+  };
+
   const handleToggleItem = async (item: ListItem) => {
     if (!activeList) return;
     triggerHaptic(10);
@@ -953,41 +976,61 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
       </div>
 
       {showNewListModal && (
-        <form
-          onSubmit={handleCreateList}
-          className="p-2 panel-surface flex flex-wrap items-center gap-2"
-        >
-          <div className="flex items-center gap-1.5">
-            {['🛒', '🏔️', '🍕', '🎉', '🧰', '🎁'].map((ic) => (
+        <div className="fixed inset-0 !m-0 modal-overlay z-50 flex items-center justify-center p-4">
+          <div className="w-full max-w-sm panel-surface shadow-panel p-4 space-y-3">
+            <div className="flex items-center justify-between border-b border-border pb-2">
+              <h3 className="text-sm font-semibold text-main flex items-center gap-1.5">
+                <ShoppingCart className="w-4 h-4 text-accent" />
+                <span>Neue Einkaufsliste erstellen</span>
+              </h3>
               <button
-                key={ic}
                 type="button"
-                onClick={() => setNewListIcon(ic)}
-                className={`w-9 h-9 flex items-center justify-center rounded-btn transition-colors ${
-                  newListIcon === ic
-                    ? 'bg-accent/20 border border-accent text-accent'
-                    : 'bg-canvas hover:bg-panel-elevated border border-border'
-                }`}
+                onClick={() => setShowNewListModal(false)}
+                className="text-muted hover:text-main"
               >
-                {ic}
+                <X className="w-4 h-4" />
               </button>
-            ))}
+            </div>
+
+            <form onSubmit={handleCreateList} className="space-y-3">
+              <div>
+                <label className="block text-xs text-muted mb-1">Titel der Liste</label>
+                <div className="flex items-center gap-1.5">
+                  <input
+                    type="text"
+                    value={newListIcon}
+                    onChange={(e) => setNewListIcon(e.target.value)}
+                    maxLength={2}
+                    className="w-10 h-8 text-center input-field text-sm"
+                    title="Icon (Emoji)"
+                  />
+                  <input
+                    type="text"
+                    value={newListTitle}
+                    onChange={(e) => setNewListTitle(e.target.value)}
+                    placeholder="z.B. Supermarkt, Baumarkt, Drogerie"
+                    autoFocus
+                    required
+                    className="flex-1 h-8 input-field px-2.5 text-xs"
+                  />
+                </div>
+              </div>
+
+              <div className="flex items-center justify-end gap-2 pt-2 border-t border-border">
+                <button
+                  type="button"
+                  onClick={() => setShowNewListModal(false)}
+                  className="btn-action h-7 px-3 text-xs"
+                >
+                  Abbrechen
+                </button>
+                <button type="submit" className="btn-primary h-7 px-3 text-xs">
+                  Erstellen
+                </button>
+              </div>
+            </form>
           </div>
-          <input
-            type="text"
-            value={newListTitle}
-            onChange={(e) => setNewListTitle(e.target.value)}
-            placeholder="Titel der Liste (z. B. Baumarkt, Drogerie, Camping)…"
-            className="flex-1 h-9 px-3 input-field text-sm"
-            autoFocus
-          />
-          <button
-            type="submit"
-            className="btn-primary h-9 px-4 text-xs sm:text-sm"
-          >
-            Liste erstellen
-          </button>
-        </form>
+        </div>
       )}
 
       {/* Active Shared List View */}
@@ -1064,8 +1107,8 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
               <input
                 type="text"
                 value={newItemQty}
-                onChange={(e) => setNewItemQty(e.target.value)}
-                placeholder="Menge (z.B. 2x)"
+                onChange={(e) => setNewItemQty(e.target.value.replace(/[^0-9.,xX]/g, ''))}
+                placeholder="Menge (z.B. 2)"
                 className="flex-1 sm:flex-none sm:w-28 h-9 sm:h-7 px-2.5 sm:px-2 input-field text-xs"
               />
               <button
@@ -1175,10 +1218,45 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
                               {displayContent}
                             </span>
 
-                            {item.quantity && (
-                              <span className="badge-accent">
-                                {item.quantity}
-                              </span>
+                            {editingQtyItemId === item.id ? (
+                              <div className="flex items-center gap-1" onClick={(e) => e.stopPropagation()}>
+                                <input
+                                  type="text"
+                                  autoFocus
+                                  value={editingQtyValue}
+                                  onChange={(e) => setEditingQtyValue(e.target.value.replace(/[^0-9.,xX]/g, ''))}
+                                  onKeyDown={async (e) => {
+                                    if (e.key === 'Enter') {
+                                      e.preventDefault();
+                                      await handleSaveQuantity(item.id, editingQtyValue);
+                                    } else if (e.key === 'Escape') {
+                                      setEditingQtyItemId(null);
+                                    }
+                                  }}
+                                  onBlur={async () => {
+                                    await handleSaveQuantity(item.id, editingQtyValue);
+                                  }}
+                                  className="w-16 h-6 px-1.5 text-xs input-field font-semibold text-accent text-center"
+                                  placeholder="Menge"
+                                />
+                              </div>
+                            ) : (
+                              <button
+                                type="button"
+                                onClick={(e) => {
+                                  e.stopPropagation();
+                                  setEditingQtyItemId(item.id);
+                                  setEditingQtyValue(item.quantity || '');
+                                }}
+                                className={`text-xs px-2 py-0.5 rounded-full transition-colors ${
+                                  item.quantity
+                                    ? 'badge-accent cursor-pointer hover:brightness-125'
+                                    : 'opacity-0 group-hover:opacity-60 hover:!opacity-100 text-muted hover:text-accent border border-dashed border-border/70 hover:border-accent text-[11px]'
+                                }`}
+                                title="Menge bearbeiten"
+                              >
+                                {item.quantity || '+ Menge'}
+                              </button>
                             )}
 
                             {cat && !group.label && (
@@ -1253,8 +1331,45 @@ export const SharedListsView: React.FC<SharedListsViewProps> = ({ onRefreshGloba
                           {displayContent}
                         </span>
 
-                        {item.quantity && (
-                          <span className="text-xs text-faint">({item.quantity})</span>
+                        {editingQtyItemId === item.id ? (
+                          <div className="flex items-center gap-1" onClick={(e) => e.stopPropagation()}>
+                            <input
+                              type="text"
+                              autoFocus
+                              value={editingQtyValue}
+                              onChange={(e) => setEditingQtyValue(e.target.value.replace(/[^0-9.,xX]/g, ''))}
+                              onKeyDown={async (e) => {
+                                if (e.key === 'Enter') {
+                                  e.preventDefault();
+                                  await handleSaveQuantity(item.id, editingQtyValue);
+                                } else if (e.key === 'Escape') {
+                                  setEditingQtyItemId(null);
+                                }
+                              }}
+                              onBlur={async () => {
+                                await handleSaveQuantity(item.id, editingQtyValue);
+                              }}
+                              className="w-16 h-6 px-1.5 text-xs input-field font-semibold text-accent text-center"
+                              placeholder="Menge"
+                            />
+                          </div>
+                        ) : (
+                          <button
+                            type="button"
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              setEditingQtyItemId(item.id);
+                              setEditingQtyValue(item.quantity || '');
+                            }}
+                            className={`text-xs px-1.5 py-0.5 rounded transition-colors ${
+                              item.quantity
+                                ? 'text-faint hover:text-main cursor-pointer'
+                                : 'opacity-0 group-hover:opacity-60 text-faint hover:text-main text-[11px]'
+                            }`}
+                            title="Menge bearbeiten"
+                          >
+                            {item.quantity ? `(${item.quantity})` : '+ Menge'}
+                          </button>
                         )}
                       </div>
 

frontend/src/features/settings/UserSettingsView.tsx

@@ -49,6 +49,7 @@ export const UserSettingsView: React.FC<UserSettingsViewProps> = ({
   const [newPassword, setNewPassword] = useState('');
   const [profileMsg, setProfileMsg] = useState<{ type: 'ok' | 'err'; text: string } | null>(null);
   const [savingProfile, setSavingProfile] = useState(false);
+  const [revokingSessions, setRevokingSessions] = useState(false);
   const [isProcessingAvatar, setIsProcessingAvatar] = useState(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
 
@@ -155,6 +156,21 @@ export const UserSettingsView: React.FC<UserSettingsViewProps> = ({
     }
   };
 
+  const handleRevokeAllSessions = async () => {
+    if (!window.confirm('Möchtest du wirklich alle aktiven Sitzungen auf allen Geräten beenden? Du wirst dabei auch auf diesem Gerät abgemeldet.')) {
+      return;
+    }
+    setRevokingSessions(true);
+    try {
+      await api.revokeAllSessions();
+      await api.logout();
+      window.location.reload();
+    } catch (err: any) {
+      setProfileMsg({ type: 'err', text: err.message || 'Fehler beim Beenden der Sitzungen' });
+      setRevokingSessions(false);
+    }
+  };
+
   // --- Handlers: Alarms ---
   const handleSaveAlarms = async (e: React.FormEvent) => {
     e.preventDefault();
@@ -530,6 +546,32 @@ export const UserSettingsView: React.FC<UserSettingsViewProps> = ({
                   </button>
                 </div>
               </form>
+
+              {/* Sessions & Security */}
+              <div className="pt-5 border-t border-border space-y-3">
+                <div>
+                  <h3 className="text-xs font-bold text-main">Aktive Sitzungen & Sicherheit</h3>
+                  <p className="text-[11px] text-muted">
+                    Sitzungen werden durch kryptografische JWTs geschützt. Bei einer Passwortänderung werden alle alten Sitzungen automatisch ungültig.
+                  </p>
+                </div>
+                <div className="flex flex-col sm:flex-row sm:items-center justify-between gap-3 p-3.5 rounded-card border border-border bg-canvas">
+                  <div className="text-xs">
+                    <p className="font-semibold text-main">Alle Sitzungen sofort beenden</p>
+                    <p className="text-[11px] text-faint">
+                      Invalidiert alle ausgestellten Tokens auf allen Geräten und Browsern.
+                    </p>
+                  </div>
+                  <button
+                    type="button"
+                    onClick={handleRevokeAllSessions}
+                    disabled={revokingSessions}
+                    className="btn-danger h-8 px-3 text-xs shrink-0 cursor-pointer"
+                  >
+                    {revokingSessions ? 'Beende…' : 'Alle Sitzungen beenden'}
+                  </button>
+                </div>
+              </div>
             </div>
           )}
 

frontend/src/features/triage/TaskDetailModal.tsx

@@ -15,9 +15,11 @@ import {
   ChevronRight,
   Folder,
   Webhook,
+  Lock,
 } from 'lucide-react';
 import { Thought, SubTask, TaskList, KanbanColumn } from '../../lib/types';
 import { triggerHaptic } from '../../lib/api';
+import { MarkdownViewer } from '../../lib/markdown';
 
 interface TaskDetailModalProps {
   task: Thought | null;
@@ -36,7 +38,9 @@ interface TaskDetailModalProps {
   onAddSubtask: (task: Thought, title: string) => Promise<void>;
   onDeleteSubtask: (task: Thought, subtaskId: string) => Promise<void>;
   onConvertToDoc: (task: Thought) => void;
+  onOpenDocument?: (docId: string, blockId?: string) => void;
   onDeleteTask: (taskId: string) => void;
+  readOnly?: boolean; // Task belongs to a list shared with "viewer" permission
 }
 
 export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
@@ -56,7 +60,9 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
   onAddSubtask,
   onDeleteSubtask,
   onConvertToDoc,
+  onOpenDocument,
   onDeleteTask,
+  readOnly = false,
 }) => {
   if (!isOpen || !task) return null;
 
@@ -173,6 +179,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
         <div className="flex items-center justify-between px-4 py-3 border-b border-border bg-panel">
           <div className="flex items-center gap-2 min-w-0">
             <button
+              disabled={readOnly}
               onClick={() => {
                 triggerHaptic(15);
                 const nextState = !task.isCompleted;
@@ -181,7 +188,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                 const nextKanban = nextState ? (doneCol ? doneCol.id : 'done') : (todoCol ? todoCol.id : 'todo');
                 onUpdateStatus(task, nextKanban);
               }}
-              className={`w-5 h-5 checkbox-square flex items-center justify-center flex-shrink-0 transition-colors border ${
+              className={`w-5 h-5 checkbox-square flex items-center justify-center flex-shrink-0 transition-colors border disabled:cursor-default ${
                 task.isCompleted
                   ? 'bg-status-ok border-status-ok text-on-accent'
                   : 'border-strong hover:border-accent text-transparent'
@@ -191,8 +198,14 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
               <Check className="w-3.5 h-3.5 stroke-[3]" />
             </button>
             <span className="text-xs font-semibold text-main truncate">
-              {task.isCompleted ? 'Erledigte Aufgabe' : 'Aufgabe bearbeiten'}
+              {readOnly ? 'Aufgabe ansehen' : task.isCompleted ? 'Erledigte Aufgabe' : 'Aufgabe bearbeiten'}
             </span>
+            {readOnly && (
+              <span className="px-1.5 py-0.5 border border-border bg-canvas text-muted rounded-btn text-[10px] font-medium flex items-center gap-1 flex-shrink-0">
+                <Lock className="w-2.5 h-2.5 text-faint" />
+                <span>Nur Lesen</span>
+              </span>
+            )}
             {task.source?.toLowerCase() === 'webhook' && (
               <span className="px-1.5 py-0.5 border border-border bg-canvas text-muted rounded-btn text-[10px] font-medium flex items-center gap-1 flex-shrink-0">
                 <Webhook className="w-2.5 h-2.5 text-accent" />
@@ -202,18 +215,36 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
           </div>
 
           <div className="flex items-center gap-1.5">
-            <button
-              type="button"
-              onClick={() => {
-                onClose();
-                onConvertToDoc(task);
-              }}
-              title="Als Dokument / Notiz vertiefen"
-              className="btn-action min-h-[38px] sm:min-h-0 h-9 sm:h-7 px-2.5 sm:px-2 text-xs flex items-center gap-1.5"
-            >
-              <FileText className="w-4 h-4 sm:w-3.5 sm:h-3.5 text-accent" />
-              <span className="hidden sm:inline">Als Notiz vertiefen</span>
-            </button>
+            {(task.convertedType === 'document_block' || task.docId) ? (
+              <button
+                type="button"
+                onClick={() => {
+                  onClose();
+                  const docId = task.docId || (task.convertedRefId ? task.convertedRefId.split(':')[0] : '');
+                  const blockId = task.blockId || (task.convertedRefId ? task.convertedRefId.split(':')[1] : '');
+                  if (docId && onOpenDocument) onOpenDocument(docId, blockId);
+                }}
+                title="Zur verlinkten Notiz springen"
+                className="btn-primary min-h-[38px] sm:min-h-0 h-9 sm:h-7 px-2.5 sm:px-2 text-xs flex items-center gap-1.5 font-semibold"
+              >
+                <FileText className="w-4 h-4 sm:w-3.5 sm:h-3.5" />
+                <span>In Notiz öffnen</span>
+              </button>
+            ) : !readOnly && (
+              <button
+                type="button"
+                onClick={() => {
+                  onClose();
+                  onConvertToDoc(task);
+                }}
+                title="Als Dokument / Notiz vertiefen"
+                className="btn-action min-h-[38px] sm:min-h-0 h-9 sm:h-7 px-2.5 sm:px-2 text-xs flex items-center gap-1.5"
+              >
+                <FileText className="w-4 h-4 sm:w-3.5 sm:h-3.5 text-accent" />
+                <span className="hidden sm:inline">Als Notiz vertiefen</span>
+              </button>
+            )}
+            {!readOnly && (
             <button
               type="button"
               onClick={() => {
@@ -228,6 +259,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
               <Trash2 className="w-4 h-4 sm:w-3.5 sm:h-3.5" />
               <span className="sm:hidden font-medium">Löschen</span>
             </button>
+            )}
             <button
               type="button"
               onClick={onClose}
@@ -239,8 +271,8 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
           </div>
         </div>
 
-        {/* Scrollable Body */}
-        <div className="p-4 overflow-y-auto space-y-4 flex-1">
+        {/* Scrollable Body (all controls disabled for read-only shares) */}
+        <fieldset disabled={readOnly} className="p-4 overflow-y-auto space-y-4 flex-1 min-w-0 border-0 m-0">
           {/* Task Title */}
           <div>
             {isEditingTitle ? (
@@ -283,9 +315,11 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
               </div>
             ) : (
               <div
-                onClick={() => setIsEditingTitle(true)}
-                className="group cursor-pointer p-2 rounded-card hover:bg-panel transition-colors border border-transparent hover:border-border"
-                title="Klicken zum Bearbeiten des Titels"
+                onClick={() => !readOnly && setIsEditingTitle(true)}
+                className={`group p-2 rounded-card transition-colors border border-transparent ${
+                  readOnly ? '' : 'cursor-pointer hover:bg-panel hover:border-border'
+                }`}
+                title={readOnly ? undefined : 'Klicken zum Bearbeiten des Titels'}
               >
                 <h2
                   className={`text-base font-semibold break-words leading-snug ${
@@ -294,9 +328,11 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                 >
                   {task.content}
                 </h2>
-                <span className="text-[10px] text-muted opacity-0 group-hover:opacity-100 transition-opacity">
-                  Klicken zum Umbenennen
-                </span>
+                {!readOnly && (
+                  <span className="text-[10px] text-muted opacity-0 group-hover:opacity-100 transition-opacity">
+                    Klicken zum Umbenennen
+                  </span>
+                )}
               </div>
             )}
           </div>
@@ -495,15 +531,18 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                     className="inline-flex items-center gap-1 px-2 py-0.5 rounded-pill bg-panel border border-border text-xs text-main"
                   >
                     <span>#{tag}</span>
-                    <button
-                      type="button"
-                      onClick={() => handleRemoveTag(tag)}
-                      className="text-muted hover:text-status-err"
-                    >
-                      <X className="w-3 h-3" />
-                    </button>
+                    {!readOnly && (
+                      <button
+                        type="button"
+                        onClick={() => handleRemoveTag(tag)}
+                        className="text-muted hover:text-status-err"
+                      >
+                        <X className="w-3 h-3" />
+                      </button>
+                    )}
                   </span>
                 ))}
+              {!readOnly && (
               <form onSubmit={handleAddTagSubmit} className="inline-flex items-center gap-1">
                 <input
                   type="text"
@@ -513,6 +552,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                   className="h-6 w-24 px-1.5 text-xs input-field"
                 />
               </form>
+              )}
             </div>
           </div>
 
@@ -567,6 +607,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                         {st.title}
                       </span>
                     </div>
+                    {!readOnly && (
                     <button
                       type="button"
                       onClick={() => onDeleteSubtask(task, st.id)}
@@ -574,12 +615,14 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                     >
                       <Trash2 className="w-3 h-3" />
                     </button>
+                    )}
                   </div>
                 ))}
               </div>
             )}
 
             {/* Inline add subtask form */}
+            {!readOnly && (
             <form onSubmit={handleAddSubtaskSubmit} className="flex items-center gap-1.5">
               <input
                 type="text"
@@ -597,6 +640,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                 <span>Hinzufügen</span>
               </button>
             </form>
+            )}
           </div>
 
           {/* Notes Section */}
@@ -606,7 +650,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
                 <FileText className="w-3.5 h-3.5 text-accent" />
                 <span>Detailnotizen:</span>
               </label>
-              {!isEditingNotes && task.notes && (
+              {!readOnly && !isEditingNotes && task.notes && (
                 <button
                   type="button"
                   onClick={() => {
@@ -653,14 +697,19 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
             ) : task.notes ? (
               <div
                 onClick={() => {
+                  if (readOnly) return;
                   setNotesDraft(task.notes || '');
                   setIsEditingNotes(true);
                 }}
-                className="p-3 bg-canvas border border-border rounded-card text-xs text-muted leading-relaxed whitespace-pre-wrap cursor-pointer hover:border-strong transition-colors"
-                title="Klicken zum Bearbeiten"
+                className={`p-3 bg-canvas border border-border rounded-card text-xs text-muted leading-relaxed transition-colors ${
+                  readOnly ? '' : 'cursor-pointer hover:border-strong'
+                }`}
+                title={readOnly ? undefined : 'Klicken zum Bearbeiten'}
               >
-                {task.notes}
+                <MarkdownViewer content={task.notes} />
               </div>
+            ) : readOnly ? (
+              <p className="text-xs text-faint">Keine Detailnotizen.</p>
             ) : (
               <button
                 type="button"
@@ -675,7 +724,7 @@ export const TaskDetailModal: React.FC<TaskDetailModalProps> = ({
               </button>
             )}
           </div>
-        </div>
+        </fieldset>
 
         {/* Modal Footer */}
         <div className="flex items-center justify-between px-4 py-2.5 border-t border-border bg-panel">

frontend/src/features/triage/TasksView.tsx

@@ -46,8 +46,9 @@ const getInitials = (name?: string): string => {
 interface TasksViewProps {
   currentUser?: User | null;
   onRefreshStats: () => void;
-  onOpenDocument: (docId: string) => void;
+  onOpenDocument: (docId: string, blockId?: string) => void;
   refreshTrigger?: number;
+  initialSelectedTaskId?: string | null;
 }
 
 export const TasksView: React.FC<TasksViewProps> = ({
@@ -55,6 +56,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
   onRefreshStats,
   onOpenDocument,
   refreshTrigger = 0,
+  initialSelectedTaskId,
 }) => {
   const [viewMode, setViewMode] = useState<'list' | 'kanban'>('list');
   const [filter, setFilter] = useState<'open' | 'done' | 'discarded'>('open');
@@ -101,6 +103,18 @@ export const TasksView: React.FC<TasksViewProps> = ({
   // Detail modal state
   const [detailTaskId, setDetailTaskId] = useState<string | null>(null);
   const [showDetailModal, setShowDetailModal] = useState(false);
+  const [extraTask, setExtraTask] = useState<Thought | null>(null);
+
+  useEffect(() => {
+    if (initialSelectedTaskId) {
+      setDetailTaskId(initialSelectedTaskId);
+      setShowDetailModal(true);
+      setFilter('open');
+      api.getThought(initialSelectedTaskId).then((th) => {
+        if (th) setExtraTask(th);
+      }).catch(() => {});
+    }
+  }, [initialSelectedTaskId]);
 
   // Manage columns modal state
   const [showManageColumnsModal, setShowManageColumnsModal] = useState(false);
@@ -215,6 +229,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
 
   const safeTaskLists = Array.isArray(taskLists) ? taskLists : [];
   const currentSelectedList = safeTaskLists.find((l) => l.id === selectedListId);
+  const isSelectedListReadOnly = currentSelectedList?.permission === 'viewer';
+  const isTaskReadOnly = (task: Thought) =>
+    !!task.taskListId && safeTaskLists.find((l) => l.id === task.taskListId)?.permission === 'viewer';
 
   // Active Kanban Columns (from selected list, or global custom, or default)
   const activeColumns: KanbanColumn[] = useMemo(() => {
@@ -243,8 +260,8 @@ export const TasksView: React.FC<TasksViewProps> = ({
 
   const detailTask = useMemo(() => {
     if (!detailTaskId) return null;
-    return tasks.find((t) => t.id === detailTaskId) || null;
-  }, [detailTaskId, tasks]);
+    return tasks.find((t) => t.id === detailTaskId) || (extraTask?.id === detailTaskId ? extraTask : null);
+  }, [detailTaskId, tasks, extraTask]);
 
   const safeTeams = Array.isArray(teams) ? teams : [];
   const safeCollaborators = Array.isArray(collaborators) ? collaborators : [];
@@ -588,6 +605,10 @@ export const TasksView: React.FC<TasksViewProps> = ({
 
   const handleTaskDragStart = (e: React.DragEvent, task: Thought) => {
     e.stopPropagation();
+    if (isTaskReadOnly(task)) {
+      e.preventDefault();
+      return;
+    }
     e.dataTransfer.setData('application/mindsift-task-id', task.id);
     e.dataTransfer.setData('text/plain', task.id);
     e.dataTransfer.effectAllowed = 'move';
@@ -851,7 +872,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
 
   useEffect(() => {
     setPrimaryAction(() => {
-      setMobileCreateListId(selectedListId === 'all' ? '' : selectedListId);
+      setMobileCreateListId(selectedListId === 'all' || isSelectedListReadOnly ? '' : selectedListId);
       setShowMobileCreateModal(true);
     });
 
@@ -862,7 +883,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
         icon: <Plus className="w-4 h-4" />,
         variant: 'accent',
         onClick: () => {
-          setMobileCreateListId(selectedListId === 'all' ? '' : selectedListId);
+          setMobileCreateListId(selectedListId === 'all' || isSelectedListReadOnly ? '' : selectedListId);
           setShowMobileCreateModal(true);
         },
       },
@@ -951,7 +972,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
       },
     ];
 
-    if (viewMode === 'kanban') {
+    if (viewMode === 'kanban' && !isSelectedListReadOnly) {
       viewItems.push({
         id: 'manage-columns',
         label: 'Kanban-Spalten verwalten',
@@ -1016,6 +1037,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
     kanbanTasks.length,
     safeTaskLists,
     currentSelectedList,
+    isSelectedListReadOnly,
     setPrimaryAction,
     setGroups,
   ]);
@@ -1057,13 +1079,14 @@ export const TasksView: React.FC<TasksViewProps> = ({
   // Clean Task Row in List View
   const renderTaskRow = (task: Thought) => {
     const isCompleted = task.isCompleted;
+    const readOnly = isTaskReadOnly(task);
     const isDragging = draggingTaskId === task.id;
     const isTarget = dragOverTaskTarget?.taskId === task.id;
 
     return (
       <div
         key={task.id}
-        draggable
+        draggable={!readOnly}
         onDragStart={(e) => handleTaskDragStart(e, task)}
         onDragEnd={() => {
           setDraggingTaskId(null);
@@ -1077,7 +1100,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
           setDetailTaskId(task.id);
           setShowDetailModal(true);
         }}
-        className={`px-3.5 py-3.5 sm:px-3 sm:py-2.5 flex items-center justify-between gap-3 transition-colors hover:bg-panel-hover group border-b border-border last:border-b-0 relative cursor-pointer cursor-grab active:cursor-grabbing select-none ${
+        className={`px-3.5 py-3.5 sm:px-3 sm:py-2.5 flex items-center justify-between gap-3 transition-colors hover:bg-panel-hover group border-b border-border last:border-b-0 relative cursor-pointer select-none ${
+          readOnly ? '' : 'cursor-grab active:cursor-grabbing'
+        } ${
           isCompleted ? 'opacity-65' : ''
         } ${isDragging ? 'opacity-30 border border-dashed border-accent/40' : ''}`}
       >
@@ -1094,17 +1119,18 @@ export const TasksView: React.FC<TasksViewProps> = ({
           <button
             type="button"
             draggable={false}
+            disabled={readOnly}
             onMouseDown={(e) => e.stopPropagation()}
             onClick={(e) => {
               e.stopPropagation();
               handleToggleDone(task);
             }}
-            className={`w-5 h-5 sm:w-4 sm:h-4 checkbox-square flex items-center justify-center flex-shrink-0 transition-colors border ${
+            className={`w-5 h-5 sm:w-4 sm:h-4 checkbox-square flex items-center justify-center flex-shrink-0 transition-colors border disabled:cursor-default ${
               isCompleted
                 ? 'bg-status-ok border-status-ok text-on-accent'
                 : 'border-strong hover:border-accent text-transparent'
             }`}
-            title={isCompleted ? 'Als offen markieren' : 'Als erledigt abhaken'}
+            title={readOnly ? 'Nur Lesen' : isCompleted ? 'Als offen markieren' : 'Als erledigt abhaken'}
           >
             <Check className="w-3.5 h-3.5 sm:w-3 sm:h-3 stroke-[3]" />
           </button>
@@ -1135,9 +1161,27 @@ export const TasksView: React.FC<TasksViewProps> = ({
               className="flex flex-wrap items-center gap-1.5 pt-0.5 empty:hidden"
               onClick={(e) => e.stopPropagation()}
             >
+              {(task.convertedType === 'document_block' || task.docId) && (
+                <button
+                  type="button"
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    const docId = task.docId || (task.convertedRefId ? task.convertedRefId.split(':')[0] : '');
+                    const blockId = task.blockId || (task.convertedRefId ? task.convertedRefId.split(':')[1] : '');
+                    if (docId) onOpenDocument(docId, blockId);
+                  }}
+                  className="h-5 px-1.5 text-[10px] rounded-btn border border-accent/40 bg-accent/10 text-accent hover:bg-accent/20 cursor-pointer flex items-center gap-1 font-medium"
+                  title="In Notiz an der passenden Stelle öffnen"
+                >
+                  <FileText className="w-2.5 h-2.5" />
+                  <span>In Notiz</span>
+                </button>
+              )}
+
               {/* Kanban status selector pill (Desktop only - on mobile done via TaskDetailModal) */}
               <select
                 value={task.kanbanStatus || (isCompleted ? 'done' : 'todo')}
+                disabled={readOnly}
                 onChange={(e) => handleSetKanbanStatus(task, e.target.value)}
                 className="hidden sm:inline-block h-5 px-1.5 text-[10px] rounded-btn border border-border bg-panel text-muted hover:text-main cursor-pointer"
                 title="Status / Zustand ändern"
@@ -1153,8 +1197,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
               {task.priority === 'urgent' && (
                 <button
                   type="button"
+                  disabled={readOnly}
                   onClick={() => handleCyclePriority(task)}
-                  className="badge-accent text-[10px] cursor-pointer hover:opacity-85"
+                  className="badge-accent text-[10px] cursor-pointer hover:opacity-85 disabled:cursor-default"
                   title="Klicken zum Ändern der Priorität (Dringend -> Normal)"
                 >
                   🔥 Dringend
@@ -1163,8 +1208,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
               {task.priority === 'high' && (
                 <button
                   type="button"
+                  disabled={readOnly}
                   onClick={() => handleCyclePriority(task)}
-                  className="px-1.5 py-0.5 border border-status-warn text-status-warn rounded-btn text-[10px] font-medium cursor-pointer hover:opacity-85"
+                  className="px-1.5 py-0.5 border border-status-warn text-status-warn rounded-btn text-[10px] font-medium cursor-pointer hover:opacity-85 disabled:cursor-default"
                   title="Klicken zum Ändern der Priorität (Wichtig -> Dringend)"
                 >
                   ⚠️ Wichtig
@@ -1235,10 +1281,12 @@ export const TasksView: React.FC<TasksViewProps> = ({
               setShowDetailModal(true);
             }}
             className="text-faint hover:text-accent p-1.5 transition-colors"
-            title="Aufgabe bearbeiten"
+            title={readOnly ? 'Aufgabe ansehen' : 'Aufgabe bearbeiten'}
           >
-            <Edit3 className="w-3.5 h-3.5" />
+            {readOnly ? <Lock className="w-3.5 h-3.5" /> : <Edit3 className="w-3.5 h-3.5" />}
           </button>
+          {!readOnly && (
+          <>
           <button
             type="button"
             draggable={false}
@@ -1257,6 +1305,8 @@ export const TasksView: React.FC<TasksViewProps> = ({
           >
             <Trash2 className="w-3.5 h-3.5" />
           </button>
+          </>
+          )}
         </div>
       </div>
     );
@@ -1448,7 +1498,17 @@ export const TasksView: React.FC<TasksViewProps> = ({
         )}
       </div>
 
+      {isSelectedListReadOnly && (
+        <div className="flex items-center gap-2 p-2.5 rounded-btn bg-panel-elevated border border-border text-xs text-muted">
+          <Lock className="w-3.5 h-3.5 text-faint shrink-0" />
+          <span>
+            Diese Liste wurde von {currentSelectedList?.ownerName || 'einem anderen Benutzer'} nur zum Lesen freigegeben.
+          </span>
+        </div>
+      )}
+
       {/* Quick Add Task Input (Desktop only - on mobile, tapping the bottom '+' FAB opens mobile create sheet) */}
+      {!isSelectedListReadOnly && (
       <form
         onSubmit={handleQuickAddTask}
         className="hidden sm:flex items-center gap-1.5 panel-surface p-2 sm:p-1.5"
@@ -1483,6 +1543,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
           </button>
         </div>
       </form>
+      )}
 
       {/* Mobile Active Filter Badge Banner (minimal and clean) */}
       {(selectedTag || groupBy !== 'none' || sortBy !== 'custom') && (
@@ -1567,6 +1628,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
         {/* Group By & Sort By Dropdowns & Manage Columns button */}
         <div className="flex items-center gap-2 flex-shrink-0 ml-auto">
           {viewMode === 'kanban' ? (
+            !isSelectedListReadOnly && (
             <button
               onClick={() => setShowManageColumnsModal(true)}
               className="btn-action h-7 px-2.5 text-xs flex items-center gap-1.5"
@@ -1575,6 +1637,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
               <Columns className="w-3.5 h-3.5 text-accent" />
               <span>Spalten anpassen</span>
             </button>
+            )
           ) : (
             <>
               {/* Group By */}
@@ -1971,17 +2034,17 @@ export const TasksView: React.FC<TasksViewProps> = ({
             targetName: sh.targetName || (sh.targetType === 'team' ? 'Gruppe' : sh.email || 'Benutzer'),
             targetEmail: sh.email,
             avatarUrl: sh.avatarUrl,
-            permission: 'editor' as const,
-            role: 'editor',
+            permission: sh.permission === 'viewer' ? 'viewer' as const : 'editor' as const,
+            role: sh.permission === 'viewer' ? 'viewer' : 'editor',
             createdAt: sh.createdAt,
           }))}
           teams={safeTeams}
           collaborators={safeCollaborators}
-          allowRoleSelection={false}
-          onAddShare={async (targetType, targetId) => {
+          onAddShare={async (targetType, targetId, permission) => {
             await api.addTaskListShare(sharingTaskList.id, {
               targetType,
               targetId,
+              permission,
             });
             const [freshLists, freshShares] = await Promise.all([
               api.getTaskLists(),
@@ -2029,6 +2092,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
         }}
         activeColumns={activeColumns}
         taskLists={safeTaskLists}
+        onOpenDocument={onOpenDocument}
         onUpdateTitle={handleUpdateTaskTitle}
         onUpdateStatus={handleSetKanbanStatus}
         onUpdatePriority={handleSetPriority}
@@ -2041,6 +2105,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
         onDeleteSubtask={handleDeleteSubtask}
         onConvertToDoc={handleConvertToDoc}
         onDeleteTask={handleDeletePermanent}
+        readOnly={detailTask ? isTaskReadOnly(detailTask) : false}
       />
 
       {/* VIEW MODES: LIST OR KANBAN */}
@@ -2097,11 +2162,12 @@ export const TasksView: React.FC<TasksViewProps> = ({
                     {colTasks.map((task) => {
                       const isDragging = draggingTaskId === task.id;
                       const isTarget = dragOverTaskTarget?.taskId === task.id;
+                      const readOnly = isTaskReadOnly(task);
 
                       return (
                         <div
                           key={task.id}
-                          draggable
+                          draggable={!readOnly}
                           onDragStart={(e) => handleTaskDragStart(e, task)}
                           onDragEnd={() => {
                             setDraggingTaskId(null);
@@ -2115,7 +2181,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
                             setDetailTaskId(task.id);
                             setShowDetailModal(true);
                           }}
-                          className={`panel-surface p-2.5 space-y-2 hover:border-strong transition-all cursor-grab active:cursor-grabbing shadow-sm group relative ${
+                          className={`panel-surface p-2.5 space-y-2 hover:border-strong transition-all shadow-sm group relative ${
+                            readOnly ? 'cursor-pointer' : 'cursor-grab active:cursor-grabbing'
+                          } ${
                             isDragging ? 'opacity-30 border border-dashed border-accent/40' : ''
                           }`}
                         >
@@ -2134,6 +2202,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                           >
                             {task.content}
                           </p>
+                          {!readOnly && (
                           <div className="hidden sm:flex items-center gap-1 flex-shrink-0" onClick={(e) => e.stopPropagation()}>
                             <button
                               onClick={() => handleConvertToDoc(task)}
@@ -2150,6 +2219,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                               <Trash2 className="w-3 h-3" />
                             </button>
                           </div>
+                          )}
                         </div>
 
                         {/* Subtasks progress */}
@@ -2163,13 +2233,30 @@ export const TasksView: React.FC<TasksViewProps> = ({
                           </div>
                         )}
 
-                        {/* Badges: Priority, Status, Tags */}
+                        {/* Badges: In Notiz, Priority, Status, Tags */}
                         <div className="flex flex-wrap items-center gap-1 pt-0.5" onClick={(e) => e.stopPropagation()}>
+                          {(task.convertedType === 'document_block' || task.docId) && (
+                            <button
+                              type="button"
+                              onClick={(e) => {
+                                e.stopPropagation();
+                                const docId = task.docId || (task.convertedRefId ? task.convertedRefId.split(':')[0] : '');
+                                const blockId = task.blockId || (task.convertedRefId ? task.convertedRefId.split(':')[1] : '');
+                                if (docId) onOpenDocument(docId, blockId);
+                              }}
+                              className="h-4 px-1.5 text-[9px] rounded-btn border border-accent/40 bg-accent/10 text-accent hover:bg-accent/20 cursor-pointer flex items-center gap-1 font-medium shrink-0"
+                              title="In Notiz an der passenden Stelle öffnen"
+                            >
+                              <FileText className="w-2.5 h-2.5" />
+                              <span>In Notiz</span>
+                            </button>
+                          )}
                           {task.priority === 'urgent' && (
                             <button
                               type="button"
+                              disabled={readOnly}
                               onClick={() => handleCyclePriority(task)}
-                              className="badge-accent text-[9px] cursor-pointer hover:opacity-85"
+                              className="badge-accent text-[9px] cursor-pointer hover:opacity-85 disabled:cursor-default"
                               title="Klicken zum Ändern der Priorität (Dringend -> Normal)"
                             >
                               🔥 Dringend
@@ -2178,8 +2265,9 @@ export const TasksView: React.FC<TasksViewProps> = ({
                           {task.priority === 'high' && (
                             <button
                               type="button"
+                              disabled={readOnly}
                               onClick={() => handleCyclePriority(task)}
-                              className="px-1.5 py-0.2 border border-status-warn text-status-warn rounded-btn text-[9px] font-medium cursor-pointer hover:opacity-85"
+                              className="px-1.5 py-0.2 border border-status-warn text-status-warn rounded-btn text-[9px] font-medium cursor-pointer hover:opacity-85 disabled:cursor-default"
                               title="Klicken zum Ändern der Priorität (Wichtig -> Dringend)"
                             >
                               ⚠️ Wichtig
@@ -2217,6 +2305,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                         </div>
 
                         {/* Column Navigation controls: Move Left / Move Right */}
+                        {!readOnly && (
                         <div
                           className="flex items-center justify-between pt-1 border-t border-border text-[10px]"
                           onClick={(e) => e.stopPropagation()}
@@ -2243,6 +2332,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                             <ArrowRight className="w-3 h-3" />
                           </button>
                         </div>
+                        )}
                       </div>
                     );
                   })}
@@ -2255,6 +2345,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                   </div>
 
                   {/* Quick Add Task to Column */}
+                  {!isSelectedListReadOnly && (
                   <div className="p-2 border-t border-border bg-panel">
                     <button
                       type="button"
@@ -2265,6 +2356,7 @@ export const TasksView: React.FC<TasksViewProps> = ({
                       <span>Aufgabe hinzufügen</span>
                     </button>
                   </div>
+                  )}
                 </div>
               );
             })}

frontend/src/features/workspace/DocumentEditor.tsx

@@ -7,18 +7,19 @@ import {
   FileText,
   Loader2,
   ArrowLeft,
-  Hash,
   Lock,
   Home,
   ChevronRight,
   Minimize2,
   Sparkles,
   Plus,
+  Search,
 } from 'lucide-react';
 import { Document, DocumentBlock, User } from '../../lib/types';
-import { api } from '../../lib/api';
-import { useDocumentSync, DocSyncEvent, RemoteCursor, DocSyncStatus } from '../../lib/useDocumentSync';
-import { OutlinerTree } from './OutlinerTree';
+import { api, getToken } from '../../lib/api';
+import { OutlinerTree, OutlinerTreeHandle } from './OutlinerTree';
+
+export type DocSaveStatus = 'saved' | 'saving' | 'unsaved' | 'error';
 
 export interface DocumentEditorProps {
   docId: string;
@@ -33,10 +34,67 @@ export interface DocumentEditorProps {
   onSelectTag: (tag: string) => void;
   onWikiLinkClick?: (pageTitle: string) => void;
   onBackMobile?: () => void;
-  onSyncStatusChange?: (status: DocSyncStatus) => void;
+  onOpenTask?: (taskId: string) => void;
+  onSaveStatusChange?: (status: DocSaveStatus, errorMsg?: string) => void;
 }
 
-const EMOJI_PALETTE = ['📝', '📄', '💡', '🚀', '📌', '📂', '🧠', '⚡', '🎯', '🛠️', '📊', '🔒'];
+interface EmojiItem {
+  emoji: string;
+  category: string;
+  keywords: string;
+}
+
+const EMOJI_CATALOG: EmojiItem[] = [
+  // Notizen & Dokumente
+  { emoji: '📝', category: 'Notizen', keywords: 'notiz schreiben memo text note' },
+  { emoji: '📄', category: 'Notizen', keywords: 'dokument seite page doc' },
+  { emoji: '📋', category: 'Notizen', keywords: 'clipboard klemmbrett liste' },
+  { emoji: '📂', category: 'Notizen', keywords: 'ordner mappe folder datei' },
+  { emoji: '📁', category: 'Notizen', keywords: 'ordner folder directory' },
+  { emoji: '📌', category: 'Notizen', keywords: 'pin anheften bookmark wichtig' },
+  { emoji: '📍', category: 'Notizen', keywords: 'standort ort pin location' },
+  { emoji: '🏷️', category: 'Notizen', keywords: 'tag etikett label markierung' },
+  { emoji: '📚', category: 'Notizen', keywords: 'buch bibliothek lesen studium' },
+  { emoji: '📖', category: 'Notizen', keywords: 'buch open book wissen' },
+
+  // Ideen & Fokus
+  { emoji: '🧠', category: 'Ideen', keywords: 'gehirn brain denken wissen thought mind' },
+  { emoji: '💡', category: 'Ideen', keywords: 'idee inspiration lampe glühbirne idea' },
+  { emoji: '🎯', category: 'Ideen', keywords: 'ziel target fokus mission okr' },
+  { emoji: '🚀', category: 'Ideen', keywords: 'rakete start launch projekt rocket' },
+  { emoji: '⚡', category: 'Ideen', keywords: 'blitz energie schnell quick power' },
+  { emoji: '🔥', category: 'Ideen', keywords: 'feuer flame priorität hot wichtig' },
+  { emoji: '⭐', category: 'Ideen', keywords: 'stern favoriten star top' },
+  { emoji: '✨', category: 'Ideen', keywords: 'funkeln magie neu neuigkeit sparkles' },
+  { emoji: '🧩', category: 'Ideen', keywords: 'puzzle teil lösung problem' },
+  { emoji: '🔬', category: 'Ideen', keywords: 'mikroskop forschung analyse test' },
+
+  // Tech & Dev
+  { emoji: '💻', category: 'Tech', keywords: 'laptop computer dev code programming' },
+  { emoji: '🖥️', category: 'Tech', keywords: 'desktop monitor bildschirm workstation' },
+  { emoji: '🛠️', category: 'Tech', keywords: 'werkzeug tools optionen settings einstellungen' },
+  { emoji: '⚙️', category: 'Tech', keywords: 'zahnrad config settings system' },
+  { emoji: '📊', category: 'Tech', keywords: 'diagramm chart daten statistik dashboard' },
+  { emoji: '📈', category: 'Tech', keywords: 'wachstum trend kurve business' },
+  { emoji: '🔒', category: 'Tech', keywords: 'schloss sicherheit geheim privat secure' },
+  { emoji: '🔑', category: 'Tech', keywords: 'schlüssel key passwort access' },
+  { emoji: '🌐', category: 'Tech', keywords: 'web internet network welt globus' },
+  { emoji: '📦', category: 'Tech', keywords: 'paket box release lieferung package' },
+
+  // Alltag & Organisation
+  { emoji: '💬', category: 'Alltag', keywords: 'chat nachricht kommentar call sprechen' },
+  { emoji: '✉️', category: 'Alltag', keywords: 'mail email brief post nachricht' },
+  { emoji: '📅', category: 'Alltag', keywords: 'kalender datum termin plan event' },
+  { emoji: '⏰', category: 'Alltag', keywords: 'wecker uhr zeit deadline alarm' },
+  { emoji: '🛒', category: 'Alltag', keywords: 'warenkorb einkauf shopping liste' },
+  { emoji: '☕', category: 'Alltag', keywords: 'kaffee pause bistro morning' },
+  { emoji: '🏠', category: 'Alltag', keywords: 'haus heim home wohnung' },
+  { emoji: '🏢', category: 'Alltag', keywords: 'büro firma arbeit office work' },
+  { emoji: '✈️', category: 'Alltag', keywords: 'flugzeug reise urlaub trip travel' },
+  { emoji: '🎨', category: 'Alltag', keywords: 'kunst farbe design creative' },
+  { emoji: '🏆', category: 'Alltag', keywords: 'pokal erfolg win trophy award' },
+  { emoji: '✅', category: 'Alltag', keywords: 'haken check done erledigt' },
+];
 
 function ensureNonEmptyBlocks(docId: string, blocks?: DocumentBlock[]): DocumentBlock[] {
   if (!blocks || blocks.length === 0) {
@@ -144,7 +202,6 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
   docId,
   currentUser,
   initialDoc,
-  availableFolders,
   autoFocusTitle,
   initialFocusedBlockId,
   onDocMetadataChange,
@@ -153,7 +210,8 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
   onSelectTag,
   onWikiLinkClick,
   onBackMobile,
-  onSyncStatusChange,
+  onOpenTask,
+  onSaveStatusChange,
 }) => {
   const [doc, setDoc] = useState<Document | null>(initialDoc || null);
   const [title, setTitle] = useState<string>(initialDoc?.title || '');
@@ -163,13 +221,36 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
   const [loading, setLoading] = useState<boolean>(!initialDoc);
   const [error, setError] = useState<string | null>(null);
   const [showEmojiPicker, setShowEmojiPicker] = useState<boolean>(false);
+  const [emojiSearch, setEmojiSearch] = useState<string>('');
   const [zoomedBlockId, setZoomedBlockId] = useState<string | null>(null);
 
-  const titleInputRef = useRef<HTMLInputElement | null>(null);
-  const titleDebounceRef = useRef<number | null>(null);
+  const filteredEmojis = useMemo(() => {
+    const q = emojiSearch.trim().toLowerCase();
+    if (!q) return EMOJI_CATALOG;
+    return EMOJI_CATALOG.filter(
+      (item) => item.keywords.includes(q) || item.emoji.includes(q) || item.category.toLowerCase().includes(q)
+    );
+  }, [emojiSearch]);
+
+  // AutoSave state (REST persistence)
+  const [, setSaveStatus] = useState<DocSaveStatus>('saved');
+  const [, setSaveErrorMessage] = useState<string | null>(null);
+  const saveTimeoutRef = useRef<number | null>(null);
+  const isSavingRef = useRef<boolean>(false);
+  const lastSavedSnapshotRef = useRef<string>('');
+  const isInitialLoadRef = useRef<boolean>(true);
+
+  const titleInputRef = useRef<HTMLTextAreaElement | HTMLInputElement | null>(null);
+  const outlinerTreeRef = useRef<OutlinerTreeHandle | null>(null);
   const docRef = useRef<Document | null>(doc);
   docRef.current = doc;
 
+  const currentTitleRef = useRef<string>(title);
+  currentTitleRef.current = title;
+  const currentBlocksRef = useRef<DocumentBlock[]>(blocks);
+  currentBlocksRef.current = blocks;
+  const lastKnownUpdatedAtRef = useRef<string | null>(initialDoc?.updatedAt || null);
+
   useEffect(() => {
     if (!loading && (autoFocusTitle || (doc?.title === 'Neue Notiz' && (!doc?.blocks || doc?.blocks.length <= 1)))) {
       const focusTitle = () => {
@@ -202,186 +283,12 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
     return computeBreadcrumbs(title || doc?.title || 'Dokument', blocks, zoomedBlockId);
   }, [title, doc?.title, blocks, zoomedBlockId]);
 
-  // Crucial fix: Collaborator with write permission can edit!
+  // Strictly Read-Only for shared documents: only the document owner can edit!
   const canEdit = useMemo(() => {
     if (!doc) return true;
-    if (doc.isOwner) return true;
-    return doc.permission === 'owner' || doc.permission === 'write';
+    return Boolean(doc.isOwner || doc.permission === 'owner');
   }, [doc]);
 
-  // Handle incoming WebSocket events for THIS document room
-  const handleRemoteEvent = useCallback(
-    (evt: DocSyncEvent) => {
-      if (evt.docId && evt.docId !== docId) return;
-
-      switch (evt.type) {
-        case 'doc_state': {
-          if (evt.title !== undefined) {
-            const isTitleActivelyEditing =
-              titleInputRef.current !== null &&
-              document.activeElement === titleInputRef.current &&
-              typeof document !== 'undefined' &&
-              document.hasFocus();
-            if (!isTitleActivelyEditing) {
-              setTitle(evt.title);
-            }
-          }
-          if (Array.isArray(evt.blocks) && evt.blocks.length > 0) {
-            setBlocks(ensureNonEmptyBlocks(docId, evt.blocks));
-          }
-          break;
-        }
-
-        case 'title_updated': {
-          if (evt.title !== undefined) {
-            const isTitleActivelyEditing =
-              titleInputRef.current !== null &&
-              document.activeElement === titleInputRef.current &&
-              typeof document !== 'undefined' &&
-              document.hasFocus();
-            if (!isTitleActivelyEditing) {
-              setTitle(evt.title);
-            }
-            if (docRef.current) {
-              const updated = { ...docRef.current, title: evt.title };
-              setDoc(updated);
-              onDocMetadataChange(updated);
-            }
-          }
-          break;
-        }
-
-        case 'block_created': {
-          if (!evt.block) return;
-          const incoming = evt.block;
-          setBlocks((prev) => {
-            if (prev.some((b) => b.id === incoming.id)) {
-              return prev.map((b) => (b.id === incoming.id ? incoming : b));
-            }
-            const next = [...prev];
-            if (evt.afterBlockId) {
-              const idx = next.findIndex((b) => b.id === evt.afterBlockId);
-              if (idx >= 0) {
-                next.splice(idx + 1, 0, incoming);
-                return ensureNonEmptyBlocks(docId, next);
-              }
-            }
-            next.push(incoming);
-            return ensureNonEmptyBlocks(docId, next);
-          });
-          break;
-        }
-
-        case 'block_updated': {
-          const targetId = evt.blockId || evt.block?.id;
-          if (!targetId) return;
-          setBlocks((prev) =>
-            prev.map((b) => {
-              if (b.id !== targetId) return b;
-              if (evt.block) {
-                return { ...b, ...evt.block };
-              }
-              return {
-                ...b,
-                content: evt.content !== undefined ? evt.content : b.content,
-                level: evt.level !== undefined ? evt.level : b.level,
-                checked: evt.checked !== undefined ? evt.checked : b.checked,
-                collapsed: evt.collapsed !== undefined ? evt.collapsed : b.collapsed,
-              };
-            })
-          );
-          break;
-        }
-
-        case 'block_deleted': {
-          if (!evt.blockId) return;
-          setBlocks((prev) =>
-            ensureNonEmptyBlocks(
-              docId,
-              prev.filter((b) => b.id !== evt.blockId)
-            )
-          );
-          break;
-        }
-
-        case 'block_moved': {
-          if (!evt.blockId || evt.newIndex === undefined) return;
-          const targetIndex = evt.newIndex;
-          setBlocks((prev) => {
-            const fromIdx = prev.findIndex((b) => b.id === evt.blockId);
-            if (fromIdx === -1) return prev;
-            const copy = [...prev];
-            const [moving] = copy.splice(fromIdx, 1);
-            const updatedMoving: DocumentBlock = {
-              ...moving,
-              level: evt.level !== undefined ? evt.level : moving.level,
-            };
-            const boundedIdx = Math.max(0, Math.min(targetIndex, copy.length));
-            copy.splice(boundedIdx, 0, updatedMoving);
-            return ensureNonEmptyBlocks(docId, copy);
-          });
-          break;
-        }
-
-        case 'blocks_replaced': {
-          if (Array.isArray(evt.blocks)) {
-            setBlocks(ensureNonEmptyBlocks(docId, evt.blocks));
-          }
-          break;
-        }
-      }
-    },
-    [docId, onDocMetadataChange]
-  );
-
-  const {
-    status: syncStatus,
-    remoteCursors,
-    sendCursorMoved,
-    sendBlockCreated,
-    sendBlockUpdated,
-    sendBlockDeleted,
-    sendBlockMoved,
-    sendTitleUpdated,
-  } = useDocumentSync(docId, handleRemoteEvent, canEdit, currentUser);
-
-  useEffect(() => {
-    onSyncStatusChange?.(syncStatus);
-  }, [syncStatus, onSyncStatusChange]);
-
-  // Fetch isolated document state on mount
-  useEffect(() => {
-    let isCancelled = false;
-    if (!initialDoc) {
-      setLoading(true);
-    }
-    setError(null);
-
-    api
-      .getDocument(docId)
-      .then((fetched) => {
-        if (isCancelled) return;
-        setDoc(fetched);
-        setTitle(fetched.title || 'Unbenannte Notiz');
-        setBlocks(ensureNonEmptyBlocks(docId, fetched.blocks));
-        setLoading(false);
-        onDocMetadataChange(fetched);
-      })
-      .catch((err: any) => {
-        if (isCancelled) return;
-        setError(err?.message || 'Dokument konnte nicht geladen werden');
-        setLoading(false);
-      });
-
-    return () => {
-      isCancelled = true;
-      if (titleDebounceRef.current !== null) {
-        window.clearTimeout(titleDebounceRef.current);
-        titleDebounceRef.current = null;
-      }
-    };
-  }, [docId]);
-
   // Extract all #tags present across the current blocks
   const extractedTags = useMemo(() => {
     const tagSet = new Set<string>();
@@ -396,6 +303,174 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
     return Array.from(tagSet);
   }, [blocks]);
 
+  const currentTagsRef = useRef<string[]>(extractedTags);
+  currentTagsRef.current = extractedTags;
+
+  // AutoSave snapshot
+  const currentSnapshot = useMemo(() => {
+    return JSON.stringify({
+      title,
+      blocks,
+      tags: extractedTags,
+    });
+  }, [title, blocks, extractedTags]);
+
+  const currentSnapshotRef = useRef<string>(currentSnapshot);
+  currentSnapshotRef.current = currentSnapshot;
+
+  const executeAutoSave = useCallback(
+    async (immediate: boolean = false) => {
+      if (!docId || !canEdit) return;
+      if (isSavingRef.current && !immediate) return;
+
+      const snapshot = currentSnapshotRef.current;
+      if (snapshot === lastSavedSnapshotRef.current) {
+        setSaveStatus('saved');
+        onSaveStatusChange?.('saved');
+        return;
+      }
+
+      isSavingRef.current = true;
+      setSaveStatus('saving');
+      onSaveStatusChange?.('saving');
+
+      try {
+        const updated = await api.updateDocument(docId, {
+          title: currentTitleRef.current,
+          blocks: currentBlocksRef.current,
+          tags: currentTagsRef.current,
+        });
+        isSavingRef.current = false;
+        lastSavedSnapshotRef.current = snapshot;
+        lastKnownUpdatedAtRef.current = updated.updatedAt || null;
+        setSaveStatus('saved');
+        setSaveErrorMessage(null);
+        onSaveStatusChange?.('saved');
+        if (docRef.current) {
+          docRef.current = updated;
+          onDocMetadataChange(updated);
+        }
+      } catch (err: any) {
+        isSavingRef.current = false;
+        const msg = err?.message || 'Fehler beim Speichern';
+        setSaveStatus('error');
+        setSaveErrorMessage(msg);
+        onSaveStatusChange?.('error', msg);
+      }
+    },
+    [docId, canEdit, onSaveStatusChange, onDocMetadataChange]
+  );
+
+  useEffect(() => {
+    if (isInitialLoadRef.current) return;
+    if (!canEdit) return;
+    if (currentSnapshot === lastSavedSnapshotRef.current) return;
+
+    setSaveStatus('unsaved');
+    onSaveStatusChange?.('unsaved');
+
+    if (saveTimeoutRef.current !== null) {
+      window.clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = window.setTimeout(() => {
+      saveTimeoutRef.current = null;
+      executeAutoSave();
+    }, 800);
+
+    return () => {
+      if (saveTimeoutRef.current !== null) {
+        window.clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+    };
+  }, [currentSnapshot, canEdit, executeAutoSave, onSaveStatusChange]);
+
+  // Flush on page unload / pagehide via keepalive fetch
+  useEffect(() => {
+    const handleUnload = () => {
+      if (saveTimeoutRef.current !== null) {
+        window.clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+      const snapshot = currentSnapshotRef.current;
+      if (snapshot !== lastSavedSnapshotRef.current && canEdit) {
+        const token = getToken();
+        if (token) {
+          fetch(`/api/v1/documents/${docId}`, {
+            method: 'PUT',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+              title: currentTitleRef.current,
+              blocks: currentBlocksRef.current,
+              tags: currentTagsRef.current,
+            }),
+            keepalive: true,
+          }).catch(() => {});
+        }
+      }
+    };
+
+    window.addEventListener('beforeunload', handleUnload);
+    window.addEventListener('pagehide', handleUnload);
+    return () => {
+      window.removeEventListener('beforeunload', handleUnload);
+      window.removeEventListener('pagehide', handleUnload);
+      handleUnload();
+    };
+  }, [docId, canEdit]);
+
+  // Fetch document on mount
+  useEffect(() => {
+    let isCancelled = false;
+    if (!initialDoc) {
+      setLoading(true);
+    }
+    setError(null);
+
+    api
+      .getDocument(docId)
+      .then((fetched) => {
+        if (isCancelled) return;
+        const normalized = ensureNonEmptyBlocks(docId, fetched.blocks);
+        setDoc(fetched);
+        setTitle(fetched.title || 'Unbenannte Notiz');
+        setBlocks(normalized);
+        setLoading(false);
+        onDocMetadataChange(fetched);
+
+        const initialTags: string[] = [];
+        for (const b of normalized) {
+          const matches = b.content?.match(/#([a-zA-Z0-9äöüÄÖÜß_-]+)/g);
+          if (matches) {
+            for (const m of matches) {
+              const tag = m.slice(1).toLowerCase();
+              if (!initialTags.includes(tag)) initialTags.push(tag);
+            }
+          }
+        }
+        lastSavedSnapshotRef.current = JSON.stringify({
+          title: fetched.title || 'Unbenannte Notiz',
+          blocks: normalized,
+          tags: initialTags,
+        });
+        isInitialLoadRef.current = false;
+        setSaveStatus('saved');
+        onSaveStatusChange?.('saved');
+      })
+      .catch((err: any) => {
+        if (isCancelled) return;
+        setError(err?.message || 'Dokument konnte nicht geladen werden');
+        setLoading(false);
+      });
+
+    return () => {
+      isCancelled = true;
+    };
+  }, [docId]);
+
   // Keep parent sidebar metadata in sync when blocks/tags change
   useEffect(() => {
     if (!docRef.current) return;
@@ -410,118 +485,154 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
     onDocMetadataChange(updatedDoc);
   }, [blocks, extractedTags, title]);
 
-  // Active remote users in this room (excluding self)
-  const activeUsers = useMemo(() => {
-    const list: RemoteCursor[] = [];
-    const seen = new Set<string>();
-    for (const c of Object.values(remoteCursors)) {
-      const key = c.userId || c.clientId;
-      if (!seen.has(key)) {
-        seen.add(key);
-        list.push(c);
-      }
-    }
-    return list;
-  }, [remoteCursors]);
-
-  const handleTitleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+  const handleTitleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
     if (!canEdit) return;
-    const nextTitle = e.target.value;
-    setTitle(nextTitle);
-
-    if (titleDebounceRef.current !== null) {
-      window.clearTimeout(titleDebounceRef.current);
-    }
-    titleDebounceRef.current = window.setTimeout(() => {
-      titleDebounceRef.current = null;
-      sendTitleUpdated(nextTitle);
-    }, 250);
+    setTitle(e.target.value);
   };
 
   const handleTitleBlur = () => {
-    if (titleDebounceRef.current !== null) {
-      window.clearTimeout(titleDebounceRef.current);
-      titleDebounceRef.current = null;
-      sendTitleUpdated(title);
-    }
+    executeAutoSave();
   };
 
-  // Flush title debouncing on window blur so background window never holds stale pending title
-  useEffect(() => {
-    const handleWindowBlur = () => {
-      if (titleDebounceRef.current !== null) {
-        window.clearTimeout(titleDebounceRef.current);
-        titleDebounceRef.current = null;
-        sendTitleUpdated(title);
-      }
-    };
-    window.addEventListener('blur', handleWindowBlur);
-    return () => window.removeEventListener('blur', handleWindowBlur);
-  }, [title, sendTitleUpdated]);
-
   const handleUpdateBlock = useCallback(
-    (updatedBlock: DocumentBlock) => {
-      setBlocks((prev) =>
-        prev.map((b) => (b.id === updatedBlock.id ? updatedBlock : b))
-      );
-      sendBlockUpdated(updatedBlock);
+    (updatedBlock: DocumentBlock, immediate: boolean = false) => {
+      if (!canEdit) return;
+      setBlocks((prev) => {
+        const next = prev.map((b) => (b.id === updatedBlock.id ? updatedBlock : b));
+        currentBlocksRef.current = next;
+        return next;
+      });
+      if (immediate) {
+        window.setTimeout(() => {
+          executeAutoSave(true);
+        }, 10);
+      }
     },
-    [sendBlockUpdated]
+    [canEdit, executeAutoSave]
+  );
+
+  const handleUpdateBlocks = useCallback(
+    (updatedBlocks: DocumentBlock[]) => {
+      if (!canEdit || updatedBlocks.length === 0) return;
+      const map = new Map<string, DocumentBlock>();
+      for (const b of updatedBlocks) {
+        map.set(b.id, b);
+      }
+      setBlocks((prev) =>
+        prev.map((b) => map.get(b.id) || b)
+      );
+    },
+    [canEdit]
   );
 
   const handleCreateBlock = useCallback(
     (newBlock: DocumentBlock, afterBlockId?: string) => {
+      if (!canEdit) return;
       setBlocks((prev) => {
         const next = [...prev];
         if (afterBlockId) {
           const idx = next.findIndex((b) => b.id === afterBlockId);
           if (idx >= 0) {
             next.splice(idx + 1, 0, newBlock);
-            const normalized = ensureNonEmptyBlocks(docId, next);
-            sendBlockCreated(newBlock, afterBlockId, normalized);
-            return normalized;
+            return ensureNonEmptyBlocks(docId, next);
           }
         }
         next.push(newBlock);
-        const normalized = ensureNonEmptyBlocks(docId, next);
-        sendBlockCreated(newBlock, afterBlockId, normalized);
-        return normalized;
+        return ensureNonEmptyBlocks(docId, next);
       });
     },
-    [docId, sendBlockCreated]
+    [docId, canEdit]
+  );
+
+  const handleInsertBlocks = useCallback(
+    (afterBlockId: string, updatedCurrentBlock: DocumentBlock, newBlocks: DocumentBlock[]) => {
+      if (!canEdit) return;
+      setBlocks((prev) => {
+        const next = [...prev];
+        const idx = next.findIndex((b) => b.id === afterBlockId);
+        if (idx >= 0) {
+          next[idx] = updatedCurrentBlock;
+          next.splice(idx + 1, 0, ...newBlocks);
+        } else {
+          next.push(updatedCurrentBlock, ...newBlocks);
+        }
+        const normalized = ensureNonEmptyBlocks(docId, next);
+        currentBlocksRef.current = normalized;
+        return normalized;
+      });
+      window.setTimeout(() => {
+        executeAutoSave(true);
+      }, 50);
+    },
+    [docId, canEdit, executeAutoSave]
   );
 
   const handleDeleteBlock = useCallback(
     (blockId: string) => {
+      if (!canEdit) return;
       setBlocks((prev) => {
         const filtered = prev.filter((b) => b.id !== blockId);
-        const normalized = ensureNonEmptyBlocks(docId, filtered);
-        sendBlockDeleted(blockId, normalized);
-        return normalized;
+        return ensureNonEmptyBlocks(docId, filtered);
       });
     },
-    [docId, sendBlockDeleted]
+    [docId, canEdit]
   );
 
   const handleMoveBlock = useCallback(
-    (blockId: string, newIndex: number, level?: number) => {
+    (blockId: string, targetIndex: number, newLevel?: number) => {
+      if (!canEdit) return;
       setBlocks((prev) => {
         const fromIdx = prev.findIndex((b) => b.id === blockId);
         if (fromIdx === -1) return prev;
+
+        const parentBlock = prev[fromIdx];
+        const parentLevel = Math.max(0, parentBlock.level || 0);
+
+        // Calculate full subtree count (dragged block + all contiguous descendants)
+        let count = 1;
+        for (let i = fromIdx + 1; i < prev.length; i++) {
+          if (Math.max(0, prev[i].level || 0) > parentLevel) {
+            count++;
+          } else {
+            break;
+          }
+        }
+
+        // Prevent dropping inside its own subtree
+        if (targetIndex >= fromIdx && targetIndex < fromIdx + count) {
+          return prev;
+        }
+
         const copy = [...prev];
-        const [moving] = copy.splice(fromIdx, 1);
-        const updatedMoving: DocumentBlock = {
-          ...moving,
-          level: level !== undefined ? level : moving.level,
-        };
-        const boundedIdx = Math.max(0, Math.min(newIndex, copy.length));
-        copy.splice(boundedIdx, 0, updatedMoving);
-        const normalized = ensureNonEmptyBlocks(docId, copy);
-        sendBlockMoved(blockId, boundedIdx, updatedMoving.level, normalized);
-        return normalized;
+        const subtree = copy.splice(fromIdx, count);
+
+        // Adjust insertion index because removing elements from before shifts target index
+        let insertIndex = targetIndex;
+        if (fromIdx < targetIndex) {
+          insertIndex = targetIndex - count;
+        }
+        insertIndex = Math.max(0, Math.min(insertIndex, copy.length));
+
+        // Calculate level adjustments if moving to a constrained position
+        const prevBlockInPosition = insertIndex > 0 ? copy[insertIndex - 1] : null;
+        const maxAllowed = prevBlockInPosition
+          ? Math.max(0, prevBlockInPosition.level || 0) + 1
+          : 0;
+
+        const targetLevel = newLevel !== undefined ? newLevel : parentLevel;
+        const clampedLevel = Math.min(targetLevel, maxAllowed);
+        const levelDelta = clampedLevel - parentLevel;
+
+        const updatedSubtree = subtree.map((b) => ({
+          ...b,
+          level: Math.max(0, (b.level || 0) + levelDelta),
+        }));
+
+        copy.splice(insertIndex, 0, ...updatedSubtree);
+        return ensureNonEmptyBlocks(docId, copy);
       });
     },
-    [docId, sendBlockMoved]
+    [docId, canEdit]
   );
 
   const handleTogglePin = async () => {
@@ -680,37 +791,9 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
           )}
         </div>
 
-        {/* Right Status & Action Buttons */}
+        {/* Right Action Buttons */}
         <div className="flex items-center gap-1.5">
-          {/* Active Presence Avatars (Immer rund: rounded-full mit Überlappung) */}
-          {activeUsers.length > 0 && (
-            <div className="flex items-center -space-x-1.5 mr-1" title="Aktive Bearbeiter im Dokument">
-              {activeUsers.map((u) => {
-                const initials = (u.userName || 'A')
-                  .split(' ')
-                  .map((n) => n[0])
-                  .slice(0, 2)
-                  .join('')
-                  .toUpperCase();
-                return (
-                  <div key={u.clientId} className="relative group/avatar cursor-default">
-                    <div
-                      className="w-6 h-6 rounded-full flex items-center justify-center text-[10px] font-bold text-white shadow-sm ring-2 ring-canvas"
-                      style={{ backgroundColor: u.userColor }}
-                    >
-                      {initials}
-                    </div>
-                    {/* Tooltip */}
-                    <div className="pointer-events-none absolute bottom-full mb-1 left-1/2 -translate-x-1/2 opacity-0 group-hover/avatar:opacity-100 transition-opacity whitespace-nowrap bg-canvas text-main text-[10px] px-1.5 py-0.5 rounded-btn border border-border shadow-md z-30">
-                      {u.userName}
-                    </div>
-                  </div>
-                );
-              })}
-            </div>
-          )}
-
-          {/* Sharing Section (1:1 styling from SharedListsView) */}
+          {/* Sharing Section */}
           {doc && (() => {
             const isOwner = doc.isOwner !== false && (doc.userId === currentUser?.id || !doc.userId || currentUser?.role === 'admin');
             const sharesCount = doc.sharedWith?.length || 0;
@@ -790,14 +873,21 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
         </div>
       </div>
 
+      {/* Read-only notification banner */}
+      {!canEdit && (
+        <div className="flex items-center gap-2 px-4 sm:px-6 py-2 bg-status-warn/10 border-b border-status-warn/25 text-status-warn text-xs">
+          <Lock className="w-3.5 h-3.5 shrink-0" />
+          <span>Dieses Dokument wurde schreibgeschützt mit dir geteilt (Nur Lesen).</span>
+        </div>
+      )}
+
       {/* Main Content Area */}
-      <div className="max-w-4xl w-full mx-auto px-4 sm:px-8 py-5 flex-1">
+      <div className="w-full px-4 sm:px-8 py-5 flex-1">
         {zoomedBlock ? (
           /* =========================================================================
              FOKUS-MODUS & ZOOM-IN (HOISTED SUBTREE VIEW)
              ========================================================================= */
           <div className="space-y-3">
-            {/* Prominent Zoomed Ast-Heading */}
             <div className="flex items-start justify-between gap-3 pb-4 mb-2 border-b border-border">
               <div className="flex-1 min-w-0">
                 <div className="flex items-center gap-2 mb-1.5">
@@ -846,7 +936,6 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
               </button>
             </div>
 
-            {/* Subtree Children or Empty State */}
             {childBlocks.length === 0 ? (
               <div className="py-8 text-center text-xs text-faint border border-dashed border-border rounded-card my-2">
                 <p className="mb-2">Dieser Ast hat noch keine Unterpunkte.</p>
@@ -878,12 +967,13 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
                 canEdit={canEdit}
                 levelOffset={levelOffset}
                 onZoomBlock={setZoomedBlockId}
-                remoteCursors={remoteCursors}
-                sendCursorMoved={sendCursorMoved}
                 onUpdateBlock={handleUpdateBlock}
+                onUpdateBlocks={handleUpdateBlocks}
                 onCreateBlock={handleCreateBlock}
+                onInsertBlocks={handleInsertBlocks}
                 onDeleteBlock={handleDeleteBlock}
                 onMoveBlock={handleMoveBlock}
+                onOpenTask={onOpenTask}
                 onTagClick={onSelectTag}
                 onWikiLinkClick={onWikiLinkClick}
                 initialFocusedBlockId={initialFocusedBlockId}
@@ -907,47 +997,119 @@ export const DocumentEditor: React.FC<DocumentEditorProps> = ({
                   {doc?.icon || '📝'}
                 </button>
                 {showEmojiPicker && canEdit && (
-                  <div className="absolute left-0 mt-1 p-2 panel-surface shadow-panel border border-border rounded-card grid grid-cols-6 gap-1 z-30 w-52">
-                    {EMOJI_PALETTE.map((emoji) => (
+                  <div
+                    className="absolute left-0 mt-1 p-2 panel-surface shadow-lg border border-border rounded-card z-30 w-72 space-y-2"
+                    onClick={(e) => e.stopPropagation()}
+                  >
+                    <div className="relative">
+                      <Search className="w-3.5 h-3.5 text-faint absolute left-2 top-1/2 -translate-y-1/2" />
+                      <input
+                        type="text"
+                        autoFocus
+                        value={emojiSearch}
+                        onChange={(e) => setEmojiSearch(e.target.value)}
+                        placeholder="Icon suchen oder Emoji eingeben…"
+                        className="input-field w-full pl-7 pr-2 py-1 text-xs"
+                      />
+                    </div>
+                    {doc?.icon && (
                       <button
-                        key={emoji}
                         type="button"
-                        onClick={() => handleSelectIcon(emoji)}
-                        className="p-1.5 rounded-btn hover:bg-panel-elevated text-base flex items-center justify-center cursor-pointer"
+                        onClick={() => {
+                          handleSelectIcon('');
+                          setShowEmojiPicker(false);
+                          setEmojiSearch('');
+                        }}
+                        className="w-full text-left px-2 py-1 text-status-warn/90 hover:bg-status-warn/10 rounded text-xs font-medium flex items-center gap-1.5 cursor-pointer"
                       >
-                        {emoji}
+                        <Trash2 className="w-3 h-3" />
+                        <span>Icon entfernen</span>
                       </button>
-                    ))}
+                    )}
+                    {emojiSearch.trim() && (
+                      <button
+                        type="button"
+                        onClick={() => {
+                          handleSelectIcon(emojiSearch.trim());
+                          setShowEmojiPicker(false);
+                          setEmojiSearch('');
+                        }}
+                        className="w-full text-left px-2 py-1 bg-accent/10 hover:bg-accent/20 text-accent rounded text-xs font-medium flex items-center justify-between cursor-pointer"
+                      >
+                        <span>Eingabe als Icon nutzen</span>
+                        <span className="text-base">{emojiSearch.trim()}</span>
+                      </button>
+                    )}
+                    <div className="max-h-48 overflow-y-auto grid grid-cols-6 gap-1 pr-1">
+                      {filteredEmojis.map((item) => (
+                        <button
+                          key={item.emoji}
+                          type="button"
+                          onClick={() => {
+                            handleSelectIcon(item.emoji);
+                            setShowEmojiPicker(false);
+                            setEmojiSearch('');
+                          }}
+                          className="p-1.5 rounded-btn hover:bg-panel-elevated text-lg flex items-center justify-center cursor-pointer transition-colors"
+                          title={item.keywords}
+                        >
+                          {item.emoji}
+                        </button>
+                      ))}
+                      {filteredEmojis.length === 0 && (
+                        <div className="col-span-6 text-center text-xs text-faint py-3">
+                          Kein passendes Standard-Icon
+                        </div>
+                      )}
+                    </div>
                   </div>
                 )}
               </div>
 
-              <input
-                ref={titleInputRef}
-                type="text"
+              <textarea
+                ref={(el) => {
+                  titleInputRef.current = el;
+                  if (el) {
+                    el.style.height = 'auto';
+                    el.style.height = `${el.scrollHeight}px`;
+                  }
+                }}
+                rows={1}
                 value={title}
                 readOnly={!canEdit}
                 autoFocus={autoFocusTitle}
-                onChange={handleTitleChange}
+                onChange={(e) => {
+                  handleTitleChange(e);
+                  e.target.style.height = 'auto';
+                  e.target.style.height = `${e.target.scrollHeight}px`;
+                }}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    outlinerTreeRef.current?.focusFirstBlock();
+                  }
+                }}
                 onBlur={handleTitleBlur}
                 placeholder="Titel der Notiz…"
-                className="flex-1 min-w-0 text-xl sm:text-2xl font-bold text-main bg-transparent border-0 focus:outline-none focus:ring-0 tracking-tight"
+                className="flex-1 min-w-0 text-xl sm:text-2xl font-bold text-main bg-transparent border-0 focus:outline-none focus:ring-0 tracking-tight resize-none leading-snug whitespace-pre-wrap break-words [overflow-wrap:anywhere]"
               />
             </div>
 
             {/* Logseq Outliner Tree */}
             <OutlinerTree
+              ref={outlinerTreeRef}
               docId={docId}
               blocks={blocks}
               canEdit={canEdit}
               levelOffset={0}
               onZoomBlock={setZoomedBlockId}
-              remoteCursors={remoteCursors}
-              sendCursorMoved={sendCursorMoved}
               onUpdateBlock={handleUpdateBlock}
+              onUpdateBlocks={handleUpdateBlocks}
               onCreateBlock={handleCreateBlock}
+              onInsertBlocks={handleInsertBlocks}
               onDeleteBlock={handleDeleteBlock}
               onMoveBlock={handleMoveBlock}
+              onOpenTask={onOpenTask}
               onTagClick={onSelectTag}
               onWikiLinkClick={onWikiLinkClick}
               initialFocusedBlockId={initialFocusedBlockId}

frontend/src/features/workspace/OutlinerBlock.tsx

@@ -3,8 +3,10 @@ import {
   ChevronRight,
   ChevronDown,
   Check,
+  CheckSquare,
   X,
-  GripVertical,
+  Trash2,
+  MoreHorizontal,
   Code,
   Heading1,
   Heading2,
@@ -19,8 +21,9 @@ import {
   FileText,
 } from 'lucide-react';
 import { DocumentBlock, BlockType } from '../../lib/types';
-import { RemoteCursor } from '../../lib/useDocumentSync';
 import { LinkModal } from './LinkModal';
+import { renderInlineMarkdown } from '../../lib/markdown';
+import { api } from '../../lib/api';
 
 export interface SlashCommand {
   type: BlockType | 'link';
@@ -41,22 +44,23 @@ const SLASH_COMMANDS: SlashCommand[] = [
 ];
 
 export interface OutlinerBlockProps {
+  docId: string;
   block: DocumentBlock;
   index: number;
+  isLast: boolean;
   maxAllowedLevel: number;
   hasChildren: boolean;
   isFocused: boolean;
   canEdit: boolean;
-  activeRemoteCursors?: RemoteCursor[];
-  sendCursorMoved?: (blockId: string | null, selectionStart?: number, selectionEnd?: number) => void;
   levelOffset?: number;
   onZoomBlock?: (blockId: string) => void;
-  onFocusBlock: (blockId: string) => void;
   onUpdateBlock: (updated: DocumentBlock, immediate?: boolean) => void;
-  onCreateBlockBelow: (afterBlockId: string, currentContent: string) => void;
-  onDeleteBlock: (blockId: string) => void;
+  onCreateBlockBelow: (afterBlockId: string, newContent?: string) => void;
+  onDeleteBlock: (blockId: string, deleteSubtree?: boolean) => void;
   onIndentBlock: (blockId: string, delta: 1 | -1) => void;
   onNavigateFocus: (blockId: string, direction: 'up' | 'down') => void;
+  onFocusBlock?: (blockId: string) => void;
+  onOpenTask?: (taskId: string) => void;
   onTagClick?: (tag: string) => void;
   onWikiLinkClick?: (pageTitle: string) => void;
   onDragStartBlock?: (index: number) => void;
@@ -65,24 +69,27 @@ export interface OutlinerBlockProps {
   isDragTarget?: boolean;
   isTargeted?: boolean;
   registerTextareaRef: (blockId: string, el: HTMLTextAreaElement | null) => void;
+  onPasteMultiLines?: (blockId: string, textBefore: string, textAfter: string, rawLines: string[]) => void;
 }
 
 export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
+  docId,
   block,
   index,
+  isLast,
+  maxAllowedLevel,
   hasChildren,
   isFocused,
   canEdit,
-  activeRemoteCursors = [],
-  sendCursorMoved,
   levelOffset = 0,
   onZoomBlock,
-  onFocusBlock,
   onUpdateBlock,
   onCreateBlockBelow,
   onDeleteBlock,
   onIndentBlock,
   onNavigateFocus,
+  onFocusBlock,
+  onOpenTask,
   onTagClick,
   onWikiLinkClick,
   onDragStartBlock,
@@ -91,11 +98,15 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
   isDragTarget,
   isTargeted,
   registerTextareaRef,
+  onPasteMultiLines,
 }) => {
   const [localContent, setLocalContent] = useState<string>(block.content || '');
+  const [isLocallyFocused, setIsLocallyFocused] = useState<boolean>(false);
+  const activeFocus = isFocused || isLocallyFocused;
   const [slashSearch, setSlashSearch] = useState<string | null>(null);
   const [slashIndex, setSlashIndex] = useState(0);
   const [showLinkModal, setShowLinkModal] = useState<boolean>(false);
+  const [showTodoMenu, setShowTodoMenu] = useState<boolean>(false);
 
   const textareaRef = useRef<HTMLTextAreaElement | null>(null);
   const debounceTimerRef = useRef<number | null>(null);
@@ -107,18 +118,17 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
   // Callback refs to avoid stale closures in setTimeout, debounce flush, and event listeners
   const onUpdateBlockRef = useRef(onUpdateBlock);
   onUpdateBlockRef.current = onUpdateBlock;
-  const onFocusBlockRef = useRef(onFocusBlock);
-  onFocusBlockRef.current = onFocusBlock;
   const onCreateBlockBelowRef = useRef(onCreateBlockBelow);
   onCreateBlockBelowRef.current = onCreateBlockBelow;
+  const onPasteMultiLinesRef = useRef(onPasteMultiLines);
+  onPasteMultiLinesRef.current = onPasteMultiLines;
   const onDeleteBlockRef = useRef(onDeleteBlock);
   onDeleteBlockRef.current = onDeleteBlock;
   const onIndentBlockRef = useRef(onIndentBlock);
   onIndentBlockRef.current = onIndentBlock;
   const onNavigateFocusRef = useRef(onNavigateFocus);
   onNavigateFocusRef.current = onNavigateFocus;
-  const sendCursorMovedRef = useRef(sendCursorMoved);
-  sendCursorMovedRef.current = sendCursorMoved;
+  const isPastingRef = useRef<boolean>(false);
 
   // Track if this input currently has actual focus in an active browser window
   const isFocusedRef = useRef<boolean>(false);
@@ -166,7 +176,6 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
         flushDebounce(localContentRef.current);
       }
       isFocusedRef.current = false;
-      sendCursorMovedRef.current?.(null);
     };
 
     const handleWindowFocus = () => {
@@ -203,7 +212,7 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
 
   useLayoutEffect(() => {
     adjustHeight();
-  }, [localContent, block.type, block.level, adjustHeight]);
+  }, [localContent, block.type, block.level, activeFocus, adjustHeight]);
 
   useEffect(() => {
     window.addEventListener('resize', adjustHeight);
@@ -279,7 +288,6 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
     }
 
     setLocalContent(val);
-    sendCursorMoved?.(block.id, e.target.selectionStart, e.target.selectionEnd);
 
     if (debounceTimerRef.current !== null) {
       window.clearTimeout(debounceTimerRef.current);
@@ -302,14 +310,20 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
     }, 150);
   };
 
-  const handleFocus = (e: React.FocusEvent<HTMLTextAreaElement>) => {
+  const handleFocus = () => {
     isFocusedRef.current = true;
-    onFocusBlockRef.current(block.id);
-    sendCursorMovedRef.current?.(block.id, e.target.selectionStart, e.target.selectionEnd);
+    setIsLocallyFocused(true);
+    onFocusBlock?.(block.id);
+    setTimeout(adjustHeight, 0);
   };
 
   const handleBlur = () => {
     isFocusedRef.current = false;
+    setIsLocallyFocused(false);
+    if (isPastingRef.current) {
+      isPastingRef.current = false;
+      return;
+    }
     if (debounceTimerRef.current !== null) {
       window.clearTimeout(debounceTimerRef.current);
       debounceTimerRef.current = null;
@@ -317,23 +331,30 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
     } else if (localContentRef.current !== latestBlockRef.current.content) {
       flushDebounce(localContentRef.current);
     }
-    sendCursorMovedRef.current?.(null);
   };
 
-  const handleClick = (e: React.MouseEvent<HTMLTextAreaElement>) => {
-    sendCursorMovedRef.current?.(block.id, e.currentTarget.selectionStart, e.currentTarget.selectionEnd);
-  };
+  const handlePaste = (e: React.ClipboardEvent<HTMLTextAreaElement>) => {
+    if (!canEdit || block.type === 'code') return;
+    const pastedText = e.clipboardData.getData('text');
+    if (!pastedText || !pastedText.includes('\n')) return;
 
-  const handleKeyUp = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
-    sendCursorMovedRef.current?.(block.id, e.currentTarget.selectionStart, e.currentTarget.selectionEnd);
-  };
+    e.preventDefault();
+    const rawLines = pastedText.split(/\r?\n/);
+    if (rawLines.length <= 1) return;
 
-  const handleSelect = (e: React.SyntheticEvent<HTMLTextAreaElement>) => {
-    const target = e.currentTarget;
-    sendCursorMovedRef.current?.(block.id, target.selectionStart, target.selectionEnd);
-  };
+    const start = e.currentTarget.selectionStart ?? localContent.length;
+    const end = e.currentTarget.selectionEnd ?? start;
+    const textBefore = localContent.slice(0, start);
+    const textAfter = localContent.slice(end);
 
-  const primaryRemoteCursor = activeRemoteCursors.length > 0 ? activeRemoteCursors[0] : null;
+    if (debounceTimerRef.current !== null) {
+      window.clearTimeout(debounceTimerRef.current);
+      debounceTimerRef.current = null;
+    }
+
+    isPastingRef.current = true;
+    onPasteMultiLinesRef.current?.(block.id, textBefore, textAfter, rawLines);
+  };
 
   const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
     if (!canEdit) return;
@@ -374,13 +395,49 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
       return;
     }
 
-    // 2. Enter (without Shift) -> Create new block on same level
+    // 2. Enter (without Shift) -> If block is completely empty:
+    //    - If level > minLevel, outdent (Shift+Tab behaviour)
+    //    - If already at minLevel and is the last block, do NOT create another empty block below
+    //    - Otherwise split paragraph at cursor and create new block below
     if (e.key === 'Enter' && !e.shiftKey && block.type !== 'code') {
       e.preventDefault();
       e.stopPropagation();
       setSlashSearch(null);
-      flushDebounce(localContent);
-      onCreateBlockBelowRef.current(block.id, localContent);
+
+      const minLevel = levelOffset || 0;
+      if (localContent === '') {
+        if (Math.max(0, block.level || 0) > minLevel) {
+          flushDebounce(localContent);
+          onIndentBlockRef.current(block.id, -1);
+          return;
+        }
+        if (isLast) {
+          // Bereits auf oberster Ebene und der letzte Block: kein weiterer leerer Block
+          return;
+        }
+      }
+
+      const start = e.currentTarget.selectionStart ?? localContent.length;
+      const end = e.currentTarget.selectionEnd ?? start;
+      let beforeText = localContent.slice(0, start);
+      let afterText = localContent.slice(end);
+
+      // Clean linebreaks at the split boundary if present
+      if (beforeText.endsWith('\r\n')) {
+        beforeText = beforeText.slice(0, -2);
+      } else if (beforeText.endsWith('\n')) {
+        beforeText = beforeText.slice(0, -1);
+      }
+      if (afterText.startsWith('\r\n')) {
+        afterText = afterText.slice(2);
+      } else if (afterText.startsWith('\n')) {
+        afterText = afterText.slice(1);
+      }
+
+      setLocalContent(beforeText);
+      localContentRef.current = beforeText;
+      flushDebounce(beforeText);
+      onCreateBlockBelowRef.current(block.id, afterText);
       return;
     }
 
@@ -422,6 +479,7 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
 
   const level = Math.max(0, block.level || 0);
   const visualLevel = Math.max(0, level - (levelOffset || 0));
+  const isEmpty = (!localContent || localContent.trim() === '') && !hasChildren;
 
   // Parse rich tokens (WikiLinks [[Page]], Markdown Links [Title](url), raw URLs, and #Tags)
   const tokens = useMemo(() => {
@@ -441,39 +499,29 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
 
   return (
     <div
-      className={`group relative flex items-start gap-1 py-1 rounded-card transition-all duration-300 ${
+      className={`group relative flex items-start gap-1 py-1 px-1.5 rounded-card transition-all duration-300 ${
         isDragTarget
           ? 'border-t-2 border-accent bg-accent/10'
           : isTargeted
           ? 'bg-accent/15 ring-2 ring-accent'
-          : isFocused
+          : activeFocus
           ? 'bg-panel-elevated'
           : 'hover:bg-panel'
       }`}
       style={{
         paddingLeft: `${visualLevel * 22 + 4}px`,
-        ...(primaryRemoteCursor
-          ? { borderLeft: `2px solid ${primaryRemoteCursor.userColor}` }
-          : {}),
       }}
       onDragOver={(e) => onDragOverBlock?.(e, index)}
       onDrop={() => onDropBlock?.(index)}
+      onClick={(e) => {
+        if ((e.target as HTMLElement).closest('button, a, input, select')) return;
+        if (!activeFocus && canEdit && textareaRef.current) {
+          textareaRef.current.focus();
+          const len = textareaRef.current.value.length;
+          textareaRef.current.setSelectionRange(len, len);
+        }
+      }}
     >
-      {/* Remote Cursors Floating Name Badges on Block */}
-      {activeRemoteCursors.length > 0 && (
-        <div className="absolute -top-2.5 right-2 z-20 flex items-center gap-1 select-none pointer-events-none">
-          {activeRemoteCursors.map((c) => (
-            <span
-              key={c.clientId}
-              className="text-[9px] font-bold px-1.5 py-0.5 rounded-btn text-white shadow-sm flex items-center gap-0.5"
-              style={{ backgroundColor: c.userColor }}
-            >
-              {c.userName}
-            </span>
-          ))}
-        </div>
-      )}
-
       {/* Indentation Guide Line */}
       {visualLevel > 0 &&
         Array.from({ length: visualLevel }).map((_, lvlIdx) => (
@@ -484,20 +532,8 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
           />
         ))}
 
-      {/* Bullet Controls: Drag Handle, Collapse Toggle, Bullet / Checkbox */}
+      {/* Bullet Controls: Collapse Toggle & Bullet (Drag-Handle & Zoom) / Checkbox */}
       <div className="flex items-center gap-0.5 pt-1 select-none shrink-0">
-        {canEdit && (
-          <button
-            type="button"
-            draggable
-            onDragStart={() => onDragStartBlock?.(index)}
-            title="Block ziehen oder umwandeln"
-            className="opacity-0 group-hover:opacity-100 focus:opacity-100 p-0.5 text-faint hover:text-main cursor-grab active:cursor-grabbing transition-opacity"
-          >
-            <GripVertical className="w-3.5 h-3.5" />
-          </button>
-        )}
-
         {hasChildren ? (
           <button
             type="button"
@@ -517,7 +553,38 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
           <span className="w-3.5" />
         )}
 
-        {block.type === 'todo' ? (
+        {/* Bullet handle for dragging and zoom focus */}
+        <button
+          type="button"
+          draggable={canEdit}
+          onDragStart={() => canEdit && onDragStartBlock?.(index)}
+          onClick={() => onZoomBlock?.(block.id)}
+          className={`w-4 h-4 flex items-center justify-center rounded-btn hover:bg-panel-hover group/bullet transition-transform ${
+            canEdit ? 'cursor-grab active:cursor-grabbing' : 'cursor-pointer'
+          }`}
+          title={
+            canEdit
+              ? 'Ziehen zum Verschieben • Klick: Ast hineinzoomen (Fokus-Modus)'
+              : 'Klick: In diesen Ast hineinzoomen (Fokus-Modus)'
+          }
+        >
+          <span
+            className={`w-1.5 h-1.5 rounded-full transition-all duration-150 ${
+              block.collapsed && hasChildren
+                ? 'bg-accent ring-2 ring-accent/30'
+                : activeFocus
+                ? 'bg-accent scale-125'
+                : 'bg-faint group-hover/bullet:bg-accent group-hover/bullet:scale-125'
+            } ${
+              isEmpty
+                ? 'opacity-0 group-hover:opacity-100 hover:opacity-100'
+                : 'opacity-100'
+            }`}
+          />
+        </button>
+
+        {/* If To-Do block: checkbox alongside bullet */}
+        {block.type === 'todo' && (
           <button
             type="button"
             disabled={!canEdit}
@@ -533,28 +600,11 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
           >
             <Check className="w-3 h-3 stroke-[3]" />
           </button>
-        ) : (
-          <button
-            type="button"
-            onClick={() => onZoomBlock?.(block.id)}
-            className="w-4 h-4 flex items-center justify-center rounded-btn hover:bg-panel-hover group/bullet transition-transform"
-            title="Klick: In diesen Ast hineinzoomen (Fokus-Modus)"
-          >
-            <span
-              className={`w-1.5 h-1.5 rounded-full transition-all ${
-                block.collapsed && hasChildren
-                  ? 'bg-accent ring-2 ring-accent/30'
-                  : isFocused
-                  ? 'bg-accent scale-125'
-                  : 'bg-faint group-hover/bullet:bg-accent group-hover/bullet:scale-125'
-              }`}
-            />
-          </button>
         )}
       </div>
 
       {/* Main Block Content */}
-      <div className="flex-1 min-w-0 pr-1 relative">
+      <div className="flex-1 min-w-0 pr-1 relative min-h-[1.5rem]">
         {block.type === 'divider' ? (
           <div className="py-2">
             <hr className="border-t border-border" />
@@ -581,9 +631,6 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
               readOnly={!canEdit}
               onFocus={handleFocus}
               onBlur={handleBlur}
-              onClick={handleClick}
-              onKeyUp={handleKeyUp}
-              onSelect={handleSelect}
               onChange={handleContentChange}
               onKeyDown={handleKeyDown}
               className="w-full resize-none font-mono text-xs bg-transparent text-status-ok border-0 focus:outline-none focus:ring-0 leading-relaxed"
@@ -601,16 +648,133 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
               readOnly={!canEdit}
               onFocus={handleFocus}
               onBlur={handleBlur}
-              onClick={handleClick}
-              onKeyUp={handleKeyUp}
-              onSelect={handleSelect}
               onChange={handleContentChange}
               onKeyDown={handleKeyDown}
               className="w-full resize-none bg-transparent text-sm text-main border-0 focus:outline-none focus:ring-0 leading-relaxed italic"
             />
           </div>
         ) : (
-          <div className="relative w-full">
+          <div className="relative w-full min-h-[1.5rem]">
+            {/* View Layer with Inline Markdown & Actions (3-dots or Erweitert Badge) directly behind text */}
+            <div
+              onClick={() => {
+                if (!activeFocus && canEdit && textareaRef.current) {
+                  textareaRef.current.focus();
+                  const len = textareaRef.current.value.length;
+                  textareaRef.current.setSelectionRange(len, len);
+                }
+              }}
+              className={`w-full min-h-[1.5rem] leading-relaxed whitespace-pre-wrap break-words [overflow-wrap:anywhere] ${
+                activeFocus ? 'absolute inset-0 pointer-events-none' : 'relative cursor-text'
+              } ${
+                block.type === 'h1'
+                  ? 'text-lg font-bold text-main tracking-tight'
+                  : block.type === 'h2'
+                  ? 'text-base font-semibold text-main'
+                  : block.type === 'h3'
+                  ? 'text-sm font-semibold text-main'
+                  : block.type === 'todo' && block.checked
+                  ? 'text-sm text-faint line-through'
+                  : 'text-sm text-main'
+              }`}
+            >
+              {/* When actively focused, ghost text is invisible so textarea renders text/caret directly */}
+              <span className={activeFocus ? 'invisible' : ''}>
+                {localContent ? renderInlineMarkdown(localContent) : '\u200b'}
+              </span>
+
+              {/* Inline Badge and 3-Dots directly behind the text */}
+              {block.type === 'todo' && (
+                <span className="inline-flex items-center align-middle ml-1.5 gap-1 shrink-0 pointer-events-auto z-10 relative select-none">
+                  {block.taskId && (
+                    <span
+                      className="badge-accent text-[9px] inline-flex items-center gap-0.5 px-1.5 py-0.2 rounded font-medium shrink-0"
+                      title="Mit erweiterter Aufgabe synchronisiert"
+                    >
+                      <CheckSquare className="w-2.5 h-2.5" />
+                      <span>Erweitert</span>
+                    </span>
+                  )}
+
+                  {canEdit && (
+                    <span className="relative inline-flex items-center">
+                      <button
+                        type="button"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setShowTodoMenu((prev) => !prev);
+                        }}
+                        className="p-0.5 text-faint hover:text-accent rounded-btn transition-colors cursor-pointer"
+                        title="Aufgaben-Optionen"
+                      >
+                        <MoreHorizontal className="w-3.5 h-3.5" />
+                      </button>
+                      {showTodoMenu && (
+                        <div
+                          className="absolute left-0 top-full mt-1 bg-panel border border-border shadow-lg rounded-card p-1 z-30 w-52 text-xs"
+                          onClick={(e) => e.stopPropagation()}
+                        >
+                          {!block.taskId ? (
+                            <button
+                              type="button"
+                              onClick={async () => {
+                                setShowTodoMenu(false);
+                                try {
+                                  const targetDocId = docId || block.documentId || block.docId || '';
+                                  const thought = await api.createEnhancedTask(targetDocId, block.id, {
+                                    content: localContent || 'Aufgabe',
+                                    checked: Boolean(block.checked),
+                                  });
+                                  const updatedBlock: DocumentBlock = {
+                                    ...latestBlockRef.current,
+                                    content: localContent,
+                                    taskId: thought.id,
+                                    type: 'todo',
+                                  };
+                                  onUpdateBlockRef.current(updatedBlock, true);
+                                } catch (err: any) {
+                                  alert(err.message || 'Fehler beim Erstellen der erweiterten Aufgabe');
+                                }
+                              }}
+                              className="w-full text-left px-2 py-1.5 rounded-btn hover:bg-panel-elevated hover:text-accent flex items-center gap-1.5 text-main font-medium cursor-pointer"
+                            >
+                              <CheckSquare className="w-3.5 h-3.5 text-accent" />
+                              <span>In erweiterte Aufgabe umwandeln</span>
+                            </button>
+                          ) : (
+                            <button
+                              type="button"
+                              onClick={async () => {
+                                setShowTodoMenu(false);
+                                try {
+                                  if (block.taskId) {
+                                    await api.unlinkEnhancedTask(block.taskId).catch(() => {});
+                                  }
+                                  const updatedBlock: DocumentBlock = {
+                                    ...latestBlockRef.current,
+                                    content: localContent,
+                                    taskId: '',
+                                    type: 'todo',
+                                  };
+                                  onUpdateBlockRef.current(updatedBlock, true);
+                                } catch (err: any) {
+                                  alert(err.message || 'Fehler beim Aufheben der Verknüpfung');
+                                }
+                              }}
+                              className="w-full text-left px-2 py-1.5 rounded-btn hover:bg-panel-elevated hover:text-status-warn flex items-center gap-1.5 text-main font-medium cursor-pointer"
+                            >
+                              <X className="w-3.5 h-3.5 text-status-warn" />
+                              <span>Verknüpfung aufheben</span>
+                            </button>
+                          )}
+                        </div>
+                      )}
+                    </span>
+                  )}
+                </span>
+              )}
+            </div>
+
             <textarea
               ref={(el) => {
                 textareaRef.current = el;
@@ -621,17 +785,12 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
               readOnly={!canEdit}
               onFocus={handleFocus}
               onBlur={handleBlur}
-              onClick={handleClick}
-              onKeyUp={handleKeyUp}
-              onSelect={handleSelect}
               onChange={handleContentChange}
               onKeyDown={handleKeyDown}
-              placeholder={
-                index === 0 && level === 0
-                  ? 'Schreibe einen Punkt… (Enter = Neu, Tab = Einrücken, Shift+Tab = Ausrücken, / für Befehle)'
-                  : ''
-              }
-              className={`w-full resize-none overflow-hidden bg-transparent border-0 focus:outline-none focus:ring-0 leading-relaxed whitespace-pre-wrap break-words ${
+              onPaste={handlePaste}
+              className={`w-full min-h-[1.5rem] resize-none overflow-hidden bg-transparent border-0 focus:outline-none focus:ring-0 leading-relaxed whitespace-pre-wrap break-words [overflow-wrap:anywhere] ${
+                activeFocus ? 'relative z-0 text-main' : 'absolute inset-0 text-transparent selection:text-transparent pointer-events-none'
+              } ${
                 block.type === 'h1'
                   ? 'text-lg font-bold text-main tracking-tight'
                   : block.type === 'h2'
@@ -643,45 +802,6 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
                   : 'text-sm text-main'
               }`}
             />
-
-            {/* Remote Caret & Floating Name Tag Overlay */}
-            {primaryRemoteCursor &&
-              primaryRemoteCursor.selectionStart !== undefined &&
-              primaryRemoteCursor.selectionStart !== null && (
-                <div
-                  aria-hidden="true"
-                  className={`pointer-events-none absolute inset-0 overflow-hidden leading-relaxed whitespace-pre-wrap break-words select-none z-10 ${
-                    block.type === 'h1'
-                      ? 'text-lg font-bold tracking-tight'
-                      : block.type === 'h2'
-                      ? 'text-base font-semibold'
-                      : block.type === 'h3'
-                      ? 'text-sm font-semibold'
-                      : block.type === 'todo' && block.checked
-                      ? 'text-sm text-faint line-through'
-                      : 'text-sm'
-                  }`}
-                >
-                  <span className="opacity-0">
-                    {localContent.slice(
-                      0,
-                      Math.min(primaryRemoteCursor.selectionStart, localContent.length)
-                    )}
-                  </span>
-                  <span className="relative inline-block align-baseline">
-                    <span
-                      className="inline-block w-[2px] h-[1.15em] -mb-0.5 animate-pulse"
-                      style={{ backgroundColor: primaryRemoteCursor.userColor }}
-                    />
-                    <span
-                      className="absolute -top-3.5 left-0 text-[8px] font-bold px-1 py-0 rounded-btn text-white whitespace-nowrap shadow-sm"
-                      style={{ backgroundColor: primaryRemoteCursor.userColor }}
-                    >
-                      {primaryRemoteCursor.userName}
-                    </span>
-                  </span>
-                </div>
-              )}
           </div>
         )}
 
@@ -804,15 +924,23 @@ export const OutlinerBlock: React.FC<OutlinerBlockProps> = ({
         <Maximize2 className="w-3.5 h-3.5" />
       </button>
 
-      {/* Delete button on hover */}
+      {/* Delete button on hover (Trash2 icon) */}
       {canEdit && (
         <button
           type="button"
-          onClick={() => onDeleteBlockRef.current(block.id)}
-          className="opacity-0 group-hover:opacity-100 focus:opacity-100 p-0.5 text-faint hover:text-status-err rounded-btn transition-opacity shrink-0"
+          onClick={() => {
+            if (hasChildren) {
+              if (window.confirm('Bist du sicher? Alle Unterpunkte dieses Asts werden ebenfalls gelöscht.')) {
+                onDeleteBlockRef.current(block.id, true);
+              }
+            } else {
+              onDeleteBlockRef.current(block.id, false);
+            }
+          }}
+          className="opacity-0 group-hover:opacity-100 focus:opacity-100 p-0.5 text-faint hover:text-status-err rounded-btn transition-opacity shrink-0 cursor-pointer"
           title="Block löschen"
         >
-          <X className="w-3.5 h-3.5" />
+          <Trash2 className="w-3.5 h-3.5" />
         </button>
       )}
 

frontend/src/features/workspace/OutlinerTree.tsx

@@ -1,42 +1,47 @@
-import React, { useState, useRef, useEffect, useCallback, useMemo } from 'react';
-import { Plus } from 'lucide-react';
-import { DocumentBlock } from '../../lib/types';
-import { RemoteCursor } from '../../lib/useDocumentSync';
+import React, { useState, useRef, useEffect, useCallback, useMemo, forwardRef, useImperativeHandle } from 'react';
+import { DocumentBlock, BlockType } from '../../lib/types';
 import { OutlinerBlock } from './OutlinerBlock';
 
+export interface OutlinerTreeHandle {
+  focusFirstBlock: () => void;
+  focusBlock: (blockId: string, cursor?: 'start' | 'end') => void;
+}
+
 export interface OutlinerTreeProps {
   docId: string;
   blocks: DocumentBlock[];
   canEdit: boolean;
   levelOffset?: number;
   onZoomBlock?: (blockId: string) => void;
-  remoteCursors?: Record<string, RemoteCursor>;
-  sendCursorMoved?: (blockId: string | null, selectionStart?: number, selectionEnd?: number) => void;
   onUpdateBlock: (updated: DocumentBlock, immediate?: boolean) => void;
+  onUpdateBlocks?: (updated: DocumentBlock[]) => void;
   onCreateBlock: (newBlock: DocumentBlock, afterBlockId?: string) => void;
+  onInsertBlocks?: (afterBlockId: string, updatedCurrent: DocumentBlock, newBlocks: DocumentBlock[]) => void;
   onDeleteBlock: (blockId: string) => void;
   onMoveBlock: (blockId: string, newIndex: number, level?: number) => void;
+  onOpenTask?: (taskId: string) => void;
   onTagClick?: (tag: string) => void;
   onWikiLinkClick?: (pageTitle: string) => void;
   initialFocusedBlockId?: string | null;
 }
 
-export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
+export const OutlinerTree = forwardRef<OutlinerTreeHandle, OutlinerTreeProps>(({
   docId,
   blocks,
   canEdit,
   levelOffset = 0,
   onZoomBlock,
-  remoteCursors,
-  sendCursorMoved,
   onUpdateBlock,
+  onUpdateBlocks,
   onCreateBlock,
+  onInsertBlocks,
   onDeleteBlock,
   onMoveBlock,
+  onOpenTask,
   onTagClick,
   onWikiLinkClick,
   initialFocusedBlockId,
-}) => {
+}, ref) => {
   const [focusedBlockId, setFocusedBlockId] = useState<string | null>(null);
   const [highlightedBlockId, setHighlightedBlockId] = useState<string | null>(
     initialFocusedBlockId || null
@@ -73,6 +78,32 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
     []
   );
 
+  useImperativeHandle(
+    ref,
+    () => ({
+      focusFirstBlock: () => {
+        if (blocks.length > 0) {
+          focusBlockInput(blocks[0].id, 'end');
+        } else {
+          const firstBlock: DocumentBlock = {
+            id: `blk_${Date.now().toString(36)}_0`,
+            documentId: docId,
+            type: 'text',
+            content: '',
+            level: levelOffset || 0,
+            position: 1000,
+          };
+          pendingFocusRef.current = { blockId: firstBlock.id, cursor: 'end' };
+          onCreateBlock(firstBlock);
+        }
+      },
+      focusBlock: (blockId: string, cursor: 'start' | 'end' = 'end') => {
+        focusBlockInput(blockId, cursor);
+      },
+    }),
+    [blocks, docId, levelOffset, onCreateBlock, focusBlockInput]
+  );
+
   const registerTextareaRef = useCallback((blockId: string, el: HTMLTextAreaElement | null) => {
     if (el) {
       textareaMapRef.current.set(blockId, el);
@@ -164,22 +195,21 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
     }
 
     return result;
-  }, [blocks]);
+  }, [blocks, levelOffset]);
 
   const handleCreateBlockBelow = useCallback(
-    (afterBlockId: string, _currentContent: string) => {
+    (afterBlockId: string, newContent: string = '') => {
       if (!canEdit) return;
       const idx = blocks.findIndex((b) => b.id === afterBlockId);
       const currentBlock = idx >= 0 ? blocks[idx] : null;
       const level = currentBlock ? Math.max(0, currentBlock.level || 0) : 0;
-      const inheritedType =
-        currentBlock && currentBlock.type === 'todo' ? 'todo' : 'text';
+      const inheritedType: BlockType = 'text';
 
       const newBlock: DocumentBlock = {
         id: `blk_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
         documentId: docId,
         type: inheritedType,
-        content: '',
+        content: newContent,
         level,
         checked: false,
         collapsed: false,
@@ -193,8 +223,252 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
     [blocks, canEdit, docId, onCreateBlock]
   );
 
+  const handlePasteMultiLines = useCallback(
+    (blockId: string, textBefore: string, textAfter: string, rawLines: string[]) => {
+      if (!canEdit || rawLines.length === 0) return;
+      const idx = blocks.findIndex((b) => b.id === blockId);
+      if (idx === -1) return;
+
+      const currentBlock = blocks[idx];
+      const baseLevel = Math.max(0, currentBlock.level || 0);
+
+      // Detect indentation style (2-space vs 4-space tabs)
+      let detectedSpaceStep = 2;
+      const leadingSpacesList: number[] = [];
+      for (const line of rawLines) {
+        if (!line.trim()) continue;
+        let sp = 0;
+        while (sp < line.length && line[sp] === ' ') sp++;
+        if (sp > 0) leadingSpacesList.push(sp);
+      }
+      if (leadingSpacesList.length > 0 && leadingSpacesList.every((s) => s % 4 === 0)) {
+        detectedSpaceStep = 4;
+      }
+
+      // Parse lines into structured blocks
+      interface ParsedPasteItem {
+        type: BlockType;
+        checked?: boolean;
+        content: string;
+        indent: number;
+      }
+
+      const parsed: ParsedPasteItem[] = [];
+      let currentItem: ParsedPasteItem | null = null;
+      let inCodeBlock = false;
+      let afterHeading = false;
+
+      const pushCurrentItem = () => {
+        if (currentItem) {
+          currentItem.content = currentItem.content.trimEnd();
+          parsed.push(currentItem);
+          currentItem = null;
+        }
+      };
+
+      for (let i = 0; i < rawLines.length; i++) {
+        const rawLine = rawLines[i];
+
+        // 1. Inside a fenced code block
+        if (inCodeBlock) {
+          if (currentItem) {
+            currentItem.content += '\n' + rawLine;
+          }
+          if (rawLine.trim().startsWith('```')) {
+            inCodeBlock = false;
+          }
+          continue;
+        }
+
+        // 2. Starts a code fence
+        if (rawLine.trim().startsWith('```')) {
+          inCodeBlock = true;
+          if (afterHeading) {
+            afterHeading = false;
+            pushCurrentItem();
+            currentItem = {
+              type: 'text',
+              content: rawLine,
+              indent: 0,
+            };
+          } else if (currentItem) {
+            currentItem.content += (currentItem.content.endsWith('\n') ? '' : '\n') + rawLine;
+          } else {
+            currentItem = {
+              type: 'text',
+              content: rawLine,
+              indent: 0,
+            };
+          }
+          continue;
+        }
+
+        // Measure leading indent
+        let tabs = 0;
+        let spaces = 0;
+        let charIdx = 0;
+        while (charIdx < rawLine.length) {
+          if (rawLine[charIdx] === '\t') {
+            tabs++;
+            charIdx++;
+          } else if (rawLine[charIdx] === ' ') {
+            spaces++;
+            charIdx++;
+          } else {
+            break;
+          }
+        }
+        const strippedLine = rawLine.slice(charIdx);
+        const lineIndent = tabs + Math.floor(spaces / detectedSpaceStep);
+
+        // Blank lines
+        if (strippedLine.trim() === '') {
+          if (currentItem) {
+            currentItem.content += '\n';
+          }
+          continue;
+        }
+
+        // Headings: #, ##, ###
+        const h3Match = strippedLine.match(/^###\s+(.*)$/);
+        const h2Match = strippedLine.match(/^##\s+(.*)$/);
+        const h1Match = strippedLine.match(/^#\s+(.*)$/);
+        if (h1Match || h2Match || h3Match) {
+          pushCurrentItem();
+          afterHeading = true;
+          const type: BlockType = h1Match ? 'h1' : h2Match ? 'h2' : 'h3';
+          const content = (h1Match || h2Match || h3Match)![1];
+          parsed.push({ type, content, indent: lineIndent });
+          continue;
+        }
+
+        // Dividers: ---, ***, ___
+        if (/^(?:---|---|\*\*\*|___)\s*$/.test(strippedLine.trim())) {
+          pushCurrentItem();
+          afterHeading = false;
+          parsed.push({ type: 'divider', content: '---', indent: lineIndent });
+          continue;
+        }
+
+        // Todo items: - [ ], - [x], * [ ], * [x]
+        const todoMatch = strippedLine.match(/^[-*]\s*\[([ xX])\]\s*(.*)$/);
+        if (todoMatch) {
+          pushCurrentItem();
+          afterHeading = false;
+          parsed.push({
+            type: 'todo',
+            checked: todoMatch[1].toLowerCase() === 'x',
+            content: todoMatch[2],
+            indent: lineIndent,
+          });
+          continue;
+        }
+
+        // Explicit bullet or numbered list: - item, * item, • item, 1. item, 1) item
+        const bulletMatch = strippedLine.match(/^[-*•]\s+(.*)$/);
+        const numMatch = strippedLine.match(/^\d+[\.\)]\s+(.*)$/);
+        if (bulletMatch || numMatch) {
+          pushCurrentItem();
+          afterHeading = false;
+          parsed.push({
+            type: 'text',
+            content: (bulletMatch ? bulletMatch[1] : numMatch![1]),
+            indent: lineIndent,
+          });
+          continue;
+        }
+
+        // Regular text line
+        if (afterHeading) {
+          // This starts the single bullet point after the heading
+          afterHeading = false;
+          pushCurrentItem();
+          currentItem = {
+            type: 'text',
+            content: strippedLine,
+            indent: lineIndent,
+          };
+        } else if (currentItem) {
+          if (currentItem.content.endsWith('\n')) {
+            currentItem.content += strippedLine;
+          } else {
+            currentItem.content += '\n' + strippedLine;
+          }
+        } else {
+          currentItem = {
+            type: 'text',
+            content: strippedLine,
+            indent: lineIndent,
+          };
+        }
+      }
+
+      pushCurrentItem();
+
+      if (parsed.length === 0) return;
+
+      const line0 = parsed[0];
+      const baseIndent = line0.indent;
+      const isSingle = parsed.length === 1;
+      const line0Content = textBefore + line0.content + (isSingle ? textAfter : '');
+
+      const isCurrentEmpty = (currentBlock.content || '').trim() === '';
+      const adoptedType = line0.type !== 'text' ? line0.type : (isCurrentEmpty ? 'text' : currentBlock.type);
+      const adoptedChecked = line0.type === 'todo' ? (line0.checked ?? false) : currentBlock.checked;
+
+      const updatedCurrentBlock: DocumentBlock = {
+        ...currentBlock,
+        content: line0Content,
+        type: adoptedType,
+        checked: adoptedChecked,
+      };
+
+      const newBlocks: DocumentBlock[] = [];
+      const nowBase = Date.now().toString(36);
+
+      for (let j = 1; j < parsed.length; j++) {
+        const p = parsed[j];
+        const isLastLine = j === parsed.length - 1;
+        const lineContent = isLastLine ? (p.content + textAfter) : p.content;
+        const lineLevel = Math.max(0, baseLevel + (p.indent - baseIndent));
+
+        newBlocks.push({
+          id: `blk_${nowBase}_${j}_${Math.random().toString(36).slice(2, 6)}`,
+          documentId: docId,
+          type: p.type,
+          checked: p.checked || false,
+          content: lineContent,
+          level: lineLevel,
+          collapsed: false,
+          position: (currentBlock.position || 1000) + j * 10,
+        });
+      }
+
+      const lastTargetId = newBlocks.length > 0 ? newBlocks[newBlocks.length - 1].id : currentBlock.id;
+      const existingEl = textareaMapRef.current.get(lastTargetId);
+      if (existingEl) {
+        pendingFocusRef.current = null;
+        focusBlockInput(lastTargetId, 'end');
+      } else {
+        pendingFocusRef.current = { blockId: lastTargetId, cursor: 'end' };
+      }
+      setFocusedBlockId(lastTargetId);
+
+      if (onInsertBlocks) {
+        onInsertBlocks(currentBlock.id, updatedCurrentBlock, newBlocks);
+      } else {
+        onUpdateBlock(updatedCurrentBlock, true);
+        for (let k = 0; k < newBlocks.length; k++) {
+          const afterId = k === 0 ? currentBlock.id : newBlocks[k - 1].id;
+          onCreateBlock(newBlocks[k], afterId);
+        }
+      }
+    },
+    [blocks, canEdit, docId, focusBlockInput, onCreateBlock, onInsertBlocks, onUpdateBlock]
+  );
+
   const handleDeleteBlock = useCallback(
-    (blockId: string) => {
+    (blockId: string, deleteSubtree = false) => {
       if (!canEdit) return;
       const idx = blocks.findIndex((b) => b.id === blockId);
       if (idx === -1) return;
@@ -219,9 +493,25 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
       if (targetFocusBlock) {
         focusBlockInput(targetFocusBlock.id, 'end');
       }
-      onDeleteBlock(blockId);
+
+      if (deleteSubtree) {
+        const rootLevel = blocks[idx].level || 0;
+        const idsToDelete = [blockId];
+        for (let j = idx + 1; j < blocks.length; j++) {
+          if ((blocks[j].level || 0) > rootLevel) {
+            idsToDelete.push(blocks[j].id);
+          } else {
+            break;
+          }
+        }
+        for (const id of idsToDelete) {
+          onDeleteBlock(id);
+        }
+      } else {
+        onDeleteBlock(blockId);
+      }
     },
-    [blocks, canEdit, focusBlockInput, onDeleteBlock, onUpdateBlock]
+    [blocks, canEdit, focusBlockInput, levelOffset, onDeleteBlock, onUpdateBlock]
   );
 
   const handleIndentBlock = useCallback(
@@ -233,9 +523,9 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
       const current = blocks[idx];
       const currentLevel = Math.max(0, current.level || 0);
       const prevLevel = idx > 0 ? Math.max(0, blocks[idx - 1].level || 0) : 0;
-      const maxLevel = idx === 0 ? 0 : prevLevel + 1;
-
       const minLevel = levelOffset || 0;
+      const maxLevel = idx === 0 ? minLevel : prevLevel + 1;
+
       const nextLevel =
         delta === 1
           ? Math.min(maxLevel, currentLevel + 1)
@@ -243,15 +533,38 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
 
       if (nextLevel === currentLevel) return;
 
-      onUpdateBlock(
-        {
-          ...current,
-          level: nextLevel,
-        },
-        true
-      );
+      const actualDelta = nextLevel - currentLevel;
+
+      // Find all contiguous children / descendants:
+      // contiguous blocks with level > currentLevel
+      let count = 1;
+      for (let i = idx + 1; i < blocks.length; i++) {
+        if (Math.max(0, blocks[i].level || 0) > currentLevel) {
+          count++;
+        } else {
+          break;
+        }
+      }
+
+      const updatedBlocks: DocumentBlock[] = [];
+      for (let i = idx; i < idx + count; i++) {
+        const b = blocks[i];
+        const newLvl = Math.max(minLevel, (b.level || 0) + actualDelta);
+        updatedBlocks.push({
+          ...b,
+          level: newLvl,
+        });
+      }
+
+      if (onUpdateBlocks) {
+        onUpdateBlocks(updatedBlocks);
+      } else {
+        for (const b of updatedBlocks) {
+          onUpdateBlock(b, true);
+        }
+      }
     },
-    [blocks, canEdit, onUpdateBlock]
+    [blocks, canEdit, levelOffset, onUpdateBlock, onUpdateBlocks]
   );
 
   const handleNavigateFocus = useCallback(
@@ -274,10 +587,29 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
     setDraggedIndex(index);
   }, []);
 
-  const handleDragOverBlock = useCallback((e: React.DragEvent, index: number) => {
-    e.preventDefault();
-    setDragOverIndex(index);
-  }, []);
+  const handleDragOverBlock = useCallback(
+    (e: React.DragEvent, index: number) => {
+      e.preventDefault();
+      if (draggedIndex !== null) {
+        const parentLevel = Math.max(0, blocks[draggedIndex]?.level || 0);
+        let count = 1;
+        for (let i = draggedIndex + 1; i < blocks.length; i++) {
+          if (Math.max(0, blocks[i].level || 0) > parentLevel) {
+            count++;
+          } else {
+            break;
+          }
+        }
+        // Do not allow dropping inside its own subtree (self or descendants)
+        if (index >= draggedIndex && index < draggedIndex + count) {
+          setDragOverIndex(null);
+          return;
+        }
+      }
+      setDragOverIndex(index);
+    },
+    [blocks, draggedIndex]
+  );
 
   const handleDropBlock = useCallback(
     (targetIndex: number) => {
@@ -286,6 +618,20 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
         setDragOverIndex(null);
         return;
       }
+      const parentLevel = Math.max(0, blocks[draggedIndex]?.level || 0);
+      let count = 1;
+      for (let i = draggedIndex + 1; i < blocks.length; i++) {
+        if (Math.max(0, blocks[i].level || 0) > parentLevel) {
+          count++;
+        } else {
+          break;
+        }
+      }
+      if (targetIndex >= draggedIndex && targetIndex < draggedIndex + count) {
+        setDraggedIndex(null);
+        setDragOverIndex(null);
+        return;
+      }
       const movingBlock = blocks[draggedIndex];
       if (movingBlock) {
         onMoveBlock(movingBlock.id, targetIndex, movingBlock.level);
@@ -305,78 +651,81 @@ export const OutlinerTree: React.FC<OutlinerTreeProps> = ({
     return () => window.removeEventListener('dragend', clearDrag);
   }, []);
 
-  const cursorsByBlock = useMemo(() => {
-    const map: Record<string, RemoteCursor[]> = {};
-    if (!remoteCursors) return map;
-    for (const c of Object.values(remoteCursors)) {
-      if (c.blockId) {
-        if (!map[c.blockId]) map[c.blockId] = [];
-        map[c.blockId].push(c);
-      }
-    }
-    return map;
-  }, [remoteCursors]);
-
   return (
     <div className="space-y-0.5">
-      {visibleEntries.map(({ block, index, hasChildren, maxAllowedLevel }) => (
-        <OutlinerBlock
-          key={block.id}
-          block={block}
-          index={index}
-          maxAllowedLevel={maxAllowedLevel}
-          hasChildren={hasChildren}
-          isFocused={focusedBlockId === block.id}
-          canEdit={canEdit}
-          levelOffset={levelOffset}
-          onZoomBlock={onZoomBlock}
-          activeRemoteCursors={cursorsByBlock[block.id] || []}
-          sendCursorMoved={sendCursorMoved}
-          onFocusBlock={setFocusedBlockId}
-          onUpdateBlock={onUpdateBlock}
-          onCreateBlockBelow={handleCreateBlockBelow}
-          onDeleteBlock={handleDeleteBlock}
-          onIndentBlock={handleIndentBlock}
-          onNavigateFocus={handleNavigateFocus}
-          onTagClick={onTagClick}
-          onWikiLinkClick={onWikiLinkClick}
-          onDragStartBlock={handleDragStartBlock}
-          onDragOverBlock={handleDragOverBlock}
-          onDropBlock={handleDropBlock}
-          isDragTarget={dragOverIndex === index && draggedIndex !== index}
-          isTargeted={highlightedBlockId === block.id}
-          registerTextareaRef={registerTextareaRef}
-        />
-      ))}
+      {visibleEntries.map(({ block, index, hasChildren, maxAllowedLevel }, entryIdx) => {
+        const isLast = entryIdx === visibleEntries.length - 1;
+        return (
+          <OutlinerBlock
+            key={block.id}
+            docId={docId}
+            block={block}
+            index={index}
+            isLast={isLast}
+            maxAllowedLevel={maxAllowedLevel}
+            hasChildren={hasChildren}
+            isFocused={focusedBlockId === block.id}
+            canEdit={canEdit}
+            levelOffset={levelOffset}
+            onZoomBlock={onZoomBlock}
+            onUpdateBlock={onUpdateBlock}
+            onCreateBlockBelow={handleCreateBlockBelow}
+            onPasteMultiLines={handlePasteMultiLines}
+            onDeleteBlock={handleDeleteBlock}
+            onIndentBlock={handleIndentBlock}
+            onNavigateFocus={handleNavigateFocus}
+            onFocusBlock={setFocusedBlockId}
+            onOpenTask={onOpenTask}
+            onTagClick={onTagClick}
+            onWikiLinkClick={onWikiLinkClick}
+            onDragStartBlock={handleDragStartBlock}
+            onDragOverBlock={handleDragOverBlock}
+            onDropBlock={handleDropBlock}
+            isDragTarget={dragOverIndex === index && draggedIndex !== index}
+            isTargeted={highlightedBlockId === block.id}
+            registerTextareaRef={registerTextareaRef}
+          />
+        );
+      })}
 
       {canEdit && (
-        <div className="pt-2 pl-2">
-          <button
-            type="button"
-            onClick={() => {
+        <div
+          className={`min-h-[14rem] pt-2 pl-2 transition-colors cursor-text ${
+            dragOverIndex === blocks.length ? 'border-t-2 border-accent bg-accent/10 rounded' : ''
+          }`}
+          onClick={(e) => {
+            if (e.target !== e.currentTarget && (e.target as HTMLElement).closest('button, a, input, textarea, select')) {
+              return;
+            }
+            if (blocks.length === 0) {
+              const firstBlock: DocumentBlock = {
+                id: `blk_${Date.now().toString(36)}_0`,
+                documentId: docId,
+                type: 'text',
+                content: '',
+                level: levelOffset || 0,
+                position: 1000,
+              };
+              pendingFocusRef.current = { blockId: firstBlock.id, cursor: 'start' };
+              onCreateBlock(firstBlock);
+            } else {
               const lastBlock = blocks[blocks.length - 1];
-              if (lastBlock) {
-                handleCreateBlockBelow(lastBlock.id, lastBlock.content);
+              if (lastBlock.content && lastBlock.content.trim() !== '') {
+                handleCreateBlockBelow(lastBlock.id, '');
               } else {
-                const firstBlock: DocumentBlock = {
-                  id: `blk_${Date.now().toString(36)}_0`,
-                  documentId: docId,
-                  type: 'text',
-                  content: '',
-                  level: levelOffset || 0,
-                  position: 1000,
-                };
-                pendingFocusRef.current = { blockId: firstBlock.id, cursor: 'start' };
-                onCreateBlock(firstBlock);
+                focusBlockInput(lastBlock.id, 'end');
               }
-            }}
-            className="btn-action inline-flex items-center gap-1.5 px-2.5 py-1 text-xs text-muted hover:text-main"
-          >
-            <Plus className="w-3.5 h-3.5" />
-            <span>Neuer Punkt</span>
-          </button>
-        </div>
+            }
+          }}
+          onDragOver={(e) => {
+            e.preventDefault();
+            if (draggedIndex !== null) {
+              setDragOverIndex(blocks.length);
+            }
+          }}
+          onDrop={() => handleDropBlock(blocks.length)}
+        />
       )}
     </div>
   );
-};
+});

frontend/src/lib/api.ts

@@ -5,7 +5,6 @@ import {
   Document,
   DocumentBlock,
   DocShare,
-  DocLockInfo,
   KanbanColumn,
   ListItem,
   ListShare,
@@ -37,6 +36,19 @@ export function getToken(): string | null {
   return localStorage.getItem(TOKEN_STORAGE_KEY);
 }
 
+export function getCurrentUserId(): string | null {
+  const token = getToken();
+  if (!token) return null;
+  try {
+    const parts = token.split('.');
+    if (parts.length >= 2) {
+      const payload = JSON.parse(atob(parts[1]));
+      return payload.userId || payload.sub || payload.id || null;
+    }
+  } catch {}
+  return null;
+}
+
 export function setToken(token: string): void {
   localStorage.setItem(TOKEN_STORAGE_KEY, token);
 }
@@ -117,6 +129,18 @@ export const api = {
     return request<AuthStatus>('/api/v1/auth/status');
   },
 
+  async logout(): Promise<void> {
+    try {
+      await request<{ success: boolean }>('/api/v1/auth/logout', { method: 'POST' });
+    } finally {
+      clearToken();
+    }
+  },
+
+  async revokeAllSessions(): Promise<void> {
+    await request<{ success: boolean }>('/api/v1/auth/revoke-all', { method: 'POST' });
+  },
+
   async completeSetup(payload: {
     email: string;
     password: string;
@@ -285,6 +309,10 @@ export const api = {
     return ensureArray(res);
   },
 
+  async getThought(thoughtId: string): Promise<Thought> {
+    return request<Thought>(`/api/v1/thoughts/${encodeURIComponent(thoughtId)}`);
+  },
+
   async triageAction(
     thoughtId: string,
     action: 'keep' | 'discard' | 'restore',
@@ -402,7 +430,7 @@ export const api = {
 
   async addTaskListShare(
     id: string,
-    payload: { targetType: 'team' | 'user'; targetId: string }
+    payload: { targetType: 'team' | 'user'; targetId: string; permission?: 'editor' | 'viewer' }
   ): Promise<TaskListShare> {
     return request<TaskListShare>(`/api/v1/task-lists/${id}/shares`, {
       method: 'POST',
@@ -625,6 +653,23 @@ export const api = {
     };
   },
 
+  async createEnhancedTask(
+    docId: string,
+    blockId: string,
+    payload: { content: string; checked: boolean }
+  ): Promise<Thought> {
+    return request<Thought>(`/api/v1/documents/${docId}/blocks/${blockId}/enhanced-task`, {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    });
+  },
+
+  async unlinkEnhancedTask(taskId: string): Promise<{ unlinked: boolean }> {
+    return request<{ unlinked: boolean }>(`/api/v1/tasks/${encodeURIComponent(taskId)}/unlink`, {
+      method: 'POST',
+    });
+  },
+
   // --- DOCUMENT SHARING ---
   async getDocShares(docId: string): Promise<DocShare[]> {
     const res = await request<DocShare[]>(`/api/v1/documents/${docId}/shares`);
@@ -772,6 +817,17 @@ export const api = {
     });
   },
 
+  async updateListItem(
+    listId: string,
+    itemId: string,
+    payload: { content?: string; category?: string; quantity?: string }
+  ): Promise<ListItem> {
+    return request<ListItem>(`/api/v1/lists/${listId}/items/${itemId}`, {
+      method: 'PUT',
+      body: JSON.stringify(payload),
+    });
+  },
+
   async deleteListItem(listId: string, itemId: string): Promise<void> {
     await request(`/api/v1/lists/${listId}/items/${itemId}`, { method: 'DELETE' });
   },
@@ -1077,7 +1133,7 @@ export function onRealtimeStatus(callback: (connected: boolean, transport: Realt
   };
 }
 
-let isWsBlockedByProxy = false;
+let isWsBlockedByProxy = typeof window !== 'undefined' && sessionStorage.getItem('mindsift_ws_blocked') === 'true';
 let sseReconnectTimer: any = null;
 let sseReconnectDelay = 2000;
 const globalSubscribedRooms = new Set<string>();
@@ -1095,6 +1151,25 @@ function notifyRealtimeStatusChange(connected: boolean, transport: RealtimeTrans
   window.dispatchEvent(new CustomEvent('mindsift:ws:status', { detail: { connected, transport } }));
 }
 
+function switchToSSE(reason: string) {
+  console.warn(`[MindSift Realtime] ${reason} -> Schalte sofort und dauerhaft auf Server-Sent Events (SSE) um.`);
+  isWsBlockedByProxy = true;
+  try {
+    sessionStorage.setItem('mindsift_ws_blocked', 'true');
+  } catch {}
+  clearTimeout(wsConnectionWatchdog);
+  clearTimeout(wsReconnectTimer);
+  if (activeGlobalWS) {
+    try {
+      activeGlobalWS.onclose = null;
+      activeGlobalWS.onerror = null;
+      activeGlobalWS.close();
+    } catch {}
+    activeGlobalWS = null;
+  }
+  connectSSE();
+}
+
 export function connectSSE(rooms?: string[]): void {
   if (rooms) {
     rooms.forEach((r) => globalSubscribedRooms.add(r));
@@ -1114,7 +1189,6 @@ export function connectSSE(rooms?: string[]): void {
     activeGlobalSSE = es;
 
     es.onopen = () => {
-      console.info('[MindSift Realtime] Server-Sent Events (SSE) verbunden (Proxy-Fallback aktiv).');
       sseReconnectDelay = 2000;
       notifyRealtimeStatusChange(true, 'sse');
       if (activeSSEId && globalSubscribedRooms.size > 0) {
@@ -1149,6 +1223,7 @@ export function connectSSE(rooms?: string[]): void {
     };
 
     es.onerror = (e) => {
+      console.warn('[MindSift Realtime] SSE Verbindungsfehler:', e);
       if (activeTransport === 'sse') {
         notifyRealtimeStatusChange(false, 'none');
       }
@@ -1160,11 +1235,7 @@ export function connectSSE(rooms?: string[]): void {
         sseReconnectDelay = Math.min(30000, Math.round(sseReconnectDelay * 1.5));
         sseReconnectTimer = setTimeout(() => {
           if (!manualDisconnect && getToken()) {
-            if (isWsBlockedByProxy) {
-              connectSSE();
-            } else {
-              connectWebSocket();
-            }
+            connectSSE();
           }
         }, delay);
       }
@@ -1199,16 +1270,12 @@ export function connectWebSocket(): void {
     const ws = new WebSocket(url);
     activeGlobalWS = ws;
 
-    // 3.5s watchdog for corporate proxies silently stripping Upgrade header
+    // 2.5s watchdog for corporate proxies silently stripping Upgrade header or hanging
     wsConnectionWatchdog = setTimeout(() => {
       if (ws && ws.readyState !== WebSocket.OPEN) {
-        console.warn('[MindSift Realtime] WebSocket connection timeout (Proxy Upgrade Block). Wechsle automatisch zu SSE...');
-        isWsBlockedByProxy = true;
-        try { ws.close(); } catch {}
-        activeGlobalWS = null;
-        connectSSE();
+        switchToSSE('WebSocket Timeout nach 2.5s (Proxy Upgrade Header blockiert)');
       }
-    }, 3500);
+    }, 2500);
 
     ws.onopen = () => {
       clearTimeout(wsConnectionWatchdog);
@@ -1247,11 +1314,9 @@ export function connectWebSocket(): void {
       clearTimeout(wsConnectionWatchdog);
       activeGlobalWS = null;
 
-      const isProxyIssue = evt?.code === 1006 || evt?.code === 1002 || evt?.code === 1008;
-      if (isProxyIssue && !manualDisconnect && getToken()) {
-        console.warn('[MindSift Realtime] Proxy/Firewall Inkompatibilität erkannt (Code ' + evt.code + '). Wechsle dauerhaft zu SSE...');
-        isWsBlockedByProxy = true;
-        connectSSE();
+      // In corporate environments, blocked WebSockets close abruptly without clean handshake
+      if (!evt.wasClean || evt.code === 1006 || evt.code === 1002 || evt.code === 1008 || evt.code === 1005) {
+        switchToSSE(`WebSocket unsauber beendet (Code ${evt.code}, wasClean=${evt.wasClean})`);
         return;
       }
 
@@ -1273,14 +1338,10 @@ export function connectWebSocket(): void {
 
     ws.onerror = (e) => {
       clearTimeout(wsConnectionWatchdog);
-      try {
-        ws.close();
-      } catch {}
+      switchToSSE('WebSocket Fehler (Handshake/Verbindung verweigert)');
     };
   } catch (e) {
-    clearTimeout(wsConnectionWatchdog);
-    isWsBlockedByProxy = true;
-    connectSSE();
+    switchToSSE('WebSocket Exception beim Initialisieren');
   }
 }
 
@@ -1394,10 +1455,9 @@ export function createRealtimeConnection(options: {
   // Join rooms on the active connection
   const joinAll = () => {
     joinedRooms.forEach((r) => {
-      if (r.startsWith('doc:')) {
-        sendWebSocketMessage({ event: 'CRDT_JOIN', docId: r.slice(4) });
-      } else {
-        sendWebSocketMessage({ event: 'JOIN_ROOM', room: r });
+      sendWebSocketMessage({ event: 'JOIN_ROOM', room: r });
+      if (activeSSEId) {
+        api.joinSSERoom(activeSSEId, r, 'join').catch(() => {});
       }
     });
   };
@@ -1427,10 +1487,9 @@ export function createRealtimeConnection(options: {
       if (unsubMsg) unsubMsg();
       joinedRooms.forEach((r) => {
         globalSubscribedRooms.delete(r);
-        if (r.startsWith('doc:')) {
-          sendWebSocketMessage({ event: 'CRDT_LEAVE', docId: r.slice(4) });
-        } else {
-          sendWebSocketMessage({ event: 'LEAVE_ROOM', room: r });
+        sendWebSocketMessage({ event: 'LEAVE_ROOM', room: r });
+        if (activeSSEId) {
+          api.joinSSERoom(activeSSEId, r, 'leave').catch(() => {});
         }
       });
     },

frontend/src/lib/markdown.tsx

@@ -0,0 +1,228 @@
+import React from 'react';
+
+/**
+ * Parses inline markdown:
+ * - **bold** or __bold__
+ * - *italic* or _italic_
+ * - ~~strikethrough~~
+ * - `code`
+ * - [label](url)
+ */
+function renderInlineTokens(text: string): React.ReactNode[] {
+  if (!text) return [];
+
+  const regex = /(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|~~[^~]+~~|\*[^*]+\*|_[^_]+_|\[([^\]]+)\]\(([^)]+)\))/g;
+
+  const elements: React.ReactNode[] = [];
+  let lastIndex = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      elements.push(text.slice(lastIndex, match.index));
+    }
+    const token = match[0];
+    const key = `${match.index}-${token}`;
+
+    if (token.startsWith('`') && token.endsWith('`')) {
+      elements.push(
+        <code key={key} className="px-1.5 py-0.5 rounded bg-panel-elevated text-accent font-mono text-[0.9em] border border-border/50">
+          {token.slice(1, -1)}
+        </code>
+      );
+    } else if (
+      (token.startsWith('**') && token.endsWith('**')) ||
+      (token.startsWith('__') && token.endsWith('__'))
+    ) {
+      elements.push(
+        <strong key={key} className="font-semibold text-main">
+          {token.slice(2, -2)}
+        </strong>
+      );
+    } else if (
+      (token.startsWith('*') && token.endsWith('*')) ||
+      (token.startsWith('_') && token.endsWith('_'))
+    ) {
+      elements.push(
+        <em key={key} className="italic text-main/90">
+          {token.slice(1, -1)}
+        </em>
+      );
+    } else if (token.startsWith('~~') && token.endsWith('~~')) {
+      elements.push(
+        <del key={key} className="line-through text-muted/80">
+          {token.slice(2, -2)}
+        </del>
+      );
+    } else if (token.startsWith('[') && match[2] && match[3]) {
+      const label = match[2];
+      const url = match[3];
+      elements.push(
+        <a
+          key={key}
+          href={url}
+          target="_blank"
+          rel="noopener noreferrer"
+          className="text-accent underline hover:opacity-80 transition-opacity"
+          onClick={(e) => e.stopPropagation()}
+        >
+          {label}
+        </a>
+      );
+    } else {
+      elements.push(token);
+    }
+
+    lastIndex = regex.lastIndex;
+  }
+
+  if (lastIndex < text.length) {
+    elements.push(text.slice(lastIndex));
+  }
+
+  return elements;
+}
+
+/**
+ * Parses inline markdown and fenced code blocks:
+ * - ```lang\ncode\n```
+ * - **bold** or __bold__
+ * - *italic* or _italic_
+ * - ~~strikethrough~~
+ * - `code`
+ * - [label](url)
+ */
+export function renderInlineMarkdown(text: string): React.ReactNode[] {
+  if (!text) return [];
+
+  if (text.includes('```')) {
+    const codeBlockRegex = /(```[a-zA-Z0-9_-]*\r?\n[\s\S]*?```|```[\s\S]*?```)/g;
+    const parts = text.split(codeBlockRegex);
+    const nodes: React.ReactNode[] = [];
+
+    parts.forEach((part, partIdx) => {
+      if (part.startsWith('```') && part.endsWith('```')) {
+        const lines = part.split(/\r?\n/);
+        const firstLine = lines[0].slice(3).trim();
+        const codeLines = lines.slice(1, lines.length - 1);
+        const code = codeLines.join('\n');
+        nodes.push(
+          <div
+            key={`fenced-${partIdx}`}
+            className="p-2.5 my-2 rounded bg-code text-accent font-mono text-xs overflow-x-auto border border-border/60 select-text"
+          >
+            {firstLine && (
+              <div className="text-[10px] text-faint uppercase font-sans pb-1 select-none">
+                {firstLine}
+              </div>
+            )}
+            <pre className="whitespace-pre overflow-x-auto font-mono text-status-ok leading-relaxed">
+              <code>{code}</code>
+            </pre>
+          </div>
+        );
+      } else if (part) {
+        nodes.push(...renderInlineTokens(part));
+      }
+    });
+
+    return nodes;
+  }
+
+  return renderInlineTokens(text);
+}
+
+export function MarkdownViewer({ content, className = '' }: { content: string; className?: string }) {
+  if (!content) return null;
+
+  const lines = content.split('\n');
+  const renderedNodes: React.ReactNode[] = [];
+  let inCodeBlock = false;
+  let codeBlockLines: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    if (line.trim().startsWith('```')) {
+      if (inCodeBlock) {
+        renderedNodes.push(
+          <pre key={`code-${i}`} className="p-2.5 my-2 rounded bg-panel-elevated text-accent font-mono text-xs overflow-x-auto border border-border/60">
+            <code>{codeBlockLines.join('\n')}</code>
+          </pre>
+        );
+        codeBlockLines = [];
+        inCodeBlock = false;
+      } else {
+        inCodeBlock = true;
+        codeBlockLines = [];
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeBlockLines.push(line);
+      continue;
+    }
+
+    const trimmed = line.trim();
+
+    if (trimmed.startsWith('### ')) {
+      renderedNodes.push(
+        <h3 key={i} className="text-sm font-bold text-main mt-2 mb-1">
+          {renderInlineMarkdown(trimmed.slice(4))}
+        </h3>
+      );
+    } else if (trimmed.startsWith('## ')) {
+      renderedNodes.push(
+        <h2 key={i} className="text-base font-bold text-main mt-3 mb-1">
+          {renderInlineMarkdown(trimmed.slice(3))}
+        </h2>
+      );
+    } else if (trimmed.startsWith('# ')) {
+      renderedNodes.push(
+        <h1 key={i} className="text-lg font-bold text-main mt-3 mb-1.5">
+          {renderInlineMarkdown(trimmed.slice(2))}
+        </h1>
+      );
+    } else if (trimmed.startsWith('> ')) {
+      renderedNodes.push(
+        <blockquote key={i} className="border-l-2 border-accent pl-2.5 my-1 text-muted italic">
+          {renderInlineMarkdown(trimmed.slice(2))}
+        </blockquote>
+      );
+    } else if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
+      renderedNodes.push(
+        <div key={i} className="flex items-start gap-1.5 my-0.5">
+          <span className="text-accent mt-0.5">•</span>
+          <span className="flex-1 text-main">{renderInlineMarkdown(trimmed.slice(2))}</span>
+        </div>
+      );
+    } else if (/^\d+\.\s/.test(trimmed)) {
+      const matchNum = trimmed.match(/^(\d+)\.\s(.*)$/);
+      renderedNodes.push(
+        <div key={i} className="flex items-start gap-1.5 my-0.5">
+          <span className="text-muted text-[11px] font-mono mt-0.5">{matchNum ? matchNum[1] + '.' : '•'}</span>
+          <span className="flex-1 text-main">{renderInlineMarkdown(matchNum ? matchNum[2] : trimmed)}</span>
+        </div>
+      );
+    } else if (trimmed === '') {
+      renderedNodes.push(<div key={i} className="h-2" />);
+    } else {
+      renderedNodes.push(
+        <div key={i} className="my-0.5 text-main leading-relaxed">
+          {renderInlineMarkdown(line)}
+        </div>
+      );
+    }
+  }
+
+  if (inCodeBlock && codeBlockLines.length > 0) {
+    renderedNodes.push(
+      <pre key="code-end" className="p-2.5 my-2 rounded bg-panel-elevated text-accent font-mono text-xs overflow-x-auto border border-border/60">
+        <code>{codeBlockLines.join('\n')}</code>
+      </pre>
+    );
+  }
+
+  return <div className={`markdown-body text-xs ${className}`}>{renderedNodes}</div>;
+}

frontend/src/lib/types.ts

@@ -53,8 +53,10 @@ export interface Thought {
   source: 'manual' | 'voice' | 'webhook';
   status: ThoughtStatus;
   isCompleted: boolean;
-  convertedType?: 'task' | 'document' | 'list_item';
+  convertedType?: 'task' | 'document' | 'list_item' | 'document_block';
   convertedRefId?: string;
+  docId?: string;
+  blockId?: string;
   dueDate?: string;
   taskListId?: string;
   kanbanStatus?: string;
@@ -81,6 +83,7 @@ export interface TaskListShare {
   targetName?: string;
   email?: string;
   avatarUrl?: string;
+  permission?: 'editor' | 'viewer';
   createdAt: string;
 }
 
@@ -102,6 +105,7 @@ export interface TaskList {
   ownerId?: string;
   ownerName?: string;
   isOwner?: boolean;
+  permission?: 'owner' | 'editor' | 'viewer';
   members?: TaskListMember[];
   shares?: TaskListShare[];
   columns?: KanbanColumn[];
@@ -159,6 +163,7 @@ export interface DocumentBlock {
   id: string;
   docId?: string;
   documentId?: string;
+  taskId?: string;
   type: BlockType;
   content: string;
   checked?: boolean;
@@ -200,13 +205,6 @@ export interface DocShare {
   createdAt: string;
 }
 
-export interface DocLockInfo {
-  docId: string;
-  userId: string;
-  userName: string;
-  expiresAt: string;
-}
-
 export interface Document {
   id: string;
   userId: string;

frontend/src/lib/useDocumentSync.ts

@@ -1,553 +0,0 @@
-import { useEffect, useRef, useState, useCallback, useMemo } from 'react';
-import { DocumentBlock } from './types';
-import { getToken, api } from './api';
-
-export type DocSyncStatus = 'connecting' | 'connected' | 'reconnecting' | 'offline';
-
-export interface RemoteCursor {
-  clientId: string;
-  userId: string;
-  userName: string;
-  userColor: string;
-  blockId: string | null;
-  selectionStart?: number;
-  selectionEnd?: number;
-  updatedAt: number;
-}
-
-export const CURSOR_COLORS = [
-  '#3b82f6', // blue
-  '#10b981', // emerald
-  '#f59e0b', // amber
-  '#ec4899', // pink
-  '#8b5cf6', // purple
-  '#06b6d4', // cyan
-  '#f97316', // orange
-  '#14b8a6', // teal
-  '#6366f1', // indigo
-];
-
-export function getUserColor(idOrName: string): string {
-  if (!idOrName) return CURSOR_COLORS[0];
-  let hash = 0;
-  for (let i = 0; i < idOrName.length; i++) {
-    hash = (hash << 5) - hash + idOrName.charCodeAt(i);
-    hash |= 0;
-  }
-  return CURSOR_COLORS[Math.abs(hash) % CURSOR_COLORS.length];
-}
-
-export interface DocSyncEvent {
-  type:
-    | 'doc_state'
-    | 'block_created'
-    | 'block_updated'
-    | 'block_deleted'
-    | 'block_moved'
-    | 'title_updated'
-    | 'blocks_replaced'
-    | 'cursor_moved'
-    | 'client_left';
-  docId?: string;
-  clientId?: string;
-  userId?: string;
-  userName?: string;
-  userColor?: string;
-  selectionStart?: number;
-  selectionEnd?: number;
-  activeCursors?: RemoteCursor[];
-  title?: string;
-  block?: DocumentBlock;
-  blockId?: string;
-  afterBlockId?: string;
-  newIndex?: number;
-  content?: string;
-  level?: number;
-  checked?: boolean;
-  collapsed?: boolean;
-  blockType?: string;
-  blocks?: DocumentBlock[];
-}
-
-export function useDocumentSync(
-  docId: string | null,
-  onRemoteEvent: (evt: DocSyncEvent) => void,
-  canEdit: boolean = true,
-  currentUser?: { id: string; email?: string; displayName?: string } | null
-) {
-  const [status, setStatus] = useState<DocSyncStatus>('connecting');
-  const [remoteCursors, setRemoteCursors] = useState<Record<string, RemoteCursor>>({});
-  const wsRef = useRef<WebSocket | null>(null);
-  const clientIdRef = useRef<string>(
-    `cli_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`
-  );
-  const onRemoteEventRef = useRef(onRemoteEvent);
-  onRemoteEventRef.current = onRemoteEvent;
-
-  const docIdRef = useRef(docId);
-  docIdRef.current = docId;
-  const canEditRef = useRef(canEdit);
-  canEditRef.current = canEdit;
-  const currentUserRef = useRef(currentUser);
-  currentUserRef.current = currentUser;
-
-  const reconnectTimerRef = useRef<number | null>(null);
-  const fallbackTimerRef = useRef<number | null>(null);
-
-  const localUserName =
-    currentUser?.displayName || currentUser?.email?.split('@')[0] || 'Anonym';
-  const localUserColor = useMemo(
-    () => getUserColor(currentUser?.id || clientIdRef.current),
-    [currentUser?.id]
-  );
-  const localUserNameRef = useRef(localUserName);
-  localUserNameRef.current = localUserName;
-  const localUserColorRef = useRef(localUserColor);
-  localUserColorRef.current = localUserColor;
-
-  const pendingMessagesQueueRef = useRef<string[]>([]);
-
-  const lastCursorSendRef = useRef<number>(0);
-  const pendingCursorTimerRef = useRef<number | null>(null);
-  const pendingCursorPayloadRef = useRef<{
-    blockId: string | null;
-    selectionStart?: number;
-    selectionEnd?: number;
-  } | null>(null);
-
-  // Clean up stale remote cursors (> 30s)
-  useEffect(() => {
-    const interval = setInterval(() => {
-      const now = Date.now();
-      setRemoteCursors((prev) => {
-        let hasStale = false;
-        const next: Record<string, RemoteCursor> = {};
-        for (const [key, cursor] of Object.entries(prev)) {
-          if (now - cursor.updatedAt < 30000) {
-            next[key] = cursor;
-          } else {
-            hasStale = true;
-          }
-        }
-        return hasStale ? next : prev;
-      });
-    }, 5000);
-    return () => clearInterval(interval);
-  }, []);
-
-  useEffect(() => {
-    if (!docId) {
-      setStatus('offline');
-      setRemoteCursors({});
-      pendingMessagesQueueRef.current = [];
-      return;
-    }
-
-    pendingMessagesQueueRef.current = [];
-    let isDisposed = false;
-    let retryCount = 0;
-    const currentClientId = `cli_${Math.random().toString(36).slice(2, 10)}_${Date.now().toString(36)}`;
-    clientIdRef.current = currentClientId;
-
-    const connect = () => {
-      if (isDisposed) return;
-
-      const token = getToken();
-      if (!token) {
-        setStatus('offline');
-        return;
-      }
-
-      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-      const wsUrl = `${protocol}//${window.location.host}/api/v1/ws/docs/${encodeURIComponent(
-        docId
-      )}?token=${encodeURIComponent(token)}&clientId=${encodeURIComponent(
-        currentClientId
-      )}&userName=${encodeURIComponent(localUserName)}&userColor=${encodeURIComponent(
-        localUserColor
-      )}`;
-
-      setStatus(retryCount === 0 ? 'connecting' : 'reconnecting');
-
-      let ws: WebSocket;
-      try {
-        ws = new WebSocket(wsUrl);
-      } catch {
-        setStatus('offline');
-        return;
-      }
-
-      wsRef.current = ws;
-
-      ws.onopen = () => {
-        if (isDisposed) {
-          ws.close();
-          return;
-        }
-        retryCount = 0;
-        setStatus('connected');
-
-        // Flush any queued messages buffered while connecting or reconnecting
-        if (pendingMessagesQueueRef.current.length > 0) {
-          const queue = [...pendingMessagesQueueRef.current];
-          pendingMessagesQueueRef.current = [];
-          for (const msg of queue) {
-            try {
-              ws.send(msg);
-            } catch (err) {
-              console.warn('[DocSync] Failed to flush queued message:', err);
-            }
-          }
-        }
-      };
-
-      ws.onmessage = (event) => {
-        if (isDisposed) return;
-        try {
-          const parsed: DocSyncEvent = JSON.parse(event.data);
-          if (!parsed || !parsed.type) return;
-
-          // Echo protection: ignore events originating from our own clientId (except initial doc_state)
-          if (parsed.type !== 'doc_state' && parsed.clientId && parsed.clientId === currentClientId) {
-            return;
-          }
-
-          if (parsed.type === 'doc_state') {
-            if (Array.isArray(parsed.activeCursors)) {
-              const initialCursors: Record<string, RemoteCursor> = {};
-              for (const c of parsed.activeCursors) {
-                if (c.clientId && c.clientId !== currentClientId) {
-                  initialCursors[c.clientId] = {
-                    ...c,
-                    updatedAt: c.updatedAt || Date.now(),
-                  };
-                }
-              }
-              setRemoteCursors(initialCursors);
-            }
-          } else if (parsed.type === 'cursor_moved') {
-            if (parsed.clientId && parsed.clientId !== currentClientId) {
-              setRemoteCursors((prev) => ({
-                ...prev,
-                [parsed.clientId!]: {
-                  clientId: parsed.clientId!,
-                  userId: parsed.userId || '',
-                  userName: parsed.userName || 'Anonym',
-                  userColor: parsed.userColor || '#3b82f6',
-                  blockId:
-                    parsed.blockId !== undefined
-                      ? parsed.blockId
-                      : prev[parsed.clientId!]?.blockId ?? null,
-                  selectionStart: parsed.selectionStart,
-                  selectionEnd: parsed.selectionEnd,
-                  updatedAt: Date.now(),
-                },
-              }));
-            }
-          } else if (parsed.type === 'client_left') {
-            if (parsed.clientId) {
-              setRemoteCursors((prev) => {
-                if (!prev[parsed.clientId!]) return prev;
-                const next = { ...prev };
-                delete next[parsed.clientId!];
-                return next;
-              });
-            }
-          }
-
-          onRemoteEventRef.current(parsed);
-        } catch {
-          // Ignore malformed frames
-        }
-      };
-
-      ws.onerror = () => {
-        // Handled in onclose
-      };
-
-      ws.onclose = () => {
-        if (isDisposed) return;
-        wsRef.current = null;
-        retryCount += 1;
-        setStatus(retryCount > 2 ? 'offline' : 'reconnecting');
-        const delay = Math.min(1000 * Math.pow(1.6, retryCount), 8000);
-        reconnectTimerRef.current = window.setTimeout(connect, delay);
-      };
-    };
-
-    connect();
-
-    return () => {
-      isDisposed = true;
-      if (reconnectTimerRef.current !== null) {
-        window.clearTimeout(reconnectTimerRef.current);
-        reconnectTimerRef.current = null;
-      }
-      if (fallbackTimerRef.current !== null) {
-        window.clearTimeout(fallbackTimerRef.current);
-        fallbackTimerRef.current = null;
-      }
-      if (pendingCursorTimerRef.current !== null) {
-        window.clearTimeout(pendingCursorTimerRef.current);
-        pendingCursorTimerRef.current = null;
-      }
-      if (wsRef.current) {
-        try {
-          wsRef.current.onopen = null;
-          wsRef.current.onmessage = null;
-          wsRef.current.onerror = null;
-          wsRef.current.onclose = null;
-          wsRef.current.close();
-        } catch {
-          // ignore
-        }
-        wsRef.current = null;
-      }
-    };
-  }, [docId, localUserName, localUserColor]);
-
-  const executeSendCursor = useCallback(
-    (blockId: string | null, selectionStart?: number, selectionEnd?: number) => {
-      const ws = wsRef.current;
-      const activeDocId = docIdRef.current;
-      if (!activeDocId || !ws || ws.readyState !== WebSocket.OPEN) return;
-      const payload: DocSyncEvent = {
-        type: 'cursor_moved',
-        docId: activeDocId,
-        clientId: clientIdRef.current,
-        userId: currentUserRef.current?.id,
-        userName: localUserNameRef.current,
-        userColor: localUserColorRef.current,
-        blockId: blockId || undefined,
-        selectionStart,
-        selectionEnd,
-      };
-      try {
-        ws.send(JSON.stringify(payload));
-      } catch {
-        // Ephemeral cursor, ignore send failure
-      }
-      lastCursorSendRef.current = Date.now();
-    },
-    []
-  );
-
-  const sendCursorMoved = useCallback(
-    (blockId: string | null, selectionStart?: number, selectionEnd?: number) => {
-      if (!docIdRef.current) return;
-      const now = Date.now();
-      const elapsed = now - lastCursorSendRef.current;
-
-      // When leaving focus / blur (blockId === null), send immediately
-      if (blockId === null) {
-        if (pendingCursorTimerRef.current !== null) {
-          window.clearTimeout(pendingCursorTimerRef.current);
-          pendingCursorTimerRef.current = null;
-        }
-        pendingCursorPayloadRef.current = null;
-        executeSendCursor(null);
-        return;
-      }
-
-      // Max once per 100ms
-      if (elapsed >= 100) {
-        if (pendingCursorTimerRef.current !== null) {
-          window.clearTimeout(pendingCursorTimerRef.current);
-          pendingCursorTimerRef.current = null;
-        }
-        executeSendCursor(blockId, selectionStart, selectionEnd);
-      } else {
-        pendingCursorPayloadRef.current = { blockId, selectionStart, selectionEnd };
-        if (pendingCursorTimerRef.current === null) {
-          pendingCursorTimerRef.current = window.setTimeout(() => {
-            pendingCursorTimerRef.current = null;
-            if (pendingCursorPayloadRef.current) {
-              executeSendCursor(
-                pendingCursorPayloadRef.current.blockId,
-                pendingCursorPayloadRef.current.selectionStart,
-                pendingCursorPayloadRef.current.selectionEnd
-              );
-              pendingCursorPayloadRef.current = null;
-            }
-          }, 100 - elapsed);
-        }
-      }
-    },
-    [executeSendCursor]
-  );
-
-  const sendRawEvent = useCallback(
-    (evt: DocSyncEvent, fallbackFn?: () => void) => {
-      const activeDocId = docIdRef.current;
-      const activeCanEdit = canEditRef.current;
-      if (!activeDocId || !activeCanEdit) return;
-
-      const ws = wsRef.current;
-      const payload: DocSyncEvent = {
-        ...evt,
-        docId: activeDocId,
-        clientId: clientIdRef.current,
-      };
-      const jsonStr = JSON.stringify(payload);
-
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        try {
-          ws.send(jsonStr);
-        } catch (err) {
-          console.warn('[DocSync] Failed to send WebSocket message, buffering:', err);
-          pendingMessagesQueueRef.current.push(jsonStr);
-        }
-      } else {
-        console.warn(
-          `[DocSync] WebSocket not OPEN (state=${ws ? ws.readyState : 'null'}). Buffering event:`,
-          evt.type
-        );
-        pendingMessagesQueueRef.current.push(jsonStr);
-
-        if (fallbackFn) {
-          if (fallbackTimerRef.current !== null) {
-            window.clearTimeout(fallbackTimerRef.current);
-          }
-          fallbackTimerRef.current = window.setTimeout(() => {
-            fallbackFn();
-          }, 600);
-        }
-      }
-    },
-    []
-  );
-
-  const sendBlockCreated = useCallback(
-    (block: DocumentBlock, afterBlockId?: string, allBlocks?: DocumentBlock[]) => {
-      sendRawEvent(
-        {
-          type: 'block_created',
-          block,
-          afterBlockId,
-        },
-        () => {
-          if (docId && allBlocks) {
-            api
-              .patchDocumentBlocks(docId, {
-                upserted: [block],
-                blockOrder: allBlocks.map((b) => b.id),
-              })
-              .catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  const sendBlockUpdated = useCallback(
-    (block: DocumentBlock) => {
-      sendRawEvent(
-        {
-          type: 'block_updated',
-          blockId: block.id,
-          block,
-        },
-        () => {
-          if (docId) {
-            api.patchDocumentBlocks(docId, { upserted: [block] }).catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  const sendBlockDeleted = useCallback(
-    (blockId: string, allBlocks?: DocumentBlock[]) => {
-      sendRawEvent(
-        {
-          type: 'block_deleted',
-          blockId,
-        },
-        () => {
-          if (docId) {
-            api
-              .patchDocumentBlocks(docId, {
-                deletedIds: [blockId],
-                blockOrder: allBlocks ? allBlocks.map((b) => b.id) : undefined,
-              })
-              .catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  const sendBlockMoved = useCallback(
-    (blockId: string, newIndex: number, level?: number, allBlocks?: DocumentBlock[]) => {
-      sendRawEvent(
-        {
-          type: 'block_moved',
-          blockId,
-          newIndex,
-          level,
-        },
-        () => {
-          if (docId && allBlocks) {
-            api
-              .patchDocumentBlocks(docId, {
-                upserted: allBlocks,
-                blockOrder: allBlocks.map((b) => b.id),
-              })
-              .catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  const sendTitleUpdated = useCallback(
-    (title: string) => {
-      sendRawEvent(
-        {
-          type: 'title_updated',
-          title,
-        },
-        () => {
-          if (docId) {
-            api.updateDocument(docId, { title }).catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  const sendBlocksReplaced = useCallback(
-    (blocks: DocumentBlock[]) => {
-      sendRawEvent(
-        {
-          type: 'blocks_replaced',
-          blocks,
-        },
-        () => {
-          if (docId) {
-            api.updateDocument(docId, { blocks }).catch(() => {});
-          }
-        }
-      );
-    },
-    [docId, sendRawEvent]
-  );
-
-  return {
-    status,
-    clientId: clientIdRef.current,
-    remoteCursors,
-    sendCursorMoved,
-    sendBlockCreated,
-    sendBlockUpdated,
-    sendBlockDeleted,
-    sendBlockMoved,
-    sendTitleUpdated,
-    sendBlocksReplaced,
-  };
-}

internal/api/server.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/tls"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"io/fs"
@@ -31,9 +32,6 @@ type Server struct {
 }
 
 func NewServer(cfg *config.Config, store *storage.Store, wsHub *ws.Hub, staticFS fs.FS) *Server {
-	if wsHub != nil && store != nil {
-		wsHub.SetDocStore(store)
-	}
 	srv := &Server{
 		cfg:      cfg,
 		store:    store,
@@ -70,7 +68,6 @@ func (s *Server) Router() http.Handler {
 	r.Get("/api/v1/ws", s.handleWebSocket)
 	r.Get("/api/v1/ws/spaces/{spaceId}", s.handleWebSocket)
 	r.Get("/api/v1/ws/lists/{listId}", s.handleWebSocket)
-	r.Get("/api/v1/ws/docs/{id}", s.handleDocWebSocket)
 	r.Get("/api/v1/events", s.handleSSE)
 	r.Post("/api/v1/events/rooms", s.handleSSERooms)
 
@@ -79,6 +76,8 @@ func (s *Server) Router() http.Handler {
 		r.Use(s.authMiddleware)
 
 		r.Get("/api/v1/auth/me", s.handleMe)
+		r.Post("/api/v1/auth/logout", s.handleLogout)
+		r.Post("/api/v1/auth/revoke-all", s.handleRevokeAllSessions)
 		r.Patch("/api/v1/auth/settings", s.handleUpdateUserSettings)
 		r.Post("/api/v1/auth/alarms/test", s.handleTestUserAlarm)
 		r.Get("/api/v1/users/directory", s.handleGetUsersDirectory)
@@ -90,6 +89,7 @@ func (s *Server) Router() http.Handler {
 		// Instant Capture & Thoughts
 		r.Post("/api/v1/inbox", s.handleCaptureInbox)
 		r.Get("/api/v1/thoughts", s.handleGetThoughts)
+		r.Get("/api/v1/thoughts/{id}", s.handleGetThought)
 		r.Patch("/api/v1/thoughts/{id}", s.handleUpdateThought)
 		r.Delete("/api/v1/thoughts/{id}", s.handleDeleteThought)
 		r.Delete("/api/v1/thoughts/discarded/purge", s.handlePurgeDiscarded)
@@ -98,6 +98,7 @@ func (s *Server) Router() http.Handler {
 		r.Get("/api/v1/triage/deck", s.handleGetTriageDeck)
 		r.Patch("/api/v1/triage/{id}", s.handleTriageAction)
 		r.Get("/api/v1/tasks", s.handleGetTasks)
+		r.Post("/api/v1/tasks/{id}/unlink", s.handleUnlinkEnhancedTask)
 		r.Post("/api/v1/tasks/reorder", s.handleReorderTasks)
 		r.Post("/api/v1/task-lists/{id}/tasks/reorder", s.handleReorderTasks)
 
@@ -137,6 +138,7 @@ func (s *Server) Router() http.Handler {
 		r.Patch("/api/v1/documents/{id}/blocks", s.handlePatchDocumentBlocks)
 		r.Put("/api/v1/documents/{id}/move", s.handleMoveDocument)
 		r.Delete("/api/v1/documents/{id}", s.handleDeleteDocument)
+		r.Post("/api/v1/documents/{id}/blocks/{blockId}/enhanced-task", s.handleCreateEnhancedTask)
 
 		// Document Sharing & Collaboration
 		r.Get("/api/v1/documents/{id}/shares", s.handleGetDocShares)
@@ -153,6 +155,7 @@ func (s *Server) Router() http.Handler {
 		r.Delete("/api/v1/lists/{id}/shares/{shareId}", s.handleDeleteListShare)
 		r.Post("/api/v1/lists/{id}/items", s.handleCreateListItem)
 		r.Patch("/api/v1/lists/{id}/items/{itemId}", s.handleToggleListItem)
+		r.Put("/api/v1/lists/{id}/items/{itemId}", s.handleUpdateListItem)
 		r.Delete("/api/v1/lists/{id}/items/{itemId}", s.handleDeleteListItem)
 		r.Post("/api/v1/lists/{id}/items/reorder", s.handleReorderListItems)
 		r.Put("/api/v1/lists/{id}/items/reorder", s.handleReorderListItems)
@@ -241,6 +244,15 @@ func writeError(w http.ResponseWriter, status int, message string) {
 	writeJSON(w, status, map[string]string{"error": message})
 }
 
+// writeStoreError maps read-only task list violations to 403 and everything else to the given fallback status.
+func writeStoreError(w http.ResponseWriter, fallbackStatus int, err error) {
+	if errors.Is(err, storage.ErrTaskListReadOnly) {
+		writeError(w, http.StatusForbidden, err.Error())
+		return
+	}
+	writeError(w, fallbackStatus, err.Error())
+}
+
 func (s *Server) apiLoggingMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Only log API requests (/api/...)
@@ -304,10 +316,14 @@ func (s *Server) authMiddleware(next http.Handler) http.Handler {
 			}
 			claims, err := auth.ValidateToken(s.cfg.JWTSecret, tokenStr)
 			if err == nil && claims != nil {
-				user, userErr := s.store.GetUserByID(claims.UserID)
-				if userErr == nil && user != nil && user.IsActive {
-					next.ServeHTTP(w, r.WithContext(auth.WithUserID(r.Context(), user.ID)))
-					return
+				if !s.store.IsTokenRevoked(tokenStr) {
+					user, userErr := s.store.GetUserByID(claims.UserID)
+					if userErr == nil && user != nil && user.IsActive {
+						if claims.TokenVersion == 0 || claims.TokenVersion == user.TokenVersion {
+							next.ServeHTTP(w, r.WithContext(auth.WithUserID(r.Context(), user.ID)))
+							return
+						}
+					}
 				}
 			}
 		}
@@ -443,7 +459,7 @@ func (s *Server) handleFirstBootSetup(w http.ResponseWriter, r *http.Request) {
 		_ = s.store.SeedStarterContent(user)
 	}
 
-	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
+	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName, user.TokenVersion)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "Token konnte nicht erstellt werden")
 		return
@@ -519,7 +535,7 @@ func (s *Server) handleRegister(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
+	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName, user.TokenVersion)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "Token konnte nicht erstellt werden")
 		return
@@ -557,21 +573,31 @@ func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
 	}
 
 	user, err := s.store.GetUserByLogin(identifier)
-	if err != nil || !auth.CheckPassword(req.Password, user.PasswordHash) {
+	if err != nil {
+		slog.Warn("Login fehlgeschlagen: Benutzer existiert nicht", "login", identifier, "remote_addr", r.RemoteAddr)
+		writeError(w, http.StatusUnauthorized, "Benutzername/E-Mail oder Passwort ungültig")
+		return
+	}
+	if !auth.CheckPassword(req.Password, user.PasswordHash) {
+		slog.Warn("Login fehlgeschlagen: Falsches Passwort", "login", identifier, "user_id", user.ID, "display_name", user.DisplayName, "remote_addr", r.RemoteAddr)
 		writeError(w, http.StatusUnauthorized, "Benutzername/E-Mail oder Passwort ungültig")
 		return
 	}
 	if !user.IsActive {
+		slog.Warn("Login verweigert: Benutzerkonto ist deaktiviert", "login", identifier, "user_id", user.ID, "display_name", user.DisplayName, "remote_addr", r.RemoteAddr)
 		writeError(w, http.StatusForbidden, "Dieses Benutzerkonto ist deaktiviert")
 		return
 	}
 
-	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
+	token, err := auth.GenerateToken(s.cfg.JWTSecret, user.ID, user.Email, user.DisplayName, user.TokenVersion)
 	if err != nil {
+		slog.Error("Login-Token konnte nicht erstellt werden", "login", identifier, "user_id", user.ID, "error", err)
 		writeError(w, http.StatusInternalServerError, "Token konnte nicht erstellt werden")
 		return
 	}
 
+	slog.Info("Login erfolgreich", "login", identifier, "user_id", user.ID, "display_name", user.DisplayName, "role", user.Role, "remote_addr", r.RemoteAddr)
+
 	writeJSON(w, http.StatusOK, map[string]interface{}{
 		"token": token,
 		"user":  user,
@@ -657,7 +683,7 @@ func (s *Server) handleCaptureInbox(w http.ResponseWriter, r *http.Request) {
 
 	thought, err := s.store.CreateThoughtWithDetails(userID, req.Content, req.Priority, source, dueDate, taskListID, "todo", "")
 	if err != nil {
-		writeError(w, http.StatusBadRequest, err.Error())
+		writeStoreError(w, http.StatusBadRequest, err)
 		return
 	}
 
@@ -688,6 +714,17 @@ func (s *Server) handleGetThoughts(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, thoughts)
 }
 
+func (s *Server) handleGetThought(w http.ResponseWriter, r *http.Request) {
+	userID := auth.GetUserID(r.Context())
+	thoughtID := chi.URLParam(r, "id")
+	thought, err := s.store.GetThoughtByID(userID, thoughtID)
+	if err != nil || thought == nil {
+		writeError(w, http.StatusNotFound, "Aufgabe nicht gefunden")
+		return
+	}
+	writeJSON(w, http.StatusOK, thought)
+}
+
 func (s *Server) handleGetTriageDeck(w http.ResponseWriter, r *http.Request) {
 	userID := auth.GetUserID(r.Context())
 	thoughts, err := s.store.GetThoughts(userID, "inbox", 100)
@@ -737,7 +774,7 @@ func (s *Server) handleTriageAction(w http.ResponseWriter, r *http.Request) {
 
 	updated, err := s.store.UpdateThoughtTriage(userID, thoughtID, req.Action, convertTo, targetListID, dueDate, taskListID)
 	if err != nil {
-		writeError(w, http.StatusBadRequest, err.Error())
+		writeStoreError(w, http.StatusBadRequest, err)
 		return
 	}
 
@@ -778,6 +815,17 @@ func (s *Server) handleReorderTasks(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	if taskListID != "" && !s.store.CanEditTaskList(userID, taskListID) {
+		writeError(w, http.StatusForbidden, storage.ErrTaskListReadOnly.Error())
+		return
+	}
+	for _, it := range req.Items {
+		if th, err := s.store.GetThoughtByID(userID, it.ID); err == nil && th.TaskListID != "" && !s.store.CanEditTaskList(userID, th.TaskListID) {
+			writeError(w, http.StatusForbidden, storage.ErrTaskListReadOnly.Error())
+			return
+		}
+	}
+
 	if err := s.store.ReorderTasks(taskListID, req.Items); err != nil {
 		writeError(w, http.StatusInternalServerError, err.Error())
 		return
@@ -813,18 +861,31 @@ func (s *Server) handleUpdateThought(w http.ResponseWriter, r *http.Request) {
 
 	updated, err := s.store.UpdateThoughtDetails(userID, thoughtID, req.Content, req.IsCompleted, req.DueDate, req.Priority, req.TaskListID, req.KanbanStatus, req.Notes, req.Subtasks, req.Tags)
 	if err != nil {
-		writeError(w, http.StatusBadRequest, err.Error())
+		writeStoreError(w, http.StatusBadRequest, err)
 		return
 	}
+	s.store.SyncDocBlockAndTask(userID, thoughtID, updated.IsCompleted)
 	s.wsHub.BroadcastToAll("TASK_UPDATED", updated)
 	writeJSON(w, http.StatusOK, updated)
 }
 
+func (s *Server) handleUnlinkEnhancedTask(w http.ResponseWriter, r *http.Request) {
+	userID := auth.GetUserID(r.Context())
+	thoughtID := chi.URLParam(r, "id")
+	s.store.UnlinkTaskFromDocBlock(userID, thoughtID)
+	writeJSON(w, http.StatusOK, map[string]bool{"unlinked": true})
+}
+
 func (s *Server) handleDeleteThought(w http.ResponseWriter, r *http.Request) {
 	userID := auth.GetUserID(r.Context())
 	thoughtID := chi.URLParam(r, "id")
+	if th, err := s.store.GetThoughtByID(userID, thoughtID); err == nil && th.TaskListID != "" && !s.store.CanEditTaskList(userID, th.TaskListID) {
+		writeError(w, http.StatusForbidden, storage.ErrTaskListReadOnly.Error())
+		return
+	}
+	s.store.UnlinkTaskFromDocBlock(userID, thoughtID)
 	if err := s.store.DeleteThought(userID, thoughtID); err != nil {
-		writeError(w, http.StatusInternalServerError, err.Error())
+		writeStoreError(w, http.StatusInternalServerError, err)
 		return
 	}
 	s.wsHub.BroadcastToAll("TASK_DELETED", map[string]string{"id": thoughtID})
@@ -848,11 +909,18 @@ func (s *Server) broadcastDocToAuthorizedUsers(docID, event string) {
 	if err != nil {
 		return
 	}
+	var firstDoc *domain.Document
 	for _, uid := range users {
 		if userDoc, err := s.store.GetDocumentByID(uid, docID); err == nil && userDoc != nil {
+			if firstDoc == nil {
+				firstDoc = userDoc
+			}
 			s.wsHub.BroadcastToUser(uid, event, userDoc)
 		}
 	}
+	if s.wsHub != nil && firstDoc != nil {
+		s.wsHub.BroadcastRoom("doc:"+docID, event, firstDoc, nil)
+	}
 }
 
 func (s *Server) handleGetDocuments(w http.ResponseWriter, r *http.Request) {
@@ -898,18 +966,6 @@ func (s *Server) handleGetDocument(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusNotFound, "Dokument nicht gefunden")
 		return
 	}
-	if s.wsHub != nil {
-		if liveTitle, liveBlocks, ok := s.wsHub.GetActiveDocState(docID); ok {
-			if liveTitle != "" {
-				doc.Title = liveTitle
-			}
-			if len(liveBlocks) > 0 {
-				doc.Blocks = liveBlocks
-				doc.MarkdownCache = domain.CompileBlocksToMarkdown(liveBlocks)
-				doc.Content = doc.MarkdownCache
-			}
-		}
-	}
 	writeJSON(w, http.StatusOK, doc)
 }
 
@@ -935,9 +991,6 @@ func (s *Server) handleUpdateDocument(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
-	if s.wsHub != nil && (req.Title != nil || req.Blocks != nil) {
-		s.wsHub.SyncActiveDocRoom(docID, doc.Title, doc.Blocks)
-	}
 	if req.Title != nil || req.Icon != nil || req.FolderPath != nil || req.Blocks != nil || req.Tags != nil {
 		s.broadcastDocToAuthorizedUsers(docID, "DOC_UPDATED")
 	}
@@ -959,9 +1012,6 @@ func (s *Server) handlePatchDocumentBlocks(w http.ResponseWriter, r *http.Reques
 		writeError(w, http.StatusBadRequest, err.Error())
 		return
 	}
-	if s.wsHub != nil {
-		s.wsHub.SyncActiveDocRoom(docID, doc.Title, doc.Blocks)
-	}
 
 	patchEvent := domain.DocBlocksPatchEvent{
 		DocID:      docID,
@@ -986,9 +1036,6 @@ func (s *Server) handleDeleteDocument(w http.ResponseWriter, r *http.Request) {
 	docID := chi.URLParam(r, "id")
 	authorizedUsers, _ := s.store.GetAuthorizedDocUsers(docID)
 
-	if s.wsHub != nil {
-		s.wsHub.CloseDocRoom(docID)
-	}
 	if err := s.store.DeleteDocument(userID, docID); err != nil {
 		writeError(w, http.StatusInternalServerError, err.Error())
 		return
@@ -999,6 +1046,30 @@ func (s *Server) handleDeleteDocument(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]bool{"deleted": true})
 }
 
+func (s *Server) handleCreateEnhancedTask(w http.ResponseWriter, r *http.Request) {
+	userID := auth.GetUserID(r.Context())
+	docID := chi.URLParam(r, "id")
+	blockID := chi.URLParam(r, "blockId")
+
+	var req struct {
+		Content string `json:"content"`
+		Checked bool   `json:"checked"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "Ungültiges JSON")
+		return
+	}
+
+	thought, err := s.store.CreateTaskFromDocBlock(userID, docID, blockID, req.Content, req.Checked)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	s.wsHub.BroadcastToUser(userID, "TASK_CREATED", thought)
+	writeJSON(w, http.StatusCreated, thought)
+}
+
 // --- WORKSPACE FOLDERS ---
 
 func (s *Server) handleGetFolders(w http.ResponseWriter, r *http.Request) {
@@ -1044,7 +1115,6 @@ func (s *Server) handleDeleteFolder(w http.ResponseWriter, r *http.Request) {
 	}
 
 	for _, docID := range deletedDocIDs {
-		s.wsHub.ReleaseDocLock(docID, userID, true)
 		s.wsHub.BroadcastDocEvent(docID, "DOC_DELETED", map[string]string{"id": docID})
 	}
 	s.wsHub.BroadcastDocEvent("", "WORKSPACE_FOLDERS_UPDATED", map[string]string{"path": folderPath})
@@ -1375,8 +1445,6 @@ func (s *Server) handleGetCollaborators(w http.ResponseWriter, r *http.Request)
 	writeJSON(w, http.StatusOK, users)
 }
 
-// --- DOCUMENT REALTIME WEBSOCKET ROOM ---
-
 func (s *Server) authenticateUserFromReq(r *http.Request) string {
 	token := r.URL.Query().Get("token")
 	if token == "" {
@@ -1385,53 +1453,24 @@ func (s *Server) authenticateUserFromReq(r *http.Request) string {
 		}
 	}
 	if token != "" {
-		if claims, err := auth.ValidateToken(s.cfg.JWTSecret, token); err == nil {
-			return claims.UserID
+		if strings.HasPrefix(token, "mindsift_sec_") {
+			if user, err := s.store.ValidateAPIKeyAndGetUser(token); err == nil && user != nil && user.IsActive {
+				return user.ID
+			}
+		}
+		if claims, err := auth.ValidateToken(s.cfg.JWTSecret, token); err == nil && claims != nil {
+			if !s.store.IsTokenRevoked(token) {
+				if user, err := s.store.GetUserByID(claims.UserID); err == nil && user != nil && user.IsActive {
+					if claims.TokenVersion == 0 || claims.TokenVersion == user.TokenVersion {
+						return claims.UserID
+					}
+				}
+			}
 		}
 	}
 	return ""
 }
 
-// GET /api/v1/ws/docs/{id}
-func (s *Server) handleDocWebSocket(w http.ResponseWriter, r *http.Request) {
-	if r.Header.Get("Sec-Websocket-Key") != "" {
-		if !strings.Contains(strings.ToLower(r.Header.Get("Connection")), "upgrade") {
-			r.Header.Set("Connection", "Upgrade")
-		}
-		if !strings.Contains(strings.ToLower(r.Header.Get("Upgrade")), "websocket") {
-			r.Header.Set("Upgrade", "websocket")
-		}
-	}
-
-	docID := chi.URLParam(r, "id")
-	if docID == "" {
-		writeError(w, http.StatusBadRequest, "docId erforderlich")
-		return
-	}
-
-	userID := s.authenticateUserFromReq(r)
-	if userID == "" {
-		userID = auth.GetUserID(r.Context())
-	}
-	if userID == "" {
-		userID = "anonymous"
-	}
-
-	canWrite := false
-	if userID != "anonymous" {
-		doc, err := s.store.GetDocumentByID(userID, docID)
-		if err != nil {
-			writeError(w, http.StatusForbidden, "Kein Zugriff auf dieses Dokument")
-			return
-		}
-		canWrite = doc.IsOwner || doc.Permission == "owner" || doc.Permission == "write"
-	}
-
-	clientID := r.URL.Query().Get("clientId")
-	room := s.wsHub.GetOrCreateDocRoom(docID)
-	room.ServeDocWS(w, r, userID, clientID, canWrite)
-}
-
 // --- REALTIME LISTS & SHARING ---
 
 func (s *Server) handleGetAllLists(w http.ResponseWriter, r *http.Request) {
@@ -1608,6 +1647,30 @@ func (s *Server) handleToggleListItem(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, item)
 }
 
+func (s *Server) handleUpdateListItem(w http.ResponseWriter, r *http.Request) {
+	listID := chi.URLParam(r, "id")
+	itemID := chi.URLParam(r, "itemId")
+
+	var req struct {
+		Content  *string `json:"content"`
+		Category *string `json:"category"`
+		Quantity *string `json:"quantity"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeError(w, http.StatusBadRequest, "Ungültiges JSON")
+		return
+	}
+
+	item, err := s.store.UpdateListItem(itemID, req.Content, req.Category, req.Quantity)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	s.wsHub.BroadcastListEvent(listID, "ITEM_UPDATED", item)
+	writeJSON(w, http.StatusOK, item)
+}
+
 func (s *Server) handleDeleteListItem(w http.ResponseWriter, r *http.Request) {
 	listID := chi.URLParam(r, "id")
 	itemID := chi.URLParam(r, "itemId")
@@ -1686,17 +1749,9 @@ func (s *Server) handleWebSocket(w http.ResponseWriter, r *http.Request) {
 		roomID = r.URL.Query().Get("spaceId")
 	}
 
-	token := r.URL.Query().Get("token")
-	if token == "" {
-		if authHdr := r.Header.Get("Authorization"); strings.HasPrefix(authHdr, "Bearer ") {
-			token = strings.TrimPrefix(authHdr, "Bearer ")
-		}
-	}
-	userID := "anonymous"
-	if token != "" {
-		if claims, err := auth.ValidateToken(s.cfg.JWTSecret, token); err == nil {
-			userID = claims.UserID
-		}
+	userID := s.authenticateUserFromReq(r)
+	if userID == "" {
+		userID = "anonymous"
 	}
 	s.wsHub.ServeWS(w, r, roomID, userID)
 }
@@ -1707,17 +1762,9 @@ func (s *Server) handleSSE(w http.ResponseWriter, r *http.Request) {
 		roomID = r.URL.Query().Get("spaceId")
 	}
 
-	token := r.URL.Query().Get("token")
-	if token == "" {
-		if authHdr := r.Header.Get("Authorization"); strings.HasPrefix(authHdr, "Bearer ") {
-			token = strings.TrimPrefix(authHdr, "Bearer ")
-		}
-	}
-	userID := "anonymous"
-	if token != "" {
-		if claims, err := auth.ValidateToken(s.cfg.JWTSecret, token); err == nil {
-			userID = claims.UserID
-		}
+	userID := s.authenticateUserFromReq(r)
+	if userID == "" {
+		userID = "anonymous"
 	}
 
 	var initialRooms []string
@@ -1933,6 +1980,33 @@ func (s *Server) handleExport(w http.ResponseWriter, r *http.Request) {
 
 // --- USER SETTINGS & ALARMS ---
 
+func (s *Server) handleLogout(w http.ResponseWriter, r *http.Request) {
+	userID := auth.GetUserID(r.Context())
+	authHeader := r.Header.Get("Authorization")
+	if strings.HasPrefix(authHeader, "Bearer ") {
+		tokenStr := strings.TrimPrefix(authHeader, "Bearer ")
+		if claims, err := auth.ValidateToken(s.cfg.JWTSecret, tokenStr); err == nil && claims != nil {
+			var exp time.Time
+			if claims.ExpiresAt != nil {
+				exp = claims.ExpiresAt.Time
+			} else {
+				exp = time.Now().Add(30 * 24 * time.Hour)
+			}
+			_ = s.store.RevokeToken(tokenStr, userID, exp)
+		}
+	}
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
+
+func (s *Server) handleRevokeAllSessions(w http.ResponseWriter, r *http.Request) {
+	userID := auth.GetUserID(r.Context())
+	if err := s.store.RevokeAllUserTokens(userID); err != nil {
+		writeError(w, http.StatusInternalServerError, "Sitzungen konnten nicht beendet werden")
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]bool{"success": true})
+}
+
 func (s *Server) handleUpdateUserSettings(w http.ResponseWriter, r *http.Request) {
 	userID := auth.GetUserID(r.Context())
 	var req struct {
@@ -2108,7 +2182,7 @@ func (s *Server) handleUpdateTaskList(w http.ResponseWriter, r *http.Request) {
 	}
 	tl, err := s.store.UpdateTaskList(userID, listID, req.Title, req.Icon, req.Color, req.TeamID, req.SpaceID, req.Columns)
 	if err != nil {
-		writeError(w, http.StatusBadRequest, err.Error())
+		writeStoreError(w, http.StatusBadRequest, err)
 		return
 	}
 	s.wsHub.BroadcastToAll("TASK_LIST_UPDATED", tl)
@@ -2156,12 +2230,17 @@ func (s *Server) handleCreateTaskListShare(w http.ResponseWriter, r *http.Reques
 	var req struct {
 		TargetType string `json:"targetType"` // team | user
 		TargetID   string `json:"targetId"`
+		Permission string `json:"permission"` // editor | viewer
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeError(w, http.StatusBadRequest, "Ungültiges JSON")
 		return
 	}
-	share, err := s.store.AddTaskListShare(listID, req.TargetType, req.TargetID, userID)
+	permission := strings.ToLower(strings.TrimSpace(req.Permission))
+	if permission != "viewer" {
+		permission = "editor"
+	}
+	share, err := s.store.AddTaskListShare(listID, req.TargetType, req.TargetID, permission, userID)
 	if err != nil {
 		writeError(w, http.StatusBadRequest, err.Error())
 		return

internal/api/server_test.go

@@ -45,7 +45,7 @@ func setupTestServer(t *testing.T) (*Server, *storage.Store, string) {
 	hub := ws.NewHub()
 	srv := NewServer(cfg, store, hub, nil)
 
-	token, err := auth.GenerateToken(cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
+	token, err := auth.GenerateToken(cfg.JWTSecret, user.ID, user.Email, user.DisplayName, user.TokenVersion)
 	if err != nil {
 		t.Fatalf("failed to generate token: %v", err)
 	}
@@ -219,7 +219,7 @@ func TestQuickDumpToTriageAndDirectTargets(t *testing.T) {
 	router := srv.Router()
 
 	// Verify stale token from non-existent user is rejected (401)
-	staleToken, _ := auth.GenerateToken("test-jwt-secret-key", "usr_non_existent", "old@mindsift.local", "Old")
+	staleToken, _ := auth.GenerateToken("test-jwt-secret-key", "usr_non_existent", "old@mindsift.local", "Old", 1)
 	req := httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
 	req.Header.Set("Authorization", "Bearer "+staleToken)
 	rec := httptest.NewRecorder()
@@ -548,11 +548,11 @@ func TestSpaceMembersDirectInvitationAPI(t *testing.T) {
 		t.Fatalf("failed to get normal user: %v", err)
 	}
 
-	adminToken, err := auth.GenerateToken(cfg.JWTSecret, adminUser.ID, adminUser.Email, adminUser.DisplayName)
+	adminToken, err := auth.GenerateToken(cfg.JWTSecret, adminUser.ID, adminUser.Email, adminUser.DisplayName, adminUser.TokenVersion)
 	if err != nil {
 		t.Fatalf("failed to generate token: %v", err)
 	}
-	userToken, err := auth.GenerateToken(cfg.JWTSecret, normalUser.ID, normalUser.Email, normalUser.DisplayName)
+	userToken, err := auth.GenerateToken(cfg.JWTSecret, normalUser.ID, normalUser.Email, normalUser.DisplayName, normalUser.TokenVersion)
 	if err != nil {
 		t.Fatalf("failed to generate token: %v", err)
 	}
@@ -663,7 +663,7 @@ func TestWorkspaceTagsAPI(t *testing.T) {
 	router := srv.Router()
 
 	user, _ := store.CreateUser("api_tag_user@example.com", "hash", "API Tag User", "member")
-	token, _ := auth.GenerateToken(srv.cfg.JWTSecret, user.ID, user.Email, user.DisplayName)
+	token, _ := auth.GenerateToken(srv.cfg.JWTSecret, user.ID, user.Email, user.DisplayName, user.TokenVersion)
 
 	// Create document with hashtags
 	blocks := []domain.DocumentBlock{
@@ -841,93 +841,6 @@ func TestWebhookTriageBadgeAndIngestion(t *testing.T) {
 	}
 }
 
-func TestDocRoomLiveStateAndDebouncedFlush(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "docroom_test.db")
-
-	store, err := storage.NewStore(dbPath)
-	if err != nil {
-		t.Fatalf("NewStore failed: %v", err)
-	}
-	defer store.Close()
-
-	cfg := &config.Config{
-		JWTSecret:         "test-jwt-secret-key",
-		AllowRegistration: true,
-	}
-	hub := ws.NewHub()
-	srv := NewServer(cfg, store, hub, nil)
-	router := srv.Router()
-
-	user, err := store.CreateUser("outliner_ws@example.com", "hash", "WS Outliner User", "member")
-	if err != nil {
-		t.Fatalf("CreateUser failed: %v", err)
-	}
-	token, _ := auth.GenerateToken(cfg.JWTSecret, user.ID, user.Email, user.Role)
-
-	doc, err := store.CreateDocument(user.ID, "", "Initial Title", "📄", "", nil, nil, false)
-	if err != nil {
-		t.Fatalf("CreateDocument failed: %v", err)
-	}
-
-	// 1. Mutate in-memory DocRoom before 1.5s flush fires
-	room := hub.GetOrCreateDocRoom(doc.ID)
-	newContent := "Live RAM Block #ramtag"
-	newLevel := 1
-	room.HandleEvent(ws.DocSyncEvent{
-		Type:     "title_updated",
-		ClientID: "cli_1",
-		Title:    "RAM Updated Title",
-	}, nil)
-	room.HandleEvent(ws.DocSyncEvent{
-		Type:         "block_created",
-		ClientID:     "cli_1",
-		AfterBlockID: doc.Blocks[0].ID,
-		Block: &domain.DocumentBlock{
-			ID:      "blk_ram_2",
-			Type:    "text",
-			Content: newContent,
-			Level:   newLevel,
-		},
-	}, nil)
-
-	// 2. Verify GET /api/v1/documents/{id} immediately returns the un-flushed in-memory state
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/documents/"+doc.ID, nil)
-	req.Header.Set("Authorization", "Bearer "+token)
-	rec := httptest.NewRecorder()
-	router.ServeHTTP(rec, req)
-
-	if rec.Code != http.StatusOK {
-		t.Fatalf("expected 200 OK from GET document, got %d: %s", rec.Code, rec.Body.String())
-	}
-	var liveDoc domain.Document
-	_ = json.Unmarshal(rec.Body.Bytes(), &liveDoc)
-	if liveDoc.Title != "RAM Updated Title" {
-		t.Fatalf("expected live RAM title 'RAM Updated Title', got '%s'", liveDoc.Title)
-	}
-	if len(liveDoc.Blocks) != 2 || liveDoc.Blocks[1].Content != newContent {
-		t.Fatalf("expected 2 live blocks with RAM content, got %+v", liveDoc.Blocks)
-	}
-
-	// 3. Flush room to SQLite and verify persistence + tag extraction + markdown_cache
-	room.Flush()
-
-	persistedDoc, err := store.GetDocumentByID(user.ID, doc.ID)
-	if err != nil {
-		t.Fatalf("GetDocumentByID failed: %v", err)
-	}
-	if persistedDoc.Title != "RAM Updated Title" {
-		t.Fatalf("expected persisted title 'RAM Updated Title', got '%s'", persistedDoc.Title)
-	}
-	if !strings.Contains(persistedDoc.MarkdownCache, "  - Live RAM Block #ramtag") {
-		t.Fatalf("expected compiled markdown_cache to contain indented bullet, got:\n%s", persistedDoc.MarkdownCache)
-	}
-	tags, _ := store.GetWorkspaceTags(user.ID)
-	if len(tags) != 1 || tags[0].Tag != "ramtag" {
-		t.Fatalf("expected extracted #ramtag in block_tags, got %+v", tags)
-	}
-}
-
 func TestSSEGlobalEndpoint(t *testing.T) {
 	dbPath := filepath.Join(t.TempDir(), "test_sse.db")
 	store, err := storage.NewStore(dbPath)
@@ -997,7 +910,7 @@ func TestDecoupledFolderSharingAPI(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to create user B: %v", err)
 	}
-	tokenB, err := auth.GenerateToken(srv.cfg.JWTSecret, userB.ID, userB.Email, userB.DisplayName)
+	tokenB, err := auth.GenerateToken(srv.cfg.JWTSecret, userB.ID, userB.Email, userB.DisplayName, userB.TokenVersion)
 	if err != nil {
 		t.Fatalf("failed to generate token B: %v", err)
 	}
@@ -1121,7 +1034,7 @@ func TestDecoupledFolderSharingAPI(t *testing.T) {
 	}
 
 	// 7. Synchronous contents check:
-	// User B moves the document into a subfolder: "MeineOrdner/TeamProjekt/Archiv"
+	// User B (read-only recipient) cannot move documents within the shared folder:
 	moveDocPayload := map[string]string{
 		"folderPath": "MeineOrdner/TeamProjekt/Archiv",
 	}
@@ -1131,25 +1044,259 @@ func TestDecoupledFolderSharingAPI(t *testing.T) {
 	req.Header.Set("Content-Type", "application/json")
 	rec = httptest.NewRecorder()
 	router.ServeHTTP(rec, req)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("User B move doc into subfolder failed: %s", rec.Body.String())
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("Expected User B move doc in read-only shared folder to fail, got %d", rec.Code)
 	}
 
-	// User A must now see the document synchronized at "TeamProjekt/Archiv"!
-	req = httptest.NewRequest(http.MethodGet, "/api/v1/documents/"+createdDoc.ID, nil)
+	// User A (the owner) moves the document into a subfolder: "TeamProjekt/Archiv"
+	moveDocPayload = map[string]string{
+		"folderPath": "TeamProjekt/Archiv",
+	}
+	b, _ = json.Marshal(moveDocPayload)
+	req = httptest.NewRequest(http.MethodPut, "/api/v1/documents/"+createdDoc.ID+"/move", bytes.NewReader(b))
 	req.Header.Set("Authorization", "Bearer "+tokenA)
+	req.Header.Set("Content-Type", "application/json")
 	rec = httptest.NewRecorder()
 	router.ServeHTTP(rec, req)
 	if rec.Code != http.StatusOK {
-		t.Fatalf("User A get doc failed: %s", rec.Body.String())
+		t.Fatalf("User A move doc into subfolder failed: %s", rec.Body.String())
 	}
-	var docASynced domain.Document
-	_ = json.Unmarshal(rec.Body.Bytes(), &docASynced)
-	if docASynced.FolderPath != "TeamProjekt/Archiv" {
-		t.Fatalf("expected User A to see subfolder sync at 'TeamProjekt/Archiv', got %q", docASynced.FolderPath)
+
+	// User B must now see the document synchronized at "MeineOrdner/TeamProjekt/Archiv"!
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/documents/"+createdDoc.ID, nil)
+	req.Header.Set("Authorization", "Bearer "+tokenB)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("User B get doc failed: %s", rec.Body.String())
+	}
+	var docBSynced domain.Document
+	_ = json.Unmarshal(rec.Body.Bytes(), &docBSynced)
+	if docBSynced.FolderPath != "MeineOrdner/TeamProjekt/Archiv" {
+		t.Fatalf("expected User B to see subfolder sync at 'MeineOrdner/TeamProjekt/Archiv', got %q", docBSynced.FolderPath)
+	}
+}
+
+func TestTokenBlacklistingAndTokenVersionRevocation(t *testing.T) {
+	srv, store, _ := setupTestServer(t)
+	router := srv.Router()
+
+	// 1. Create a fresh user with known password
+	password := "initialPassword123"
+	hash, _ := auth.HashPassword(password)
+	user, err := store.CreateUser("revocation_test@example.com", hash, "Revocation Tester", "member")
+	if err != nil {
+		t.Fatalf("failed to create user: %v", err)
+	}
+
+	// 2. Perform login to get initial JWT
+	loginBody, _ := json.Marshal(map[string]string{
+		"login":    user.Email,
+		"password": password,
+	})
+	req := httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", bytes.NewReader(loginBody))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("login failed: %s", rec.Body.String())
+	}
+	var loginResp struct {
+		Token string `json:"token"`
+	}
+	_ = json.Unmarshal(rec.Body.Bytes(), &loginResp)
+	token1 := loginResp.Token
+	if token1 == "" {
+		t.Fatalf("expected token in login response")
+	}
+
+	// 3. Verify token1 works
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token1)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("token1 should be valid, got %d", rec.Code)
+	}
+
+	// 4. Test explicit logout (blacklists token1)
+	req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/logout", nil)
+	req.Header.Set("Authorization", "Bearer "+token1)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("logout failed: %s", rec.Body.String())
+	}
+
+	// Token1 must now be blacklisted and rejected (401)
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token1)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("expected 401 Unauthorized for blacklisted token1, got %d", rec.Code)
+	}
+
+	// Also check authenticateUserFromReq rejects token1
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/ws?token="+token1, nil)
+	if uid := srv.authenticateUserFromReq(req); uid != "" {
+		t.Fatalf("authenticateUserFromReq should reject blacklisted token1, got uid %q", uid)
+	}
+
+	// 5. Login again to get token2
+	req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", bytes.NewReader(loginBody))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	var loginResp2 struct {
+		Token string `json:"token"`
+	}
+	_ = json.Unmarshal(rec.Body.Bytes(), &loginResp2)
+	token2 := loginResp2.Token
+
+	// Token2 works
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token2)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("token2 should be valid, got %d", rec.Code)
+	}
+
+	// 6. Change password via UpdateUserPassword -> increments token_version
+	newPassword := "newSecretPassword456"
+	newHash, _ := auth.HashPassword(newPassword)
+	if err := store.UpdateUserPassword(user.ID, newHash); err != nil {
+		t.Fatalf("failed to update password: %v", err)
+	}
+
+	// Token2 must now be REJECTED (401) because its token_version is outdated!
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token2)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("expected 401 Unauthorized for token2 after password change, got %d", rec.Code)
+	}
+
+	// 7. Login with new password to get token3
+	loginNewBody, _ := json.Marshal(map[string]string{
+		"login":    user.Email,
+		"password": newPassword,
+	})
+	req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/login", bytes.NewReader(loginNewBody))
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	var loginResp3 struct {
+		Token string `json:"token"`
+	}
+	_ = json.Unmarshal(rec.Body.Bytes(), &loginResp3)
+	token3 := loginResp3.Token
+
+	// Token3 works
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token3)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("token3 should be valid, got %d", rec.Code)
+	}
+
+	// 8. Test revoke-all endpoint -> increments token_version and invalidates all existing sessions
+	req = httptest.NewRequest(http.MethodPost, "/api/v1/auth/revoke-all", nil)
+	req.Header.Set("Authorization", "Bearer "+token3)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("revoke-all failed: %s", rec.Body.String())
+	}
+
+	// Token3 must now be REJECTED (401)
+	req = httptest.NewRequest(http.MethodGet, "/api/v1/auth/me", nil)
+	req.Header.Set("Authorization", "Bearer "+token3)
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusUnauthorized {
+		t.Fatalf("expected 401 Unauthorized for token3 after revoke-all, got %d", rec.Code)
+	}
+}
+
+func TestDocumentSharingStrictlyReadOnly(t *testing.T) {
+	srv, store, _ := setupTestServer(t)
+	router := srv.Router()
+
+	userA, _ := store.CreateUser("user_a_ro@example.com", "hash", "User A", "member")
+	tokenA, _ := auth.GenerateToken(srv.cfg.JWTSecret, userA.ID, userA.Email, userA.DisplayName, userA.TokenVersion)
+
+	userB, _ := store.CreateUser("user_b_ro@example.com", "hash", "User B", "member")
+	tokenB, _ := auth.GenerateToken(srv.cfg.JWTSecret, userB.ID, userB.Email, userB.DisplayName, userB.TokenVersion)
+
+	// Create document owned by User A
+	blocks := []domain.DocumentBlock{
+		{ID: "b1", Type: "bullet", Content: "Row 1", Level: 0},
+		{ID: "b2", Type: "bullet", Content: "Row 2", Level: 0},
+	}
+	doc, err := store.CreateDocument(userA.ID, "", "Read Only Test Doc", "📝", "", blocks, nil, false)
+	if err != nil {
+		t.Fatalf("CreateDocument failed: %v", err)
+	}
+
+	// Share with User B (forced read-only)
+	_, err = store.CreateDocShare(userA.ID, doc.ID, userB.ID, "read")
+	if err != nil {
+		t.Fatalf("CreateDocShare failed: %v", err)
+	}
+
+	// 1. User B can read document
+	req := httptest.NewRequest(http.MethodGet, "/api/v1/documents/"+doc.ID, nil)
+	req.Header.Set("Authorization", "Bearer "+tokenB)
+	rec := httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("User B should be able to read doc, got status: %d", rec.Code)
+	}
+
+	// 2. User B tries to update document via PUT -> must fail (not owner)
+	newTitle := "Hacked Title"
+	updateBody, _ := json.Marshal(map[string]interface{}{"title": newTitle})
+	req = httptest.NewRequest(http.MethodPut, "/api/v1/documents/"+doc.ID, bytes.NewReader(updateBody))
+	req.Header.Set("Authorization", "Bearer "+tokenB)
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code == http.StatusOK {
+		t.Fatalf("expected error for User B updating document, got 200 OK")
+	}
+
+	// 3. User B tries to patch document blocks -> must fail (not owner)
+	patchBody, _ := json.Marshal(domain.DocBlocksPatchRequest{
+		Upserted: []domain.DocumentBlock{{ID: "b2", Content: "Hacked by User B"}},
+	})
+	req = httptest.NewRequest(http.MethodPatch, "/api/v1/documents/"+doc.ID+"/blocks", bytes.NewReader(patchBody))
+	req.Header.Set("Authorization", "Bearer "+tokenB)
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code == http.StatusOK {
+		t.Fatalf("expected error for User B patching document blocks, got 200 OK")
+	}
+
+	// 4. User A (owner) can successfully update document
+	ownerTitle := "Owner Updated Title"
+	ownerBody, _ := json.Marshal(map[string]interface{}{"title": ownerTitle})
+	req = httptest.NewRequest(http.MethodPut, "/api/v1/documents/"+doc.ID, bytes.NewReader(ownerBody))
+	req.Header.Set("Authorization", "Bearer "+tokenA)
+	req.Header.Set("Content-Type", "application/json")
+	rec = httptest.NewRecorder()
+	router.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("owner should be able to update document, got %d", rec.Code)
 	}
 }
 
 
 
 
+
+

internal/auth/auth.go

@@ -18,9 +18,10 @@ type contextKey string
 const UserIDContextKey contextKey = "mindsift_user_id"
 
 type Claims struct {
-	UserID      string `json:"userId"`
-	Email       string `json:"email"`
-	DisplayName string `json:"displayName"`
+	UserID       string `json:"userId"`
+	Email        string `json:"email"`
+	DisplayName  string `json:"displayName"`
+	TokenVersion int    `json:"tokenVersion"`
 	jwt.RegisteredClaims
 }
 
@@ -34,14 +35,24 @@ func CheckPassword(password, hash string) bool {
 	return err == nil
 }
 
-func GenerateToken(secret, userID, email, displayName string) (string, error) {
+func GenerateToken(secret, userID, email, displayName string, tokenVersion int) (string, error) {
+	if tokenVersion <= 0 {
+		tokenVersion = 1
+	}
+	b := make([]byte, 16)
+	_, _ = rand.Read(b)
+	jti := hex.EncodeToString(b)
+
+	now := time.Now()
 	claims := &Claims{
-		UserID:      userID,
-		Email:       email,
-		DisplayName: displayName,
+		UserID:       userID,
+		Email:        email,
+		DisplayName:  displayName,
+		TokenVersion: tokenVersion,
 		RegisteredClaims: jwt.RegisteredClaims{
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(30 * 24 * time.Hour)),
-			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			ID:        jti,
+			ExpiresAt: jwt.NewNumericDate(now.Add(30 * 24 * time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(now),
 			Issuer:    "mindsift",
 		},
 	}

internal/domain/models.go

@@ -101,6 +101,7 @@ type User struct {
 	AvatarURL           string   `json:"avatarUrl,omitempty"`
 	Role                string   `json:"role"` // admin | member
 	IsActive            bool     `json:"isActive"`
+	TokenVersion        int      `json:"tokenVersion"`
 	AlarmChannels       []string `json:"alarmChannels"` // email | discord | webhook
 	AlarmEmail          string   `json:"alarmEmail"`
 	DiscordWebhookURL   string   `json:"discordWebhookUrl"`
@@ -147,8 +148,10 @@ type Thought struct {
 	Source         string        `json:"source"`   // manual | voice | webhook
 	Status         ThoughtStatus `json:"status"`
 	IsCompleted    bool          `json:"isCompleted"`
-	ConvertedType  string        `json:"convertedType,omitempty"`  // task | document | list_item
+	ConvertedType  string        `json:"convertedType,omitempty"`  // task | document | list_item | document_block
 	ConvertedRefID string        `json:"convertedRefId,omitempty"` // referenced entity ID
+	DocID          string        `json:"docId,omitempty"`
+	BlockID        string        `json:"blockId,omitempty"`
 	DueDate        string        `json:"dueDate,omitempty"`
 	TaskListID     string        `json:"taskListId,omitempty"`
 	KanbanStatus   string        `json:"kanbanStatus,omitempty"` // todo | in_progress | done
@@ -181,6 +184,7 @@ type TaskListShare struct {
 	TargetName string `json:"targetName,omitempty"`
 	Email      string `json:"email,omitempty"`
 	AvatarURL  string `json:"avatarUrl,omitempty"`
+	Permission string `json:"permission"` // editor | viewer
 	CreatedAt  string `json:"createdAt"`
 }
 
@@ -208,6 +212,7 @@ type TaskList struct {
 	TeamName   string           `json:"teamName,omitempty"`
 	OwnerName  string           `json:"ownerName,omitempty"`
 	IsOwner    bool             `json:"isOwner"`
+	Permission string           `json:"permission,omitempty"` // owner | editor | viewer
 	Members    []TaskListMember `json:"members,omitempty"`
 	Shares     []TaskListShare  `json:"shares,omitempty"`
 	Columns    []KanbanColumn   `json:"columns,omitempty"`
@@ -269,6 +274,7 @@ type DocumentBlock struct {
 	Level      int     `json:"level"`
 	Position   float64 `json:"position"`
 	Collapsed  bool    `json:"collapsed,omitempty"`
+	TaskID     string  `json:"taskId,omitempty"`
 }
 
 func CompileBlocksToMarkdown(blocks []DocumentBlock) string {
@@ -336,13 +342,6 @@ type DocShare struct {
 	CreatedAt   string `json:"createdAt"`
 }
 
-type DocLockInfo struct {
-	DocID     string `json:"docId"`
-	UserID    string `json:"userId"`
-	UserName  string `json:"userName"`
-	ExpiresAt string `json:"expiresAt"`
-}
-
 type Document struct {
 	ID            string          `json:"id"`
 	UserID        string          `json:"userId"`

internal/storage/sqlite.go

@@ -72,6 +72,7 @@ func (s *Store) migrate() error {
 		display_name TEXT NOT NULL,
 		role TEXT NOT NULL DEFAULT 'member',
 		is_active INTEGER NOT NULL DEFAULT 1,
+		token_version INTEGER NOT NULL DEFAULT 1,
 		alarm_channels TEXT NOT NULL DEFAULT 'discord',
 		alarm_email TEXT NOT NULL DEFAULT '',
 		discord_webhook_url TEXT NOT NULL DEFAULT '',
@@ -307,6 +308,16 @@ func (s *Store) migrate() error {
 		key TEXT PRIMARY KEY,
 		value TEXT NOT NULL
 	);
+
+	CREATE TABLE IF NOT EXISTS revoked_tokens (
+		token_hash TEXT PRIMARY KEY,
+		user_id TEXT NOT NULL,
+		expires_at TEXT NOT NULL,
+		revoked_at TEXT NOT NULL
+	);
+
+	CREATE INDEX IF NOT EXISTS idx_revoked_tokens_expires ON revoked_tokens(expires_at);
+	CREATE INDEX IF NOT EXISTS idx_revoked_tokens_user ON revoked_tokens(user_id);
 	`
 	if _, err := s.db.Exec(schema); err != nil {
 		return err
@@ -318,6 +329,7 @@ func (s *Store) migrate() error {
 		"CREATE INDEX IF NOT EXISTS idx_users_username ON users(username);",
 		"ALTER TABLE users ADD COLUMN role TEXT NOT NULL DEFAULT 'member';",
 		"ALTER TABLE users ADD COLUMN is_active INTEGER NOT NULL DEFAULT 1;",
+		"ALTER TABLE users ADD COLUMN token_version INTEGER NOT NULL DEFAULT 1;",
 		"ALTER TABLE users ADD COLUMN alarm_channels TEXT NOT NULL DEFAULT 'discord';",
 		"ALTER TABLE users ADD COLUMN alarm_email TEXT NOT NULL DEFAULT '';",
 		"ALTER TABLE users ADD COLUMN discord_webhook_url TEXT NOT NULL DEFAULT '';",
@@ -344,6 +356,7 @@ func (s *Store) migrate() error {
 		"CREATE TABLE IF NOT EXISTS task_list_shares (id TEXT PRIMARY KEY, task_list_id TEXT NOT NULL, target_type TEXT NOT NULL CHECK(target_type IN ('team', 'user')), target_id TEXT NOT NULL, created_at TEXT NOT NULL, created_by TEXT NOT NULL, UNIQUE(task_list_id, target_type, target_id));",
 		"CREATE INDEX IF NOT EXISTS idx_task_list_shares_target ON task_list_shares(target_type, target_id);",
 		"CREATE INDEX IF NOT EXISTS idx_task_list_shares_list ON task_list_shares(task_list_id);",
+		"ALTER TABLE task_list_shares ADD COLUMN permission TEXT NOT NULL DEFAULT 'editor';",
 
 		"CREATE TABLE IF NOT EXISTS doc_team_shares (id TEXT PRIMARY KEY, doc_id TEXT NOT NULL, team_id TEXT NOT NULL, permission TEXT NOT NULL CHECK(permission IN ('read', 'write')), created_at TEXT NOT NULL, created_by TEXT NOT NULL, UNIQUE(doc_id, team_id));",
 		"CREATE INDEX IF NOT EXISTS idx_doc_team_shares_team ON doc_team_shares(team_id);",
@@ -402,6 +415,11 @@ func (s *Store) migrate() error {
 	// Backfill username for existing accounts where username is empty
 	_, _ = s.db.Exec(`UPDATE users SET username = LOWER(SUBSTR(email, 1, INSTR(email, '@') - 1)) WHERE (username IS NULL OR username = '') AND INSTR(email, '@') > 0`)
 
+	// Ensure all existing document & folder shares are strictly read-only
+	_, _ = s.db.Exec(`UPDATE doc_shares SET permission = 'read' WHERE permission != 'read'`)
+	_, _ = s.db.Exec(`UPDATE doc_team_shares SET permission = 'read' WHERE permission != 'read'`)
+	_, _ = s.db.Exec(`UPDATE workspace_folder_shares SET permission = 'read' WHERE permission != 'read'`)
+
 	// Default system settings (public registration disabled by default; invite or admin creation required)
 	_, _ = s.db.Exec(`INSERT OR IGNORE INTO system_settings (key, value) VALUES 
 		('sharing_mode', 'teams_only'),
@@ -536,7 +554,7 @@ func (s *Store) EnsureDefaultUser() (*domain.User, error) {
 
 // --- USERS ---
 
-const userSelectCols = `id, email, username, password_hash, display_name, role, is_active, alarm_channels, alarm_email, discord_webhook_url, custom_webhook_url, notify_before_minutes, avatar_url, created_at`
+const userSelectCols = `id, email, username, password_hash, display_name, role, is_active, token_version, alarm_channels, alarm_email, discord_webhook_url, custom_webhook_url, notify_before_minutes, avatar_url, created_at`
 
 func parseAlarmChannels(raw string) []string {
 	parts := strings.Split(raw, ",")
@@ -558,13 +576,16 @@ func scanUser(row interface{ Scan(dest ...any) error }) (*domain.User, error) {
 	var channelsRaw string
 	err := row.Scan(
 		&u.ID, &u.Email, &u.Username, &u.PasswordHash, &u.DisplayName,
-		&u.Role, &isActiveInt, &channelsRaw, &u.AlarmEmail,
+		&u.Role, &isActiveInt, &u.TokenVersion, &channelsRaw, &u.AlarmEmail,
 		&u.DiscordWebhookURL, &u.CustomWebhookURL, &u.NotifyBeforeMinutes, &u.AvatarURL, &u.CreatedAt,
 	)
 	if err != nil {
 		return nil, err
 	}
 	u.IsActive = isActiveInt != 0
+	if u.TokenVersion <= 0 {
+		u.TokenVersion = 1
+	}
 	if u.Role == "" {
 		u.Role = "member"
 	}
@@ -604,6 +625,7 @@ func (s *Store) CreateUserWithUsername(email, username, passwordHash, displayNam
 		DisplayName:         strings.TrimSpace(displayName),
 		Role:                role,
 		IsActive:            true,
+		TokenVersion:        1,
 		AlarmChannels:       []string{},
 		AlarmEmail:          cleanEmail,
 		DiscordWebhookURL:   "",
@@ -613,8 +635,8 @@ func (s *Store) CreateUserWithUsername(email, username, passwordHash, displayNam
 		CreatedAt:           domain.NowISO(),
 	}
 	_, err := s.db.Exec(
-		`INSERT INTO users (id, email, username, password_hash, display_name, role, is_active, alarm_channels, alarm_email, discord_webhook_url, custom_webhook_url, notify_before_minutes, avatar_url, created_at)
-		 VALUES (?, ?, ?, ?, ?, ?, 1, '', ?, '', '', 30, '', ?)`,
+		`INSERT INTO users (id, email, username, password_hash, display_name, role, is_active, token_version, alarm_channels, alarm_email, discord_webhook_url, custom_webhook_url, notify_before_minutes, avatar_url, created_at)
+		 VALUES (?, ?, ?, ?, ?, ?, 1, 1, '', ?, '', '', 30, '', ?)`,
 		u.ID, u.Email, u.Username, u.PasswordHash, u.DisplayName, u.Role, u.AlarmEmail, u.CreatedAt,
 	)
 	if err != nil {
@@ -811,14 +833,17 @@ func (s *Store) UpdateUserFull(
 	if avatarURL != nil {
 		u.AvatarURL = strings.TrimSpace(*avatarURL)
 	}
+	if (role != nil && *role != u.Role) || (isActive != nil && !*isActive && u.IsActive) {
+		u.TokenVersion++
+	}
 	activeInt := 0
 	if u.IsActive {
 		activeInt = 1
 	}
 	channelsStr := strings.Join(u.AlarmChannels, ",")
 	_, err = s.db.Exec(
-		`UPDATE users SET display_name = ?, email = ?, role = ?, is_active = ?, alarm_channels = ?, alarm_email = ?, discord_webhook_url = ?, custom_webhook_url = ?, notify_before_minutes = ?, avatar_url = ? WHERE id = ?`,
-		u.DisplayName, u.Email, u.Role, activeInt, channelsStr, u.AlarmEmail, u.DiscordWebhookURL, u.CustomWebhookURL, u.NotifyBeforeMinutes, u.AvatarURL, userID,
+		`UPDATE users SET display_name = ?, email = ?, role = ?, is_active = ?, token_version = ?, alarm_channels = ?, alarm_email = ?, discord_webhook_url = ?, custom_webhook_url = ?, notify_before_minutes = ?, avatar_url = ? WHERE id = ?`,
+		u.DisplayName, u.Email, u.Role, activeInt, u.TokenVersion, channelsStr, u.AlarmEmail, u.DiscordWebhookURL, u.CustomWebhookURL, u.NotifyBeforeMinutes, u.AvatarURL, userID,
 	)
 	if err != nil {
 		return nil, err
@@ -827,15 +852,45 @@ func (s *Store) UpdateUserFull(
 }
 
 func (s *Store) UpdateUserPassword(userID, passwordHash string) error {
-	_, err := s.db.Exec(`UPDATE users SET password_hash = ? WHERE id = ?`, passwordHash, userID)
+	_, err := s.db.Exec(`UPDATE users SET password_hash = ?, token_version = token_version + 1 WHERE id = ?`, passwordHash, userID)
 	return err
 }
 
 func (s *Store) DeleteUser(userID string) error {
+	_, _ = s.db.Exec(`DELETE FROM revoked_tokens WHERE user_id = ?`, userID)
 	_, err := s.db.Exec(`DELETE FROM users WHERE id = ?`, userID)
 	return err
 }
 
+// RevokeToken adds an individual JWT to the blacklist until its expiration date
+func (s *Store) RevokeToken(tokenStr, userID string, expiresAt time.Time) error {
+	hash := auth.HashAPIKey(tokenStr)
+	_, err := s.db.Exec(
+		`INSERT OR REPLACE INTO revoked_tokens (token_hash, user_id, expires_at, revoked_at) VALUES (?, ?, ?, ?)`,
+		hash, userID, expiresAt.UTC().Format(time.RFC3339), time.Now().UTC().Format(time.RFC3339),
+	)
+	// Idempotently prune old expired tokens
+	_, _ = s.db.Exec(`DELETE FROM revoked_tokens WHERE expires_at < ?`, time.Now().UTC().Format(time.RFC3339))
+	return err
+}
+
+// IsTokenRevoked checks if a specific JWT token has been explicitly blacklisted
+func (s *Store) IsTokenRevoked(tokenStr string) bool {
+	hash := auth.HashAPIKey(tokenStr)
+	var count int
+	err := s.db.QueryRow(
+		`SELECT COUNT(1) FROM revoked_tokens WHERE token_hash = ? AND expires_at >= ?`,
+		hash, time.Now().UTC().Format(time.RFC3339),
+	).Scan(&count)
+	return err == nil && count > 0
+}
+
+// RevokeAllUserTokens increments the user's token_version, instantly invalidating all existing JWTs for that user
+func (s *Store) RevokeAllUserTokens(userID string) error {
+	_, err := s.db.Exec(`UPDATE users SET token_version = token_version + 1 WHERE id = ?`, userID)
+	return err
+}
+
 // --- THOUGHTS & TRIAGE ---
 
 func (s *Store) CreateThought(userID, content, priority, source, dueDate string) (*domain.Thought, error) {
@@ -856,8 +911,35 @@ func (s *Store) CreateThoughtWithDetails(userID, content, priority, source, dueD
 	if kanbanStatus == "" {
 		kanbanStatus = "todo"
 	}
+	if err := s.ensureTaskListWritable(userID, taskListID); err != nil {
+		return nil, err
+	}
 
 	tags := domain.ExtractTags(content)
+	if strings.EqualFold(source, "voice") {
+		hasDiktat := false
+		for _, tag := range tags {
+			if strings.EqualFold(tag, "diktat") {
+				hasDiktat = true
+				break
+			}
+		}
+		if !hasDiktat {
+			tags = append(tags, "diktat")
+		}
+	}
+	if strings.EqualFold(source, "webhook") {
+		hasWebhook := false
+		for _, tag := range tags {
+			if strings.EqualFold(tag, "webhook") {
+				hasWebhook = true
+				break
+			}
+		}
+		if !hasWebhook {
+			tags = append(tags, "webhook")
+		}
+	}
 	tagsJSON, _ := json.Marshal(tags)
 
 	t := &domain.Thought{
@@ -915,6 +997,11 @@ func scanThought(rows interface {
 	}
 	t.Tags = []string{}
 	_ = json.Unmarshal([]byte(tagsStr), &t.Tags)
+	if t.ConvertedType == "document_block" && strings.Contains(t.ConvertedRefID, ":") {
+		parts := strings.SplitN(t.ConvertedRefID, ":", 2)
+		t.DocID = parts[0]
+		t.BlockID = parts[1]
+	}
 	t.Subtasks = []domain.SubTask{}
 	if subtasksStr != "" && subtasksStr != "null" {
 		_ = json.Unmarshal([]byte(subtasksStr), &t.Subtasks)
@@ -1062,8 +1149,13 @@ func (s *Store) UpdateThoughtTriage(userID, thoughtID, action, convertTo, target
 	if dueDate == "" {
 		dueDate = thought.DueDate
 	}
+	if err := s.ensureTaskListWritable(userID, thought.TaskListID); err != nil {
+		return nil, err
+	}
 	if taskListID == "" {
 		taskListID = thought.TaskListID
+	} else if err := s.ensureTaskListWritable(userID, taskListID); err != nil {
+		return nil, err
 	}
 
 	switch action {
@@ -1084,23 +1176,23 @@ func (s *Store) UpdateThoughtTriage(userID, thoughtID, action, convertTo, target
 				title = title[:72] + "…"
 			}
 			blocks := make([]domain.DocumentBlock, 0)
-			formattedDate := domain.FormatGermanDateTime(thought.CreatedAt)
-			calloutText := "Ursprünglicher Gedanke aus deiner Inbox"
-			if formattedDate != "" {
-				calloutText += " vom " + formattedDate
-			}
+
+			// 17. Wenn ich eine Aufgabe zu einer Notiz mache, muss die erste Zeile das "To-Do" noch mal als "To-Do" enthalten, auch wenn es schon in der Überschrift steht. Wenn es vorher schon abgehakt war, dann den Zustand natürlich übernehmen.
 			blocks = append(blocks, domain.DocumentBlock{
 				ID:      domain.NewID("blk"),
-				Type:    "callout",
-				Content: calloutText,
+				Type:    "todo",
+				Content: thought.Content,
+				Checked: thought.IsCompleted,
 				Level:   0,
 			})
+
+			// 17a. Die anderen Details aus der Aufgabe sollen natürlich ebenfalls übernommen werden (Notizen, Subtasks, Fälligkeit/Priorität).
 			if strings.TrimSpace(thought.Notes) != "" {
 				blocks = append(blocks, domain.DocumentBlock{
 					ID:      domain.NewID("blk"),
 					Type:    "bullet",
 					Content: strings.TrimSpace(thought.Notes),
-					Level:   0,
+					Level:   1,
 				})
 			}
 			if len(thought.Subtasks) > 0 {
@@ -1110,10 +1202,25 @@ func (s *Store) UpdateThoughtTriage(userID, thoughtID, action, convertTo, target
 						Type:    "todo",
 						Content: st.Title,
 						Checked: st.IsCompleted,
-						Level:   0,
+						Level:   1,
 					})
 				}
 			}
+			var metaItems []string
+			if thought.DueDate != "" {
+				metaItems = append(metaItems, "Fällig: "+thought.DueDate)
+			}
+			if thought.Priority != "" && thought.Priority != "normal" {
+				metaItems = append(metaItems, "Priorität: "+thought.Priority)
+			}
+			if len(metaItems) > 0 {
+				blocks = append(blocks, domain.DocumentBlock{
+					ID:      domain.NewID("blk"),
+					Type:    "bullet",
+					Content: strings.Join(metaItems, " • "),
+					Level:   1,
+				})
+			}
 			if len(blocks) == 1 {
 				blocks = append(blocks, domain.DocumentBlock{
 					ID:      domain.NewID("blk"),
@@ -1156,6 +1263,14 @@ func (s *Store) UpdateThoughtDetails(userID, thoughtID string, content *string,
 	if err != nil {
 		return nil, err
 	}
+	if err := s.ensureTaskListWritable(userID, thought.TaskListID); err != nil {
+		return nil, err
+	}
+	if taskListID != nil && *taskListID != thought.TaskListID {
+		if err := s.ensureTaskListWritable(userID, *taskListID); err != nil {
+			return nil, err
+		}
+	}
 
 	if content != nil {
 		thought.Content = strings.TrimSpace(*content)
@@ -1224,6 +1339,9 @@ func (s *Store) DeleteThought(userID, thoughtID string) error {
 	if err != nil {
 		return err
 	}
+	if err := s.ensureTaskListWritable(userID, thought.TaskListID); err != nil {
+		return err
+	}
 	_, err = s.db.Exec(`DELETE FROM thoughts WHERE id = ?`, thought.ID)
 	return err
 }
@@ -1477,7 +1595,7 @@ func (s *Store) PatchDocumentBlocks(userID, docID string, req domain.DocBlocksPa
 	if err != nil {
 		return nil, nil, err
 	}
-	if !doc.IsOwner && doc.Permission != "write" {
+	if !doc.IsOwner {
 		return nil, nil, fmt.Errorf("keine Schreibberechtigung für dieses Dokument (nur Lesezugriff)")
 	}
 
@@ -2225,7 +2343,7 @@ func (s *Store) UpdateDocument(userID, docID string, title, icon, folderPath *st
 	isOnlyPinChange := isPinned != nil && title == nil && icon == nil && folderPath == nil && blocks == nil && tags == nil
 	isOnlyFolderMove := folderPath != nil && title == nil && icon == nil && blocks == nil && tags == nil && isPinned == nil
 
-	if !doc.IsOwner && doc.Permission != "write" && !isOnlyPinChange && !isOnlyFolderMove {
+	if !doc.IsOwner && !isOnlyPinChange && !isOnlyFolderMove {
 		return nil, fmt.Errorf("keine Schreibberechtigung für dieses Dokument (nur Lesezugriff)")
 	}
 
@@ -2266,7 +2384,7 @@ func (s *Store) UpdateDocument(userID, docID string, title, icon, folderPath *st
 	if title != nil {
 		doc.Title = strings.TrimSpace(*title)
 	}
-	if icon != nil && *icon != "" {
+	if icon != nil {
 		doc.Icon = *icon
 	}
 	if tags != nil {
@@ -2301,6 +2419,34 @@ func (s *Store) UpdateDocument(userID, docID string, title, icon, folderPath *st
 	}
 	if blocks != nil {
 		_ = s.indexDocBlockTags(doc.ID, doc.UserID, doc.Blocks)
+		for _, b := range doc.Blocks {
+			if b.TaskID != "" {
+				s.SyncTaskFromBlockCheck(doc.UserID, b.TaskID, b.Checked)
+			}
+		}
+
+		// When a block is deleted from the note, unlink the corresponding task in thoughts without deleting the task
+		remainingBlockIDs := make(map[string]bool)
+		for _, b := range doc.Blocks {
+			remainingBlockIDs[b.ID] = true
+		}
+		rows, err := s.db.Query(`SELECT id, converted_ref_id, block_id FROM thoughts WHERE (doc_id = ? OR converted_ref_id LIKE ?) AND converted_type = 'document_block'`, docID, docID+":%")
+		if err == nil {
+			for rows.Next() {
+				var tid, refID, bID string
+				if err := rows.Scan(&tid, &refID, &bID); err == nil {
+					bid := bID
+					if bid == "" && strings.Contains(refID, ":") {
+						parts := strings.SplitN(refID, ":", 2)
+						bid = parts[1]
+					}
+					if !remainingBlockIDs[bid] {
+						_, _ = s.db.Exec(`UPDATE thoughts SET converted_type = '', converted_ref_id = '', doc_id = '', block_id = '' WHERE id = ?`, tid)
+					}
+				}
+			}
+			_ = rows.Close()
+		}
 	}
 	return doc, nil
 }
@@ -2835,8 +2981,8 @@ func (s *Store) MoveDocument(userID, docID, targetFolderPath string) (*domain.Do
 		if err != nil {
 			return nil, err
 		}
-		if !shFolder.IsOwner && shFolder.Permission != "write" {
-			return nil, fmt.Errorf("keine Schreibberechtigung für diesen geteilten Ordner")
+		if !shFolder.IsOwner {
+			return nil, fmt.Errorf("nur der Eigentümer dieses geteilten Ordners kann Dateien dorthin verschieben")
 		}
 
 		// Update document to belong to targetSharedFolderID
@@ -2859,7 +3005,7 @@ func (s *Store) MoveDocument(userID, docID, targetFolderPath string) (*domain.Do
 	// Target is NOT inside a shared folder (personal / standalone)
 	if doc.SharedFolderID != "" {
 		// Moving OUT of a shared folder into a personal folder
-		if !doc.IsOwner && doc.Permission != "write" {
+		if !doc.IsOwner {
 			return nil, fmt.Errorf("keine Berechtigung, die Notiz aus dem geteilten Ordner zu verschieben")
 		}
 		_, err = s.db.Exec(`UPDATE documents SET shared_folder_id = '', sub_folder_path = '', folder_path = ?, updated_at = ? WHERE id = ?`,
@@ -3285,8 +3431,8 @@ func (s *Store) CreateFolderShare(currentUserID, folderID, targetType, targetIde
 	if err != nil {
 		return nil, err
 	}
-	if !f.IsOwner && f.Permission != "write" {
-		return nil, fmt.Errorf("nur der Eigentümer oder Bearbeiter kann Ordner-Freigaben verwalten")
+	if !f.IsOwner {
+		return nil, fmt.Errorf("nur der Eigentümer kann Ordner-Freigaben verwalten")
 	}
 
 	cleanType := strings.TrimSpace(targetType)
@@ -3299,9 +3445,8 @@ func (s *Store) CreateFolderShare(currentUserID, folderID, targetType, targetIde
 		}
 	}
 
-	if permission != "read" && permission != "write" {
-		permission = "read"
-	}
+	// Geteilte Ordner können ausschließlich mit Leserberechtigung geteilt werden (wie Dokumente)
+	permission = "read"
 
 	var targetID, targetName, email, avatarURL string
 	if cleanType == "team" {
@@ -3515,8 +3660,8 @@ func (s *Store) CreateDocTeamShare(currentUserID, docID, teamID, permission stri
 	if err != nil {
 		return nil, err
 	}
-	if !doc.IsOwner && doc.Permission != "write" {
-		return nil, fmt.Errorf("nur der Eigentümer oder Bearbeiter kann Freigaben verwalten")
+	if !doc.IsOwner {
+		return nil, fmt.Errorf("nur der Eigentümer kann Freigaben verwalten")
 	}
 
 	cleanTeamID := strings.TrimSpace(teamID)
@@ -3526,9 +3671,8 @@ func (s *Store) CreateDocTeamShare(currentUserID, docID, teamID, permission stri
 		return nil, fmt.Errorf("team nicht gefunden")
 	}
 
-	if permission != "read" && permission != "write" {
-		permission = "read"
-	}
+	// Document sharing is strictly read-only
+	permission = "read"
 
 	now := domain.NowISO()
 	shareID := domain.NewID("share")
@@ -3560,20 +3704,19 @@ func (s *Store) CreateDocShare(currentUserID, docID, targetUserIdentifier, permi
 	if err != nil {
 		return nil, err
 	}
-	if !doc.IsOwner && doc.Permission != "write" {
-		return nil, fmt.Errorf("nur der Eigentümer oder Bearbeiter kann Freigaben verwalten")
+	if !doc.IsOwner {
+		return nil, fmt.Errorf("nur der Eigentümer kann Freigaben verwalten")
 	}
 
 	cleanTarget := strings.TrimSpace(targetUserIdentifier)
 
 	// If identifier looks like a team or is prefixed with team_, route to CreateDocTeamShare
 	if strings.HasPrefix(cleanTarget, "team_") {
-		return s.CreateDocTeamShare(currentUserID, docID, cleanTarget, permission)
+		return s.CreateDocTeamShare(currentUserID, docID, cleanTarget, "read")
 	}
 
-	if permission != "read" && permission != "write" {
-		permission = "read"
-	}
+	// Document sharing is strictly read-only
+	permission = "read"
 
 	// Resolve target user by ID, username, or Email
 	var targetUser *domain.User
@@ -4039,6 +4182,147 @@ func (s *Store) ToggleListItem(itemID string, isCompleted bool, userID, userName
 	return &it, nil
 }
 
+func (s *Store) UpdateListItem(itemID string, content *string, category *string, quantity *string) (*domain.ListItem, error) {
+	now := domain.NowISO()
+	var it domain.ListItem
+	var dInt int
+	err := s.db.QueryRow(
+		`SELECT id, list_id, content, category, quantity, is_completed, completed_by, completed_by_name, sort_order, created_at, completed_at
+		 FROM list_items WHERE id = ?`,
+		itemID,
+	).Scan(&it.ID, &it.ListID, &it.Content, &it.Category, &it.Quantity, &dInt, &it.CompletedBy, &it.CompletedByName, &it.SortOrder, &it.CreatedAt, &it.CompletedAt)
+	if err != nil {
+		return nil, err
+	}
+	it.IsCompleted = dInt != 0
+
+	if content != nil {
+		it.Content = *content
+	}
+	if category != nil {
+		it.Category = *category
+	}
+	if quantity != nil {
+		it.Quantity = *quantity
+	}
+
+	_, err = s.db.Exec(`UPDATE list_items SET content = ?, category = ?, quantity = ? WHERE id = ?`, it.Content, it.Category, it.Quantity, itemID)
+	if err != nil {
+		return nil, err
+	}
+	_, _ = s.db.Exec(`UPDATE lists SET updated_at = ? WHERE id = ?`, now, it.ListID)
+	return &it, nil
+}
+
+func (s *Store) CreateTaskFromDocBlock(userID, docID, blockID, content string, checked bool) (*domain.Thought, error) {
+	doc, err := s.GetDocumentByID(userID, docID)
+	if err != nil {
+		return nil, err
+	}
+	t, err := s.CreateThoughtWithDetails(userID, content, "normal", "manual", "", "", "todo", "")
+	if err != nil {
+		return nil, err
+	}
+	t.ConvertedType = "document_block"
+	t.ConvertedRefID = docID + ":" + blockID
+	t.DocID = docID
+	t.BlockID = blockID
+	t.IsCompleted = checked
+	t.Status = domain.StatusKept
+	doneInt := 0
+	if checked {
+		doneInt = 1
+		t.KanbanStatus = "done"
+	}
+	_, _ = s.db.Exec(`UPDATE thoughts SET converted_type = 'document_block', converted_ref_id = ?, is_completed = ?, kanban_status = ?, status = 'kept' WHERE id = ?`,
+		t.ConvertedRefID, doneInt, t.KanbanStatus, t.ID)
+
+	var updatedBlocks []domain.DocumentBlock
+	found := false
+	for _, b := range doc.Blocks {
+		if b.ID == blockID {
+			b.TaskID = t.ID
+			b.Checked = checked
+			found = true
+		}
+		updatedBlocks = append(updatedBlocks, b)
+	}
+	if found {
+		_, _ = s.UpdateDocument(userID, docID, nil, nil, nil, &updatedBlocks, nil, nil)
+	}
+	return t, nil
+}
+
+func (s *Store) SyncDocBlockAndTask(userID, taskID string, isCompleted bool) {
+	t, err := s.GetThoughtByID(userID, taskID)
+	if err != nil || t == nil || t.ConvertedType != "document_block" || !strings.Contains(t.ConvertedRefID, ":") {
+		return
+	}
+	parts := strings.SplitN(t.ConvertedRefID, ":", 2)
+	docID, blockID := parts[0], parts[1]
+	doc, err := s.GetDocumentByID(userID, docID)
+	if err != nil || doc == nil {
+		return
+	}
+	var updatedBlocks []domain.DocumentBlock
+	found := false
+	for _, b := range doc.Blocks {
+		if b.ID == blockID {
+			if b.Checked != isCompleted {
+				b.Checked = isCompleted
+				found = true
+			}
+		}
+		updatedBlocks = append(updatedBlocks, b)
+	}
+	if found {
+		_, _ = s.UpdateDocument(userID, docID, nil, nil, nil, &updatedBlocks, nil, nil)
+	}
+}
+
+func (s *Store) UnlinkTaskFromDocBlock(userID, taskID string) {
+	t, err := s.GetThoughtByID(userID, taskID)
+	if err != nil || t == nil {
+		return
+	}
+	docID := t.DocID
+	blockID := t.BlockID
+	if (docID == "" || blockID == "") && strings.Contains(t.ConvertedRefID, ":") {
+		parts := strings.SplitN(t.ConvertedRefID, ":", 2)
+		docID, blockID = parts[0], parts[1]
+	}
+	if docID != "" {
+		if doc, err := s.GetDocumentByID(userID, docID); err == nil && doc != nil {
+			var updatedBlocks []domain.DocumentBlock
+			found := false
+			for _, b := range doc.Blocks {
+				if b.ID == blockID || b.TaskID == taskID {
+					b.TaskID = ""
+					found = true
+				}
+				updatedBlocks = append(updatedBlocks, b)
+			}
+			if found {
+				_, _ = s.UpdateDocument(userID, docID, nil, nil, nil, &updatedBlocks, nil, nil)
+			}
+		}
+	}
+	_, _ = s.db.Exec(`UPDATE thoughts SET converted_type = '', converted_ref_id = '', doc_id = '', block_id = '' WHERE id = ?`, taskID)
+}
+
+func (s *Store) SyncTaskFromBlockCheck(userID, taskID string, checked bool) {
+	if taskID == "" {
+		return
+	}
+	doneInt := 0
+	kanban := "todo"
+	if checked {
+		doneInt = 1
+		kanban = "done"
+	}
+	_, _ = s.db.Exec(`UPDATE thoughts SET is_completed = ?, kanban_status = ? WHERE id = ? AND user_id = ?`, doneInt, kanban, taskID, userID)
+}
+
 func (s *Store) DeleteListItem(itemID string) (string, error) {
 	var listID string
 	_ = s.db.QueryRow(`SELECT list_id FROM list_items WHERE id = ?`, itemID).Scan(&listID)
@@ -4314,12 +4598,73 @@ func (s *Store) CreateTaskList(userID, spaceID, teamID, title, icon, color strin
 		return nil, err
 	}
 	if teamID != "" {
-		_, _ = s.AddTaskListShare(tl.ID, "team", teamID, userID)
+		_, _ = s.AddTaskListShare(tl.ID, "team", teamID, "editor", userID)
 	}
 	return s.GetTaskListByID(userID, tl.ID)
 }
 
-func (s *Store) AddTaskListShare(taskListID, targetType, targetID, createdBy string) (*domain.TaskListShare, error) {
+// ErrTaskListReadOnly is returned when a user with viewer permission tries to modify a task list or its tasks.
+var ErrTaskListReadOnly = errors.New("Keine Schreibrechte für diese Aufgabenliste (nur Lesen)")
+
+// GetTaskListPermission returns "owner", "editor", "viewer" or "" (no access) for the given user.
+func (s *Store) GetTaskListPermission(userID, listID string) string {
+	var ownerID, teamID string
+	if err := s.db.QueryRow(`SELECT user_id, COALESCE(team_id, '') FROM task_lists WHERE id = ?`, listID).Scan(&ownerID, &teamID); err != nil {
+		return ""
+	}
+	if ownerID == userID {
+		return "owner"
+	}
+	rows, err := s.db.Query(
+		`SELECT permission FROM task_list_shares
+		 WHERE task_list_id = ? AND (
+		    (target_type = 'user' AND target_id = ?)
+		    OR (target_type = 'team' AND target_id IN (SELECT team_id FROM team_members WHERE user_id = ?))
+		 )`,
+		listID, userID, userID,
+	)
+	perm := ""
+	if err == nil {
+		for rows.Next() {
+			var p string
+			if rows.Scan(&p) == nil {
+				if p == "viewer" {
+					if perm == "" {
+						perm = "viewer"
+					}
+				} else {
+					perm = "editor"
+				}
+			}
+		}
+		_ = rows.Close()
+	}
+	if perm == "" && teamID != "" {
+		// Legacy team assignment without a share row grants edit access
+		var isMember, hasShareRow int
+		_ = s.db.QueryRow(`SELECT COUNT(*) FROM team_members WHERE team_id = ? AND user_id = ?`, teamID, userID).Scan(&isMember)
+		_ = s.db.QueryRow(`SELECT COUNT(*) FROM task_list_shares WHERE task_list_id = ? AND target_type = 'team' AND target_id = ?`, listID, teamID).Scan(&hasShareRow)
+		if isMember > 0 && hasShareRow == 0 {
+			perm = "editor"
+		}
+	}
+	return perm
+}
+
+func (s *Store) CanEditTaskList(userID, listID string) bool {
+	p := s.GetTaskListPermission(userID, listID)
+	return p == "owner" || p == "editor"
+}
+
+// ensureTaskListWritable returns ErrTaskListReadOnly if the list is set and the user may not modify it.
+func (s *Store) ensureTaskListWritable(userID, listID string) error {
+	if listID == "" || s.CanEditTaskList(userID, listID) {
+		return nil
+	}
+	return ErrTaskListReadOnly
+}
+
+func (s *Store) AddTaskListShare(taskListID, targetType, targetID, permission, createdBy string) (*domain.TaskListShare, error) {
 	if targetType != "team" && targetType != "user" {
 		return nil, errors.New("ungültiger Freigabetyp")
 	}
@@ -4327,19 +4672,23 @@ func (s *Store) AddTaskListShare(taskListID, targetType, targetID, createdBy str
 	if targetID == "" {
 		return nil, errors.New("Ziel-ID erforderlich")
 	}
+	if permission != "viewer" {
+		permission = "editor"
+	}
 	now := domain.NowISO()
 	share := &domain.TaskListShare{
 		ID:         domain.NewID("tls"),
 		TaskListID: taskListID,
 		TargetType: targetType,
 		TargetID:   targetID,
+		Permission: permission,
 		CreatedAt:  now,
 	}
 	_, err := s.db.Exec(
-		`INSERT INTO task_list_shares (id, task_list_id, target_type, target_id, created_at, created_by)
-		 VALUES (?, ?, ?, ?, ?, ?)
-		 ON CONFLICT(task_list_id, target_type, target_id) DO UPDATE SET created_at = excluded.created_at`,
-		share.ID, share.TaskListID, share.TargetType, share.TargetID, share.CreatedAt, createdBy,
+		`INSERT INTO task_list_shares (id, task_list_id, target_type, target_id, permission, created_at, created_by)
+		 VALUES (?, ?, ?, ?, ?, ?, ?)
+		 ON CONFLICT(task_list_id, target_type, target_id) DO UPDATE SET created_at = excluded.created_at, permission = excluded.permission`,
+		share.ID, share.TaskListID, share.TargetType, share.TargetID, share.Permission, share.CreatedAt, createdBy,
 	)
 	if err != nil {
 		return nil, err
@@ -4372,7 +4721,7 @@ func (s *Store) RemoveTaskListShare(taskListID, shareIDOrTargetID string) error
 
 func (s *Store) GetTaskListShares(taskListID string) ([]domain.TaskListShare, error) {
 	rows, err := s.db.Query(
-		`SELECT id, task_list_id, target_type, target_id, created_at
+		`SELECT id, task_list_id, target_type, target_id, permission, created_at
 		 FROM task_list_shares WHERE task_list_id = ? ORDER BY created_at ASC`,
 		taskListID,
 	)
@@ -4384,7 +4733,7 @@ func (s *Store) GetTaskListShares(taskListID string) ([]domain.TaskListShare, er
 	shares := make([]domain.TaskListShare, 0)
 	for rows.Next() {
 		var sh domain.TaskListShare
-		if err := rows.Scan(&sh.ID, &sh.TaskListID, &sh.TargetType, &sh.TargetID, &sh.CreatedAt); err == nil {
+		if err := rows.Scan(&sh.ID, &sh.TaskListID, &sh.TargetType, &sh.TargetID, &sh.Permission, &sh.CreatedAt); err == nil {
 			shares = append(shares, sh)
 		}
 	}
@@ -4519,6 +4868,7 @@ func (s *Store) GetTaskLists(userID string) ([]domain.TaskList, error) {
 
 		shares, _ := s.GetTaskListShares(list[i].ID)
 		list[i].Shares = shares
+		list[i].Permission = s.GetTaskListPermission(userID, list[i].ID)
 		list[i].Members = s.getMembersForTaskList(&list[i])
 	}
 	return list, nil
@@ -4561,6 +4911,7 @@ func (s *Store) GetTaskListByID(userID, listID string) (*domain.TaskList, error)
 	}
 	shares, _ := s.GetTaskListShares(tl.ID)
 	tl.Shares = shares
+	tl.Permission = s.GetTaskListPermission(userID, tl.ID)
 	tl.Members = s.getMembersForTaskList(&tl)
 	return &tl, nil
 }
@@ -4570,6 +4921,9 @@ func (s *Store) UpdateTaskList(userID, listID string, title, icon, color, teamID
 	if err != nil {
 		return nil, err
 	}
+	if tl.Permission == "viewer" {
+		return nil, ErrTaskListReadOnly
+	}
 	if title != nil {
 		tl.Title = strings.TrimSpace(*title)
 	}
@@ -4591,8 +4945,8 @@ func (s *Store) UpdateTaskList(userID, listID string, title, icon, color, teamID
 		if oldTeamID != "" && oldTeamID != *teamID {
 			_ = s.RemoveTaskListShare(listID, oldTeamID)
 		}
-		if *teamID != "" {
-			_, _ = s.AddTaskListShare(listID, "team", *teamID, userID)
+		if *teamID != "" && *teamID != oldTeamID {
+			_, _ = s.AddTaskListShare(listID, "team", *teamID, "editor", userID)
 		}
 	}
 	tl.UpdatedAt = domain.NowISO()

internal/storage/sqlite_test.go

@@ -1,6 +1,7 @@
 package storage
 
 import (
+	"errors"
 	"path/filepath"
 	"testing"
 
@@ -118,7 +119,7 @@ func TestStoreLifecycle(t *testing.T) {
 	}
 
 	// Test TaskList Sharing with Team
-	shareTeam, err := store.AddTaskListShare(taskList.ID, "team", team.ID, user.ID)
+	shareTeam, err := store.AddTaskListShare(taskList.ID, "team", team.ID, "editor", user.ID)
 	if err != nil || shareTeam.ID == "" {
 		t.Fatalf("AddTaskListShare team failed: %v", err)
 	}
@@ -147,6 +148,45 @@ func TestStoreLifecycle(t *testing.T) {
 	if err != nil {
 		t.Fatalf("CreateUser collab failed: %v", err)
 	}
+
+	// Test read-only TaskList share
+	ownerTask, err := store.CreateThoughtWithDetails(user.ID, "Rasen mähen", "normal", "manual", "", taskList.ID, "todo", "")
+	if err != nil {
+		t.Fatalf("CreateThoughtWithDetails in own list failed: %v", err)
+	}
+	if _, err := store.UpdateThoughtTriage(user.ID, ownerTask.ID, "keep", "task", "", "", taskList.ID); err != nil {
+		t.Fatalf("UpdateThoughtTriage in own list failed: %v", err)
+	}
+	if _, err := store.AddTaskListShare(taskList.ID, "user", user2.ID, "viewer", user.ID); err != nil {
+		t.Fatalf("AddTaskListShare viewer failed: %v", err)
+	}
+	if perm := store.GetTaskListPermission(user2.ID, taskList.ID); perm != "viewer" {
+		t.Fatalf("expected viewer permission, got %q", perm)
+	}
+	viewerTasks, err := store.GetTasks(user2.ID, taskList.ID)
+	if err != nil || len(viewerTasks) == 0 {
+		t.Fatalf("viewer should see tasks of shared list: %v", err)
+	}
+	done := true
+	if _, err := store.UpdateThoughtDetails(user2.ID, ownerTask.ID, nil, &done, nil, nil, nil, nil, nil, nil, nil); !errors.Is(err, ErrTaskListReadOnly) {
+		t.Fatalf("viewer must not update tasks, got %v", err)
+	}
+	if _, err := store.CreateThoughtWithDetails(user2.ID, "Hack", "normal", "manual", "", taskList.ID, "todo", ""); !errors.Is(err, ErrTaskListReadOnly) {
+		t.Fatalf("viewer must not create tasks, got %v", err)
+	}
+	if err := store.DeleteThought(user2.ID, ownerTask.ID); !errors.Is(err, ErrTaskListReadOnly) {
+		t.Fatalf("viewer must not delete tasks, got %v", err)
+	}
+	newTitle := "Umbenannt"
+	if _, err := store.UpdateTaskList(user2.ID, taskList.ID, &newTitle, nil, nil, nil, nil, nil); !errors.Is(err, ErrTaskListReadOnly) {
+		t.Fatalf("viewer must not update task list, got %v", err)
+	}
+	if _, err := store.AddTaskListShare(taskList.ID, "user", user2.ID, "editor", user.ID); err != nil {
+		t.Fatalf("upgrading share to editor failed: %v", err)
+	}
+	if !store.CanEditTaskList(user2.ID, taskList.ID) {
+		t.Fatalf("editor share should allow editing")
+	}
 	newDoc, err := store.CreateDocument(user.ID, "", "Test Note", "📄", "", []domain.DocumentBlock{
 		{ID: "blk_1", Type: "bullet", Content: "Geheim", Level: 0},
 	}, []string{"test"}, false)
@@ -173,16 +213,10 @@ func TestStoreLifecycle(t *testing.T) {
 		t.Fatalf("expected UpdateDocument to fail for read-only user, but succeeded")
 	}
 
-	// Upgrade to write permission
-	_, err = store.CreateDocShare(user.ID, newDoc.ID, user2.ID, "write")
-	if err != nil {
-		t.Fatalf("Upgrade CreateDocShare failed: %v", err)
-	}
-
-	// user2 edits writeable doc -> must succeed
+	// user2 is a read-only collaborator -> editing must fail
 	_, err = store.UpdateDocument(user2.ID, newDoc.ID, &updatedTitle, nil, nil, nil, nil, nil)
-	if err != nil {
-		t.Fatalf("UpdateDocument failed for write collaborator: %v", err)
+	if err == nil {
+		t.Fatalf("expected UpdateDocument to fail for read-only collaborator, but succeeded")
 	}
 
 	// Remove share
@@ -551,8 +585,7 @@ func TestDatabaseFirstWorkspaceArchitecture(t *testing.T) {
 		t.Fatalf("MoveDocument by userB failed: %v", err)
 	}
 
-	// User B edits the document via PatchDocumentBlocks (modifying b2 and adding b3)
-	// Simultaneously, User A edits b1 and adds b4 using a slightly stale order
+	// User B is a read-only collaborator -> PatchDocumentBlocks must fail
 	_, _, err = store.PatchDocumentBlocks(userB.ID, doc.ID, domain.DocBlocksPatchRequest{
 		Upserted: []domain.DocumentBlock{
 			{ID: "b2", Type: "bullet", Content: "Zeile 2 von B bearbeitet", Level: 0},
@@ -560,8 +593,8 @@ func TestDatabaseFirstWorkspaceArchitecture(t *testing.T) {
 		},
 		BlockOrder: []string{"b1", "b2", "b3"},
 	})
-	if err != nil {
-		t.Fatalf("PatchDocumentBlocks by userB failed: %v", err)
+	if err == nil {
+		t.Fatalf("expected PatchDocumentBlocks by read-only userB to fail, but succeeded")
 	}
 
 	// User A's client only knew about b1, b2 when sending its patch (adds b4)
@@ -576,9 +609,9 @@ func TestDatabaseFirstWorkspaceArchitecture(t *testing.T) {
 		t.Fatalf("PatchDocumentBlocks by userA failed: %v", err)
 	}
 
-	// Verify NO blocks were lost! All 4 blocks (b1, b2, b3, b4) must exist with both users' edits preserved
-	if len(patchedDocA.Blocks) != 4 {
-		t.Fatalf("expected 4 blocks after concurrent patches, got %d: %+v", len(patchedDocA.Blocks), patchedDocA.Blocks)
+	// Verify User A's blocks are preserved: b1, b2, b4 (3 blocks)
+	if len(patchedDocA.Blocks) != 3 {
+		t.Fatalf("expected 3 blocks after patch, got %d: %+v", len(patchedDocA.Blocks), patchedDocA.Blocks)
 	}
 	blockContent := make(map[string]string)
 	for _, b := range patchedDocA.Blocks {
@@ -587,12 +620,6 @@ func TestDatabaseFirstWorkspaceArchitecture(t *testing.T) {
 	if blockContent["b1"] != "Zeile 1 von A bearbeitet" {
 		t.Fatalf("expected b1 updated by A, got %q", blockContent["b1"])
 	}
-	if blockContent["b2"] != "Zeile 2 von B bearbeitet" {
-		t.Fatalf("expected b2 updated by B to be preserved, got %q", blockContent["b2"])
-	}
-	if blockContent["b3"] != "Zeile 3 neu von B" {
-		t.Fatalf("expected b3 added by B to be preserved even with stale order from A, got %q", blockContent["b3"])
-	}
 	if blockContent["b4"] != "Zeile 4 neu von A" {
 		t.Fatalf("expected b4 added by A, got %q", blockContent["b4"])
 	}

internal/ws/docroom.go

@@ -1,736 +0,0 @@
-package ws
-
-import (
-	"encoding/json"
-	"log/slog"
-	"net/http"
-	"sync"
-	"time"
-
-	"github.com/gorilla/websocket"
-	"github.com/sandrodach/mindsift/internal/domain"
-)
-
-// CursorPresence represents an active user's ephemeral cursor position in a document room.
-type CursorPresence struct {
-	ClientID       string `json:"clientId"`
-	UserID         string `json:"userId"`
-	UserName       string `json:"userName"`
-	UserColor      string `json:"userColor"`
-	BlockID        string `json:"blockId,omitempty"`
-	SelectionStart *int   `json:"selectionStart,omitempty"`
-	SelectionEnd   *int   `json:"selectionEnd,omitempty"`
-	UpdatedAt      int64  `json:"updatedAt"`
-}
-
-// DocWSClient represents an active WebSocket connection to a specific document room.
-type DocWSClient struct {
-	hub      *Hub
-	room     *DocRoom
-	conn     *websocket.Conn
-	userID   string
-	clientID string
-	canWrite bool
-	send     chan []byte
-}
-
-// DocSyncEvent is the lightweight JSON payload exchanged over /api/v1/ws/docs/{id}.
-type DocSyncEvent struct {
-	Type           string                 `json:"type"`
-	DocID          string                 `json:"docId,omitempty"`
-	ClientID       string                 `json:"clientId,omitempty"`
-	UserID         string                 `json:"userId,omitempty"`
-	UserName       string                 `json:"userName,omitempty"`
-	UserColor      string                 `json:"userColor,omitempty"`
-	SelectionStart *int                   `json:"selectionStart,omitempty"`
-	SelectionEnd   *int                   `json:"selectionEnd,omitempty"`
-	ActiveCursors  []CursorPresence       `json:"activeCursors,omitempty"`
-	Title          string                 `json:"title,omitempty"`
-	Block          *domain.DocumentBlock  `json:"block,omitempty"`
-	BlockID        string                 `json:"blockId,omitempty"`
-	AfterBlockID   string                 `json:"afterBlockId,omitempty"`
-	NewIndex       *int                   `json:"newIndex,omitempty"`
-	Content        *string                `json:"content,omitempty"`
-	Level          *int                   `json:"level,omitempty"`
-	Checked        *bool                  `json:"checked,omitempty"`
-	Collapsed      *bool                  `json:"collapsed,omitempty"`
-	BlockType      *string                `json:"blockType,omitempty"`
-	Blocks         []domain.DocumentBlock `json:"blocks,omitempty"`
-}
-
-// DocRoom coordinates in-memory real-time block state and 1.5s debounced SQLite persistence for one document.
-type DocRoom struct {
-	mu            sync.Mutex
-	docID         string
-	hub           *Hub
-	title         string
-	blocks        []domain.DocumentBlock
-	loaded        bool
-	wsClients     map[*DocWSClient]bool
-	activeCursors map[string]*CursorPresence
-	debounceTimer *time.Timer
-	dirty         bool
-}
-
-// GetOrCreateDocRoom returns the active in-memory room for docID or initializes one from SQLite.
-func (h *Hub) GetOrCreateDocRoom(docID string) *DocRoom {
-	h.mu.Lock()
-	if h.docRooms == nil {
-		h.docRooms = make(map[string]*DocRoom)
-	}
-	room, exists := h.docRooms[docID]
-	if !exists {
-		room = &DocRoom{
-			docID:         docID,
-			hub:           h,
-			wsClients:     make(map[*DocWSClient]bool),
-			activeCursors: make(map[string]*CursorPresence),
-		}
-		h.docRooms[docID] = room
-	}
-	store := h.docStore
-	h.mu.Unlock()
-
-	room.mu.Lock()
-	if !room.loaded && store != nil {
-		title, blocks, err := store.LoadDocumentState(docID)
-		if err == nil {
-			room.title = title
-			room.blocks = normalizeRoomBlocks(docID, blocks)
-			room.loaded = true
-		}
-	}
-	room.mu.Unlock()
-
-	return room
-}
-
-// GetActiveDocState returns the live in-memory title and blocks if an active DocRoom exists in RAM.
-func (h *Hub) GetActiveDocState(docID string) (string, []domain.DocumentBlock, bool) {
-	h.mu.RLock()
-	room, exists := h.docRooms[docID]
-	h.mu.RUnlock()
-	if !exists || room == nil {
-		return "", nil, false
-	}
-
-	room.mu.Lock()
-	defer room.mu.Unlock()
-	if !room.loaded {
-		return "", nil, false
-	}
-	blocksCopy := make([]domain.DocumentBlock, len(room.blocks))
-	copy(blocksCopy, room.blocks)
-	return room.title, blocksCopy, true
-}
-
-// SyncActiveDocRoom updates an in-memory room if one is currently loaded (e.g. after REST PUT/PATCH).
-func (h *Hub) SyncActiveDocRoom(docID string, title string, blocks []domain.DocumentBlock) {
-	h.mu.RLock()
-	room, exists := h.docRooms[docID]
-	h.mu.RUnlock()
-	if !exists || room == nil {
-		return
-	}
-
-	room.mu.Lock()
-	if title != "" {
-		room.title = title
-	}
-	if blocks != nil {
-		room.blocks = normalizeRoomBlocks(docID, blocks)
-	}
-	room.loaded = true
-	room.mu.Unlock()
-}
-
-// CloseDocRoom removes a document room from memory when a document is deleted.
-func (h *Hub) CloseDocRoom(docID string) {
-	h.mu.Lock()
-	room, exists := h.docRooms[docID]
-	if exists {
-		delete(h.docRooms, docID)
-	}
-	h.mu.Unlock()
-
-	if exists && room != nil {
-		room.mu.Lock()
-		if room.debounceTimer != nil {
-			room.debounceTimer.Stop()
-		}
-		room.dirty = false
-		for c := range room.wsClients {
-			_ = c.conn.Close()
-		}
-		room.wsClients = make(map[*DocWSClient]bool)
-		room.mu.Unlock()
-	}
-}
-
-func normalizeRoomBlocks(docID string, blocks []domain.DocumentBlock) []domain.DocumentBlock {
-	if len(blocks) == 0 {
-		return []domain.DocumentBlock{
-			{
-				ID:         docID + "-b0",
-				DocumentID: docID,
-				Type:       "text",
-				Content:    "",
-				Level:      0,
-				Position:   1000,
-			},
-		}
-	}
-	out := make([]domain.DocumentBlock, len(blocks))
-	for i, b := range blocks {
-		if b.ID == "" {
-			b.ID = domain.NewID("blk")
-		}
-		b.DocumentID = docID
-		if b.Type == "" {
-			b.Type = "text"
-		}
-		if b.Level < 0 {
-			b.Level = 0
-		}
-		b.Position = float64((i + 1) * 1000)
-		out[i] = b
-	}
-	return out
-}
-
-// GetStateSnapshot returns a copy of the room's current live in-memory title and blocks.
-func (r *DocRoom) GetStateSnapshot() (string, []domain.DocumentBlock) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	blocksCopy := make([]domain.DocumentBlock, len(r.blocks))
-	copy(blocksCopy, r.blocks)
-	return r.title, blocksCopy
-}
-
-// HandleEvent applies a granular block or title mutation to the in-memory room,
-// broadcasts it to all OTHER clients in the room (excluding senderClientID for echo protection),
-// and resets the 1.5-second inactivity debounce timer for SQLite persistence.
-func (r *DocRoom) HandleEvent(evt DocSyncEvent, sender *DocWSClient) {
-	r.mu.Lock()
-
-	evt.DocID = r.docID
-	if sender != nil {
-		if evt.ClientID == "" {
-			evt.ClientID = sender.clientID
-		}
-		evt.UserID = sender.userID
-	}
-
-	mutated := false
-
-	switch evt.Type {
-	case "cursor_moved":
-		if evt.ClientID != "" {
-			cp := &CursorPresence{
-				ClientID:       evt.ClientID,
-				UserID:         evt.UserID,
-				UserName:       evt.UserName,
-				UserColor:      evt.UserColor,
-				BlockID:        evt.BlockID,
-				SelectionStart: evt.SelectionStart,
-				SelectionEnd:   evt.SelectionEnd,
-				UpdatedAt:      time.Now().UnixMilli(),
-			}
-			if r.activeCursors == nil {
-				r.activeCursors = make(map[string]*CursorPresence)
-			}
-			r.activeCursors[evt.ClientID] = cp
-
-			msgBytes, err := json.Marshal(evt)
-			if err == nil {
-				for client := range r.wsClients {
-					if sender != nil && (client == sender || (sender.clientID != "" && client.clientID == sender.clientID)) {
-						continue
-					}
-					if evt.ClientID != "" && client.clientID == evt.ClientID {
-						continue
-					}
-					select {
-					case client.send <- msgBytes:
-					default:
-					}
-				}
-			}
-		}
-		r.mu.Unlock()
-		return
-
-	case "title_updated":
-		if evt.Title != "" || r.title != evt.Title {
-			r.title = evt.Title
-			mutated = true
-		}
-
-	case "block_created":
-		if evt.Block != nil {
-			newBlock := *evt.Block
-			if newBlock.ID == "" {
-				newBlock.ID = domain.NewID("blk")
-			}
-			newBlock.DocumentID = r.docID
-			if newBlock.Type == "" {
-				newBlock.Type = "text"
-			}
-			if newBlock.Level < 0 {
-				newBlock.Level = 0
-			}
-
-			// Avoid duplicate ID if already created
-			existsIdx := -1
-			for i, b := range r.blocks {
-				if b.ID == newBlock.ID {
-					existsIdx = i
-					break
-				}
-			}
-
-			if existsIdx >= 0 {
-				r.blocks[existsIdx] = newBlock
-			} else {
-				insertIdx := len(r.blocks)
-				if evt.AfterBlockID != "" {
-					for i, b := range r.blocks {
-						if b.ID == evt.AfterBlockID {
-							insertIdx = i + 1
-							break
-						}
-					}
-				} else if evt.NewIndex != nil && *evt.NewIndex >= 0 && *evt.NewIndex <= len(r.blocks) {
-					insertIdx = *evt.NewIndex
-				}
-
-				updated := make([]domain.DocumentBlock, 0, len(r.blocks)+1)
-				updated = append(updated, r.blocks[:insertIdx]...)
-				updated = append(updated, newBlock)
-				updated = append(updated, r.blocks[insertIdx:]...)
-				r.blocks = normalizeRoomBlocks(r.docID, updated)
-			}
-			evt.Block = &newBlock
-			mutated = true
-		}
-
-	case "block_updated":
-		targetID := evt.BlockID
-		if targetID == "" && evt.Block != nil {
-			targetID = evt.Block.ID
-		}
-		if targetID != "" {
-			found := false
-			for i := range r.blocks {
-				if r.blocks[i].ID == targetID {
-					found = true
-					if evt.Block != nil {
-						r.blocks[i].Content = evt.Block.Content
-						r.blocks[i].Level = evt.Block.Level
-						if evt.Block.Type != "" {
-							r.blocks[i].Type = evt.Block.Type
-						}
-						r.blocks[i].Checked = evt.Block.Checked
-						r.blocks[i].Collapsed = evt.Block.Collapsed
-						r.blocks[i].Lang = evt.Block.Lang
-					} else {
-						if evt.Content != nil {
-							r.blocks[i].Content = *evt.Content
-						}
-						if evt.Level != nil {
-							lvl := *evt.Level
-							if lvl < 0 {
-								lvl = 0
-							}
-							r.blocks[i].Level = lvl
-						}
-						if evt.Checked != nil {
-							r.blocks[i].Checked = *evt.Checked
-						}
-						if evt.Collapsed != nil {
-							r.blocks[i].Collapsed = *evt.Collapsed
-						}
-						if evt.BlockType != nil && *evt.BlockType != "" {
-							r.blocks[i].Type = *evt.BlockType
-						}
-					}
-					bCopy := r.blocks[i]
-					evt.Block = &bCopy
-					evt.BlockID = targetID
-					mutated = true
-					break
-				}
-			}
-			if !found && evt.Block != nil {
-				newBlock := *evt.Block
-				newBlock.DocumentID = r.docID
-				if newBlock.Type == "" {
-					newBlock.Type = "text"
-				}
-				if newBlock.Level < 0 {
-					newBlock.Level = 0
-				}
-				r.blocks = append(r.blocks, newBlock)
-				r.blocks = normalizeRoomBlocks(r.docID, r.blocks)
-				bCopy := newBlock
-				evt.Block = &bCopy
-				evt.BlockID = targetID
-				mutated = true
-			}
-		}
-
-	case "block_deleted":
-		if evt.BlockID != "" {
-			filtered := make([]domain.DocumentBlock, 0, len(r.blocks))
-			for _, b := range r.blocks {
-				if b.ID != evt.BlockID {
-					filtered = append(filtered, b)
-				}
-			}
-			r.blocks = normalizeRoomBlocks(r.docID, filtered)
-			mutated = true
-		}
-
-	case "block_moved":
-		if evt.BlockID != "" && evt.NewIndex != nil {
-			fromIdx := -1
-			for i, b := range r.blocks {
-				if b.ID == evt.BlockID {
-					fromIdx = i
-					break
-				}
-			}
-			if fromIdx >= 0 {
-				moving := r.blocks[fromIdx]
-				if evt.Level != nil {
-					lvl := *evt.Level
-					if lvl < 0 {
-						lvl = 0
-					}
-					moving.Level = lvl
-				}
-				without := make([]domain.DocumentBlock, 0, len(r.blocks)-1)
-				without = append(without, r.blocks[:fromIdx]...)
-				without = append(without, r.blocks[fromIdx+1:]...)
-
-				toIdx := *evt.NewIndex
-				if toIdx < 0 {
-					toIdx = 0
-				}
-				if toIdx > len(without) {
-					toIdx = len(without)
-				}
-
-				reordered := make([]domain.DocumentBlock, 0, len(r.blocks))
-				reordered = append(reordered, without[:toIdx]...)
-				reordered = append(reordered, moving)
-				reordered = append(reordered, without[toIdx:]...)
-				r.blocks = normalizeRoomBlocks(r.docID, reordered)
-				mutated = true
-			}
-		}
-
-	case "blocks_replaced":
-		if evt.Blocks != nil {
-			r.blocks = normalizeRoomBlocks(r.docID, evt.Blocks)
-			evt.Blocks = r.blocks
-			mutated = true
-		}
-	}
-
-	if !mutated {
-		r.mu.Unlock()
-		return
-	}
-
-	r.dirty = true
-	r.loaded = true
-
-	msgBytes, err := json.Marshal(evt)
-	if err == nil {
-		for client := range r.wsClients {
-			// Strict Echo Protection: never send back to the originating connection or clientId
-			if sender != nil && (client == sender || (sender.clientID != "" && client.clientID == sender.clientID)) {
-				continue
-			}
-			if evt.ClientID != "" && client.clientID == evt.ClientID {
-				continue
-			}
-			select {
-			case client.send <- msgBytes:
-			default:
-				slog.Warn("Doc room WS client send buffer full, dropping message",
-					"doc_id", r.docID,
-					"client_id", client.clientID,
-					"user_id", client.userID,
-				)
-			}
-		}
-	}
-
-	r.scheduleDebouncedFlushLocked()
-	r.mu.Unlock()
-}
-
-func (r *DocRoom) scheduleDebouncedFlushLocked() {
-	if r.debounceTimer != nil {
-		r.debounceTimer.Stop()
-	}
-	r.debounceTimer = time.AfterFunc(1500*time.Millisecond, func() {
-		r.Flush()
-	})
-}
-
-// Flush persists the current in-memory document state (blocks, #tags in block_tags, and markdown_cache) to SQLite.
-func (r *DocRoom) Flush() {
-	r.mu.Lock()
-	if !r.dirty {
-		r.mu.Unlock()
-		return
-	}
-	if r.debounceTimer != nil {
-		r.debounceTimer.Stop()
-		r.debounceTimer = nil
-	}
-
-	docID := r.docID
-	title := r.title
-	blocksCopy := make([]domain.DocumentBlock, len(r.blocks))
-	copy(blocksCopy, r.blocks)
-	r.dirty = false
-	r.mu.Unlock()
-
-	tagsCount := 0
-	for _, b := range blocksCopy {
-		tagsCount += len(domain.ExtractTags(b.Content))
-	}
-
-	start := time.Now()
-	r.hub.mu.RLock()
-	store := r.hub.docStore
-	r.hub.mu.RUnlock()
-
-	if store != nil {
-		if err := store.FlushDocumentState(docID, title, blocksCopy); err != nil {
-			slog.Error("SQLite document flush failed",
-				"doc_id", docID,
-				"error", err,
-			)
-		} else {
-			durationMs := float64(time.Since(start).Microseconds()) / 1000.0
-			slog.Debug("SQLite document flushed",
-				"doc_id", docID,
-				"blocks_count", len(blocksCopy),
-				"tags_count", tagsCount,
-				"duration_ms", durationMs,
-			)
-		}
-	}
-}
-
-// ServeDocWS handles WebSocket connections for GET /api/v1/ws/docs/{id}
-func (r *DocRoom) ServeDocWS(w http.ResponseWriter, req *http.Request, userID string, clientID string, canWrite bool) {
-	conn, err := upgrader.Upgrade(w, req, nil)
-	if err != nil {
-		slog.Error("WebSocket upgrade error", "doc_id", r.docID, "error", err)
-		return
-	}
-
-	if clientID == "" {
-		clientID = req.URL.Query().Get("clientId")
-	}
-	if clientID == "" {
-		clientID = domain.NewID("cli")
-	}
-
-	userName := req.URL.Query().Get("userName")
-	userColor := req.URL.Query().Get("userColor")
-
-	client := &DocWSClient{
-		hub:      r.hub,
-		room:     r,
-		conn:     conn,
-		userID:   userID,
-		clientID: clientID,
-		canWrite: canWrite,
-		send:     make(chan []byte, 256),
-	}
-
-	r.mu.Lock()
-	r.wsClients[client] = true
-	activeClients := len(r.wsClients)
-	if r.activeCursors == nil {
-		r.activeCursors = make(map[string]*CursorPresence)
-	}
-	if userName != "" {
-		r.activeCursors[clientID] = &CursorPresence{
-			ClientID:  clientID,
-			UserID:    userID,
-			UserName:  userName,
-			UserColor: userColor,
-			UpdatedAt: time.Now().UnixMilli(),
-		}
-	}
-	title := r.title
-	blocksCopy := make([]domain.DocumentBlock, len(r.blocks))
-	copy(blocksCopy, r.blocks)
-
-	activeList := make([]CursorPresence, 0, len(r.activeCursors))
-	for _, cp := range r.activeCursors {
-		if cp != nil {
-			activeList = append(activeList, *cp)
-		}
-	}
-	r.mu.Unlock()
-
-	slog.Debug("WS client joined doc room",
-		"doc_id", r.docID,
-		"client_id", clientID,
-		"user_id", userID,
-		"active_clients", activeClients,
-	)
-
-	// Immediately send live in-memory state and current cursors to the newly connected client
-	initEvt := DocSyncEvent{
-		Type:          "doc_state",
-		DocID:         r.docID,
-		ClientID:      clientID,
-		Title:         title,
-		Blocks:        blocksCopy,
-		ActiveCursors: activeList,
-	}
-	if initBytes, err := json.Marshal(initEvt); err == nil {
-		client.send <- initBytes
-	}
-
-	// If userName was provided, broadcast initial presence to existing clients in room
-	if userName != "" {
-		joinEvt := DocSyncEvent{
-			Type:      "cursor_moved",
-			DocID:     r.docID,
-			ClientID:  clientID,
-			UserID:    userID,
-			UserName:  userName,
-			UserColor: userColor,
-		}
-		if joinBytes, err := json.Marshal(joinEvt); err == nil {
-			r.mu.Lock()
-			for c := range r.wsClients {
-				if c != client && c.clientID != clientID {
-					select {
-					case c.send <- joinBytes:
-					default:
-					}
-				}
-			}
-			r.mu.Unlock()
-		}
-	}
-
-	go client.writePump()
-	go client.readPump()
-}
-
-func (c *DocWSClient) readPump() {
-	defer func() {
-		c.room.mu.Lock()
-		delete(c.room.wsClients, c)
-		delete(c.room.activeCursors, c.clientID)
-		remaining := len(c.room.wsClients)
-
-		// Broadcast client_left to all remaining clients in room
-		leftEvt := DocSyncEvent{
-			Type:     "client_left",
-			DocID:    c.room.docID,
-			ClientID: c.clientID,
-			UserID:   c.userID,
-		}
-		if leftBytes, err := json.Marshal(leftEvt); err == nil {
-			for client := range c.room.wsClients {
-				if client != c && client.clientID != c.clientID {
-					select {
-					case client.send <- leftBytes:
-					default:
-					}
-				}
-			}
-		}
-		c.room.mu.Unlock()
-
-		slog.Debug("WS client left doc room",
-			"doc_id", c.room.docID,
-			"client_id", c.clientID,
-			"user_id", c.userID,
-			"active_clients", remaining,
-		)
-
-		_ = c.conn.Close()
-
-		// Flush immediately when the last client leaves the document room
-		if remaining == 0 {
-			c.room.Flush()
-		}
-	}()
-
-	c.conn.SetReadLimit(4 * 1024 * 1024)
-	_ = c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-	c.conn.SetPongHandler(func(string) error {
-		_ = c.conn.SetReadDeadline(time.Now().Add(60 * time.Second))
-		return nil
-	})
-
-	for {
-		_, message, err := c.conn.ReadMessage()
-		if err != nil {
-			break
-		}
-
-		var evt DocSyncEvent
-		if err := json.Unmarshal(message, &evt); err == nil && evt.Type != "" {
-			targetBlockID := evt.BlockID
-			if targetBlockID == "" && evt.Block != nil {
-				targetBlockID = evt.Block.ID
-			}
-
-			slog.Debug("WS doc event received",
-				"type", evt.Type,
-				"doc_id", c.room.docID,
-				"block_id", targetBlockID,
-				"sender_client_id", c.clientID,
-			)
-
-			// Read-only clients can still move their cursor and send presence updates
-			if !c.canWrite && evt.Type != "cursor_moved" {
-				continue
-			}
-			c.room.HandleEvent(evt, c)
-		}
-	}
-}
-
-func (c *DocWSClient) writePump() {
-	ticker := time.NewTicker(25 * time.Second)
-	defer func() {
-		ticker.Stop()
-		_ = c.conn.Close()
-	}()
-
-	for {
-		select {
-		case message, ok := <-c.send:
-			_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
-			if !ok {
-				_ = c.conn.WriteMessage(websocket.CloseMessage, []byte{})
-				return
-			}
-			if err := c.conn.WriteMessage(websocket.TextMessage, message); err != nil {
-				return
-			}
-		case <-ticker.C:
-			_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
-			if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
-				return
-			}
-		}
-	}
-}

internal/ws/docroom_test.go

@@ -1,85 +0,0 @@
-package ws
-
-import (
-	"testing"
-	"time"
-)
-
-func TestDocRoomCursorPresenceAndEchoProtection(t *testing.T) {
-	hub := NewHub()
-	room := hub.GetOrCreateDocRoom("doc_test_presence")
-
-	c1 := &DocWSClient{
-		hub:      hub,
-		room:     room,
-		userID:   "user_1",
-		clientID: "cli_1",
-		canWrite: true,
-		send:     make(chan []byte, 10),
-	}
-	c2 := &DocWSClient{
-		hub:      hub,
-		room:     room,
-		userID:   "user_2",
-		clientID: "cli_2",
-		canWrite: false, // read-only viewer
-		send:     make(chan []byte, 10),
-	}
-
-	room.mu.Lock()
-	room.wsClients[c1] = true
-	room.wsClients[c2] = true
-	room.mu.Unlock()
-
-	// 1. Send cursor_moved from c1
-	selStart := 5
-	selEnd := 5
-	room.HandleEvent(DocSyncEvent{
-		Type:           "cursor_moved",
-		DocID:          "doc_test_presence",
-		ClientID:       "cli_1",
-		UserID:         "user_1",
-		UserName:       "Alice",
-		UserColor:      "#3b82f6",
-		BlockID:        "blk_123",
-		SelectionStart: &selStart,
-		SelectionEnd:   &selEnd,
-	}, c1)
-
-	// c1 should NOT have received its own echo
-	select {
-	case <-c1.send:
-		t.Fatal("c1 received echo of its own cursor_moved event!")
-	default:
-	}
-
-	// c2 SHOULD receive the event
-	select {
-	case msg := <-c2.send:
-		if len(msg) == 0 {
-			t.Fatal("empty message received by c2")
-		}
-	case <-time.After(500 * time.Millisecond):
-		t.Fatal("timed out waiting for cursor_moved event on c2")
-	}
-
-	// Room should have registered c1's presence
-	room.mu.Lock()
-	cp, exists := room.activeCursors["cli_1"]
-	room.mu.Unlock()
-
-	if !exists || cp == nil {
-		t.Fatal("expected active cursor for cli_1 in room")
-	}
-	if cp.UserName != "Alice" || cp.BlockID != "blk_123" {
-		t.Fatalf("unexpected cursor data: %+v", cp)
-	}
-
-	// Ephemeral cursor events must NOT mark the room dirty for disk flush
-	room.mu.Lock()
-	dirty := room.dirty
-	room.mu.Unlock()
-	if dirty {
-		t.Fatal("cursor_moved should not mark room dirty")
-	}
-}

internal/ws/hub.go

@@ -28,6 +28,29 @@ type Client struct {
 	userID          string
 	send            chan []byte
 	subscribedRooms map[string]bool
+	sendMu          sync.RWMutex
+	closed          bool
+}
+
+func (c *Client) closeSend() {
+	c.sendMu.Lock()
+	defer c.sendMu.Unlock()
+	if !c.closed {
+		c.closed = true
+		close(c.send)
+	}
+}
+
+func (c *Client) trySend(data []byte) {
+	c.sendMu.RLock()
+	defer c.sendMu.RUnlock()
+	if c.closed {
+		return
+	}
+	select {
+	case c.send <- data:
+	default:
+	}
 }
 
 type SSEClient struct {
@@ -36,19 +59,29 @@ type SSEClient struct {
 	roomID          string
 	send            chan []byte
 	subscribedRooms map[string]bool
+	sendMu          sync.RWMutex
+	closed          bool
 }
 
-type docLockItem struct {
-	docID     string
-	userID    string
-	userName  string
-	lockedAt  time.Time
-	expiresAt time.Time
+func (c *SSEClient) closeSend() {
+	c.sendMu.Lock()
+	defer c.sendMu.Unlock()
+	if !c.closed {
+		c.closed = true
+		close(c.send)
+	}
 }
 
-type DocStore interface {
-	LoadDocumentState(docID string) (string, []domain.DocumentBlock, error)
-	FlushDocumentState(docID string, title string, blocks []domain.DocumentBlock) error
+func (c *SSEClient) trySend(data []byte) {
+	c.sendMu.RLock()
+	defer c.sendMu.RUnlock()
+	if c.closed {
+		return
+	}
+	select {
+	case c.send <- data:
+	default:
+	}
 }
 
 type Hub struct {
@@ -59,30 +92,18 @@ type Hub struct {
 	sseClients   map[*SSEClient]bool
 	sseUserRooms map[string]map[*SSEClient]bool
 	sseRooms     map[string]map[*SSEClient]bool
-	locks        map[string]*docLockItem
-	docRooms     map[string]*DocRoom
-	docStore     DocStore
+	closed       bool
 }
 
 func NewHub() *Hub {
-	h := &Hub{
+	return &Hub{
 		rooms:        make(map[string]map[*Client]bool),
 		userRooms:    make(map[string]map[*Client]bool),
 		allClients:   make(map[*Client]bool),
 		sseClients:   make(map[*SSEClient]bool),
 		sseUserRooms: make(map[string]map[*SSEClient]bool),
 		sseRooms:     make(map[string]map[*SSEClient]bool),
-		locks:        make(map[string]*docLockItem),
-		docRooms:     make(map[string]*DocRoom),
 	}
-	go h.cleanupLocksLoop()
-	return h
-}
-
-func (h *Hub) SetDocStore(store DocStore) {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	h.docStore = store
 }
 
 func (h *Hub) Register(c *Client) {
@@ -122,7 +143,6 @@ func (h *Hub) Unregister(c *Client) {
 		}
 	}
 
-	var docRoomsLeft []string
 	if c.subscribedRooms != nil {
 		for rID := range c.subscribedRooms {
 			if room, ok := h.rooms[rID]; ok {
@@ -131,52 +151,19 @@ func (h *Hub) Unregister(c *Client) {
 					delete(h.rooms, rID)
 				}
 			}
-			if strings.HasPrefix(rID, "doc:") {
-				docRoomsLeft = append(docRoomsLeft, strings.TrimPrefix(rID, "doc:"))
-			}
 		}
 	}
 
-	userRemaining := 0
 	if c.userID != "" && c.userID != "anonymous" {
 		if uRoom, ok := h.userRooms[c.userID]; ok {
 			delete(uRoom, c)
-			userRemaining += len(uRoom)
 			if len(uRoom) == 0 {
 				delete(h.userRooms, c.userID)
 			}
 		}
-		if sseRoom, ok := h.sseUserRooms[c.userID]; ok {
-			userRemaining += len(sseRoom)
-		}
-	}
-	close(c.send)
-
-	// If this user has no other active client connections, release their document locks
-	var releasedDocIDs []string
-	if userRemaining == 0 && c.userID != "" {
-		now := time.Now()
-		for docID, l := range h.locks {
-			if l.userID == c.userID || l.expiresAt.Before(now) {
-				releasedDocIDs = append(releasedDocIDs, docID)
-				delete(h.locks, docID)
-			}
-		}
 	}
+	c.closeSend()
 	h.mu.Unlock()
-
-	// Broadcast unlock events for released locks
-	for _, docID := range releasedDocIDs {
-		h.BroadcastToAll("DOC_UNLOCKED", map[string]string{"docId": docID, "doc_id": docID})
-	}
-
-	// Broadcast awareness leave for doc rooms
-	for _, docID := range docRoomsLeft {
-		h.BroadcastRoom("doc:"+docID, "CRDT_AWARENESS_LEAVE", map[string]interface{}{
-			"docId":  docID,
-			"userId": c.userID,
-		}, nil)
-	}
 }
 
 func (h *Hub) RegisterSSE(c *SSEClient) {
@@ -223,7 +210,6 @@ func (h *Hub) UnregisterSSE(c *SSEClient) {
 			}
 		}
 	}
-	var docRoomsLeft []string
 	if c.subscribedRooms != nil {
 		for rID := range c.subscribedRooms {
 			if room, ok := h.sseRooms[rID]; ok {
@@ -232,48 +218,18 @@ func (h *Hub) UnregisterSSE(c *SSEClient) {
 					delete(h.sseRooms, rID)
 				}
 			}
-			if strings.HasPrefix(rID, "doc:") {
-				docRoomsLeft = append(docRoomsLeft, strings.TrimPrefix(rID, "doc:"))
-			}
 		}
 	}
-	userRemaining := 0
 	if c.userID != "" && c.userID != "anonymous" {
 		if uRoom, ok := h.sseUserRooms[c.userID]; ok {
 			delete(uRoom, c)
-			userRemaining += len(uRoom)
 			if len(uRoom) == 0 {
 				delete(h.sseUserRooms, c.userID)
 			}
 		}
-		if wsRoom, ok := h.userRooms[c.userID]; ok {
-			userRemaining += len(wsRoom)
-		}
-	}
-	close(c.send)
-
-	var releasedDocIDs []string
-	if userRemaining == 0 && c.userID != "" {
-		now := time.Now()
-		for docID, l := range h.locks {
-			if l.userID == c.userID || l.expiresAt.Before(now) {
-				releasedDocIDs = append(releasedDocIDs, docID)
-				delete(h.locks, docID)
-			}
-		}
 	}
+	c.closeSend()
 	h.mu.Unlock()
-
-	for _, docID := range releasedDocIDs {
-		h.BroadcastToAll("DOC_UNLOCKED", map[string]string{"docId": docID, "doc_id": docID})
-	}
-
-	for _, docID := range docRoomsLeft {
-		h.BroadcastRoom("doc:"+docID, "CRDT_AWARENESS_LEAVE", map[string]interface{}{
-			"docId":  docID,
-			"userId": c.userID,
-		}, nil)
-	}
 }
 
 func (h *Hub) JoinSSERoomByID(sseID, roomID string) bool {
@@ -315,120 +271,35 @@ func (h *Hub) LeaveSSERoomByID(sseID, roomID string) bool {
 	return false
 }
 
-// Document Locking Methods
 
-func (h *Hub) AcquireDocLock(docID, userID, userName string, ttl time.Duration) (*domain.DocLockInfo, bool, *domain.DocLockInfo) {
+
+// Close gracefully disconnects all WebSocket and SSE connections so HTTP shutdown completes immediately.
+func (h *Hub) Close() {
 	h.mu.Lock()
-	defer h.mu.Unlock()
-
-	now := time.Now()
-	existing, exists := h.locks[docID]
-	if exists && existing.expiresAt.After(now) {
-		if existing.userID != userID {
-			// Locked by another user
-			info := &domain.DocLockInfo{
-				DocID:     existing.docID,
-				UserID:    existing.userID,
-				UserName:  existing.userName,
-				ExpiresAt: existing.expiresAt.Format(time.RFC3339),
-			}
-			return nil, false, info
-		}
-		// Same user extending lock
-		existing.expiresAt = now.Add(ttl)
-		if userName != "" {
-			existing.userName = userName
-		}
-		info := &domain.DocLockInfo{
-			DocID:     existing.docID,
-			UserID:    existing.userID,
-			UserName:  existing.userName,
-			ExpiresAt: existing.expiresAt.Format(time.RFC3339),
-		}
-		return info, true, nil
-	}
-
-	// Create fresh lock
-	item := &docLockItem{
-		docID:     docID,
-		userID:    userID,
-		userName:  userName,
-		lockedAt:  now,
-		expiresAt: now.Add(ttl),
-	}
-	h.locks[docID] = item
-	info := &domain.DocLockInfo{
-		DocID:     item.docID,
-		UserID:    item.userID,
-		UserName:  item.userName,
-		ExpiresAt: item.expiresAt.Format(time.RFC3339),
-	}
-	return info, true, nil
-}
-
-func (h *Hub) HeartbeatDocLock(docID, userID string, ttl time.Duration) bool {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-
-	now := time.Now()
-	item, ok := h.locks[docID]
-	if !ok || item.userID != userID || item.expiresAt.Before(now) {
-		return false
-	}
-	item.expiresAt = now.Add(ttl)
-	return true
-}
-
-func (h *Hub) ReleaseDocLock(docID, userID string, isAdmin bool) bool {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-
-	item, ok := h.locks[docID]
-	if !ok {
-		return false
-	}
-	if item.userID == userID || isAdmin || userID == "admin" {
-		delete(h.locks, docID)
-		return true
-	}
-	return false
-}
-
-func (h *Hub) GetDocLock(docID string) *domain.DocLockInfo {
-	h.mu.RLock()
-	defer h.mu.RUnlock()
-
-	item, ok := h.locks[docID]
-	if !ok || item.expiresAt.Before(time.Now()) {
-		return nil
-	}
-	return &domain.DocLockInfo{
-		DocID:     item.docID,
-		UserID:    item.userID,
-		UserName:  item.userName,
-		ExpiresAt: item.expiresAt.Format(time.RFC3339),
-	}
-}
-
-func (h *Hub) cleanupLocksLoop() {
-	ticker := time.NewTicker(2 * time.Second)
-	defer ticker.Stop()
-
-	for range ticker.C {
-		h.mu.Lock()
-		now := time.Now()
-		var expiredDocIDs []string
-		for docID, l := range h.locks {
-			if l.expiresAt.Before(now) {
-				expiredDocIDs = append(expiredDocIDs, docID)
-				delete(h.locks, docID)
-			}
-		}
+	if h.closed {
 		h.mu.Unlock()
+		return
+	}
+	h.closed = true
 
-		for _, docID := range expiredDocIDs {
-			h.BroadcastToAll("DOC_UNLOCKED", map[string]string{"docId": docID, "doc_id": docID})
-		}
+	allWsClients := make([]*Client, 0, len(h.allClients))
+	for c := range h.allClients {
+		allWsClients = append(allWsClients, c)
+	}
+
+	allSSEClients := make([]*SSEClient, 0, len(h.sseClients))
+	for c := range h.sseClients {
+		allSSEClients = append(allSSEClients, c)
+	}
+	h.mu.Unlock()
+
+	for _, c := range allWsClients {
+		_ = c.conn.Close()
+		c.closeSend()
+	}
+
+	for _, c := range allSSEClients {
+		c.closeSend()
 	}
 }
 
@@ -446,19 +317,17 @@ func (h *Hub) BroadcastToAll(event string, payload interface{}) {
 	}
 
 	h.mu.RLock()
+	if h.closed {
+		h.mu.RUnlock()
+		return
+	}
 	defer h.mu.RUnlock()
 
 	for client := range h.allClients {
-		select {
-		case client.send <- data:
-		default:
-		}
+		client.trySend(data)
 	}
 	for sseClient := range h.sseClients {
-		select {
-		case sseClient.send <- data:
-		default:
-		}
+		sseClient.trySend(data)
 	}
 }
 
@@ -474,22 +343,20 @@ func (h *Hub) BroadcastToUser(userID, event string, payload interface{}) {
 	}
 
 	h.mu.RLock()
+	if h.closed {
+		h.mu.RUnlock()
+		return
+	}
 	defer h.mu.RUnlock()
 
 	if room, ok := h.userRooms[userID]; ok {
 		for client := range room {
-			select {
-			case client.send <- data:
-			default:
-			}
+			client.trySend(data)
 		}
 	}
 	if sseRoom, ok := h.sseUserRooms[userID]; ok {
 		for sseClient := range sseRoom {
-			select {
-			case sseClient.send <- data:
-			default:
-			}
+			sseClient.trySend(data)
 		}
 	}
 }
@@ -519,6 +386,10 @@ func (h *Hub) Broadcast(spaceID, listID, event string, payload interface{}) {
 	}
 
 	h.mu.RLock()
+	if h.closed {
+		h.mu.RUnlock()
+		return
+	}
 	defer h.mu.RUnlock()
 
 	targetRoom := listID
@@ -528,19 +399,12 @@ func (h *Hub) Broadcast(spaceID, listID, event string, payload interface{}) {
 
 	if room, ok := h.rooms[targetRoom]; ok {
 		for client := range room {
-			select {
-			case client.send <- data:
-			default:
-				// Slow client buffer full
-			}
+			client.trySend(data)
 		}
 	}
 	if sseRoom, ok := h.sseRooms[targetRoom]; ok {
 		for sseClient := range sseRoom {
-			select {
-			case sseClient.send <- data:
-			default:
-			}
+			sseClient.trySend(data)
 		}
 	}
 }
@@ -588,6 +452,10 @@ func (h *Hub) BroadcastRoom(roomID, event string, payload interface{}, excludeCl
 	}
 
 	h.mu.RLock()
+	if h.closed {
+		h.mu.RUnlock()
+		return
+	}
 	defer h.mu.RUnlock()
 
 	if room, ok := h.rooms[roomID]; ok {
@@ -595,18 +463,12 @@ func (h *Hub) BroadcastRoom(roomID, event string, payload interface{}, excludeCl
 			if excludeClient != nil && client == excludeClient {
 				continue
 			}
-			select {
-			case client.send <- data:
-			default:
-			}
+			client.trySend(data)
 		}
 	}
 	if sseRoom, ok := h.sseRooms[roomID]; ok {
 		for sseClient := range sseRoom {
-			select {
-			case sseClient.send <- data:
-			default:
-			}
+			sseClient.trySend(data)
 		}
 	}
 }
@@ -619,10 +481,7 @@ func (c *Client) SendEvent(event string, payload interface{}) {
 	}
 	data, err := json.Marshal(msg)
 	if err == nil {
-		select {
-		case c.send <- data:
-		default:
-		}
+		c.trySend(data)
 	}
 }
 
@@ -767,21 +626,6 @@ func (c *Client) readPump() {
 					c.hub.LeaveRoom(c, room)
 				}
 			}
-
-			if docID != "" {
-				switch incoming.Event {
-				case "LOCK_DOC":
-					if info, ok, _ := c.hub.AcquireDocLock(docID, c.userID, "", 30*time.Second); ok && info != nil {
-						c.hub.BroadcastDocEvent(docID, "DOC_LOCKED", info)
-					}
-				case "HEARTBEAT_DOC":
-					c.hub.HeartbeatDocLock(docID, c.userID, 30*time.Second)
-				case "UNLOCK_DOC":
-					if c.hub.ReleaseDocLock(docID, c.userID, false) {
-						c.hub.BroadcastDocEvent(docID, "DOC_UNLOCKED", map[string]string{"docId": docID, "doc_id": docID})
-					}
-				}
-			}
 		}
 	}
 }

internal/ws/hub_test.go

@@ -0,0 +1,58 @@
+package ws
+
+import (
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestHubCloseAndGracefulShutdown(t *testing.T) {
+	hub := NewHub()
+
+	// Register multiple dummy SSE clients
+	var sseClients []*SSEClient
+	for i := 0; i < 5; i++ {
+		client := &SSEClient{
+			id:     "sse-test",
+			userID: "user-1",
+			send:   make(chan []byte, 10),
+		}
+		hub.RegisterSSE(client)
+		sseClients = append(sseClients, client)
+	}
+
+	// Verify broadcast works
+	hub.BroadcastToAll("TEST_EVENT", map[string]string{"msg": "hello"})
+
+	// Concurrently invoke Close() and Broadcast() to verify no panics or deadlocks
+	var wg sync.WaitGroup
+	wg.Add(2)
+
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 50; i++ {
+			hub.BroadcastToAll("SPAM", map[string]int{"i": i})
+			time.Sleep(1 * time.Millisecond)
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+		time.Sleep(5 * time.Millisecond)
+		hub.Close()
+	}()
+
+	wg.Wait()
+
+	// Verify that all SSE client channels are closed
+	for _, c := range sseClients {
+		select {
+		case _, ok := <-c.send:
+			if ok {
+				// Drained a message, check next
+				_, ok = <-c.send
+			}
+		default:
+		}
+	}
+}