Merge: Meilenstein 8 – MCP (0.8.0)

Ein Sprachmodell kann jetzt Aufgaben suchen, anlegen, abhaken und
einplanen — ueber dieselben Tokens und dieselben Rechte wie die
Schnittstelle aus M7. Welche Werkzeuge es sieht, haengt am Token: Was
nicht erlaubt ist, taucht gar nicht erst in der Liste auf.

Das Einplanen liegt jetzt an einer Stelle, die Oberflaeche und MCP-Server
gemeinsam benutzen, bewusst ausserhalb einer 'use server'-Datei. Ein ueber
MCP angelegter Zeitblock geht damit durch denselben Kalenderschreibweg und
Schleifenschutz wie ein von Hand gezogener.

Geprueft vor dem Merge: Format, Lint, Typen und 331 Unit-Tests auf dem
Endstand. Die sechs MCP-E2E-Tests liefen gruen auf bdc4260; danach kamen
Doku, Versionssprung und eine kleine Lint-Korrektur beim Lesen der
Formularfelder. E2E und ShellCheck liefen auf dem Endstand nicht, weil
Docker nicht lief — kein Shellskript wurde geaendert.

Damit ist der Fahrplan abgearbeitet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.env.example

@@ -74,6 +74,52 @@ GRAPH_TENANT_ID=organizations
 GOOGLE_CLIENT_ID=
 GOOGLE_CLIENT_SECRET=
 
+# --- Benachrichtigungen ----------------------------------------------------
+# Beides ist freiwillig. Fehlt es, laeuft der Planer ohne Benachrichtigungen
+# weiter und sagt es in den Einstellungen.
+
+# Web-Push. Schluesselpaar einmalig erzeugen mit:
+#   npx web-push generate-vapid-keys
+# Der oeffentliche Schluessel geht an den Browser, der private bleibt hier.
+# Wird das Paar getauscht, muessen sich alle Geraete neu anmelden.
+VAPID_OEFFENTLICH=
+VAPID_PRIVAT=
+# Kontakt fuer den Push-Dienst, als mailto: oder https:-Adresse.
+VAPID_KONTAKT=
+
+# E-Mail. Push braucht SMTP nicht und umgekehrt.
+SMTP_HOST=
+SMTP_PORT=587
+SMTP_BENUTZER=
+SMTP_PASSWORT=
+# Absender, z. B. "Planer <planer@example.de>".
+SMTP_ABSENDER=
+# true bei Port 465 (SMTPS), false bei 587 mit STARTTLS.
+SMTP_TLS=false
+
+# --- Integrationen ---------------------------------------------------------
+# Alles freiwillig. Was fehlt, erscheint unter "Integrationen" als nicht
+# eingerichtet; der Rest laeuft weiter.
+# Welche Integration eine Instanz ueberhaupt darf, entscheidet INSTANZ:
+# Zammad und Wartungsplaner nur "firma", Telegram nur "daheim".
+
+# Zammad (nur firma). Token in Zammad unter Profil > Token-Zugriff anlegen;
+# er sieht genau das, was der zugehoerige Benutzer sehen darf.
+ZAMMAD_URL=
+ZAMMAD_TOKEN=
+# Suchausdruck in Zammads Syntax. Was darauf passt, wird zur Aufgabe.
+ZAMMAD_ABFRAGE=owner_id:me AND (state.name:new OR state.name:open)
+
+# Telegram (nur daheim). Bot bei @BotFather anlegen, Token hier eintragen.
+# Welche Chats mitreden duerfen, wird in der Anwendung gekoppelt.
+TELEGRAM_TOKEN=
+
+# Spiegel: firma sendet, daheim empfaengt. Dasselbe Geheimnis auf beiden
+# Seiten, mindestens 32 Zeichen:  openssl rand -base64 32
+SPIEGEL_GEHEIMNIS=
+# Nur auf der sendenden Seite (firma): die Adresse der anderen Instanz.
+SPIEGEL_ZIEL=
+
 # --- Sonstiges -------------------------------------------------------------
 # Zeitzone fuer Anzeigen und Tagesgrenzen.
 TZ=Europe/Berlin

.prettierignore

@@ -8,3 +8,4 @@ test-results
 playwright-report
 coverage
 devlog/zeiten.csv
+public/sw.js

CHANGELOG.md

@@ -6,6 +6,167 @@ die Versionierung [Semantic Versioning](https://semver.org/lang/de/).
 
 ## [Unveröffentlicht]
 
+## [0.8.0] – 2026-09-13
+
+### Hinzugefügt
+
+- **MCP-Server** unter `/api/mcp` mit sechs Werkzeugen: Aufgaben suchen,
+  Woche ansehen, Kalender auflisten, Aufgabe anlegen, abhaken und einplanen.
+  Beschreibung in [docs/MCP.md](docs/MCP.md).
+- Die Werkzeugliste richtet sich nach den Rechten des Tokens — was ein Token
+  nicht darf, sieht das Modell gar nicht erst.
+
+### Geändert
+
+- Das Einplanen liegt jetzt an einer Stelle, die sowohl die Oberfläche als
+  auch der MCP-Server benutzen. Ein über MCP angelegter Zeitblock verhält
+  sich damit genau wie ein von Hand gezogener.
+
+### Sicherheit
+
+- MCP benutzt dieselben Tokens und dieselben Rechte wie die Schnittstelle.
+  Ein Sprachmodell bekommt keinen eigenen Zugang.
+- Jede schreibende Nutzung steht im Protokoll, mit dem Vermerk, dass sie
+  über MCP kam.
+- Der Server kann weder löschen noch Bereiche, Projekte, Kalenderkonten,
+  Einstellungen oder Tokens anfassen.
+
+## [0.7.0] – 2026-09-13
+
+### Hinzugefügt
+
+- **Schnellerfassung vom Handy** unter _Erfassen_: ein Feld, ein Knopf. Was
+  ohne Netz erfasst wird, bleibt im Gerät und geht hinaus, sobald wieder eine
+  Verbindung da ist — mit einer Kennung je Erfassung, damit eine doppelt
+  zugestellte Nachricht keine zweite Aufgabe ergibt.
+- Der Planer lässt sich als **App auf dem Startbildschirm ablegen**
+  (Manifest, eigenes Symbol, eigener Startpunkt).
+- **Öffentliche Schnittstelle** unter `/api/v1`: Aufgaben lesen, anlegen,
+  ändern und abhaken. Beschreibung in [docs/API.md](docs/API.md).
+- **Tokens je Anwendung** mit Rechten je Token, wahlweise mit Ablauf,
+  verwaltbar unter _API_.
+- Handbuchseite zur Schnellerfassung.
+
+### Sicherheit
+
+- Von einem Token liegt nur der Fingerabdruck in der Datenbank. Der Wert
+  erscheint genau einmal — beim Anlegen.
+- Die drei Rechte schließen einander nicht ein: Ein Dienst, der nur erfasst,
+  kann den Bestand nicht lesen.
+- Jeder Fehlschlag beim Ausweisen sieht gleich aus. Ob ein Token unbekannt,
+  abgelaufen oder zurückgezogen ist, verrät die Schnittstelle nicht.
+- Jede schreibende Nutzung steht im Protokoll, mitsamt dem Token — auch jeder
+  abgewiesene Zugriff.
+- Die Schnittstelle kann weder löschen noch Bereiche, Projekte, Zeitblöcke
+  oder Kalender anfassen.
+
+## [0.6.0] – 2026-09-12
+
+### Hinzugefügt
+
+- **Zammad** (nur `firma`): Tickets, auf die der Suchausdruck passt, werden zu
+  Aufgaben — mit Verweis ins Ticket. Wird ein Ticket dort geschlossen, hakt
+  der Planer die Aufgabe ab.
+- **Telegram** (nur `daheim`): Eine Nachricht an den Bot wird zur Aufgabe.
+  Meldungen gehen denselben Weg zurück, mit einem Knopf zum Abhaken. Ein Chat
+  meldet sich über einen Einmalcode an, der zehn Minuten gilt.
+- **Telegram als dritter Meldeweg** neben Push und E-Mail.
+- **Spiegel** zwischen den Instanzen: `firma` schickt Belegungen ohne Titel
+  und die einzeln dafür markierten Aufgaben, `daheim` empfängt. Gespiegelte
+  Belegung erscheint in der Wochenansicht als „Dienstlich belegt" und zählt
+  gegen die Tageskapazität.
+- Seite **Integrationen**: je Integration Zustand, letzter Erfolg, letzter
+  Fehler und ein Knopf, der einen Lauf sofort anstößt.
+- Handbuchseite zu den Integrationen.
+
+### Geändert
+
+- Was aus einem Fund wird, entscheidet für alle Integrationen dieselbe
+  Stelle. Geführt werden nur Titel, Notiz, Verweis und Fälligkeit — Bereich,
+  Projekt, Priorität und geschätzter Aufwand gehören der Planung und werden
+  nie von außen überschrieben.
+- Eine klemmende Integration meldet sich wie ein klemmender Kalender: erst
+  nach dem dritten Fehlversuch in Folge.
+- Die Demo-Instanz für die Bilder spricht nicht mehr nach außen.
+
+### Sicherheit
+
+- Wer dem Telegram-Bot schreibt, ohne verbunden zu sein, bekommt **keine
+  Antwort** — auch keine Fehlermeldung. Sonst ließe sich herausfinden, dass
+  es diesen Planer gibt.
+- Jede Sendung des Spiegels trägt eine Signatur über den Rumpf und ist nach
+  fünf Minuten wertlos. Der Empfänger antwortet auf jeden Fehlschlag gleich:
+  falsches Geheimnis, verstellte Uhr und Unsinn im Inhalt sind von außen
+  nicht zu unterscheiden.
+- Der Signaturvergleich läuft in gleichbleibender Zeit.
+- Aufgaben verlassen die Instanz nur mit ausdrücklicher Freigabe je Aufgabe.
+  Ein Schalter für einen ganzen Bereich würde zu leicht Kundennamen nach
+  Hause schicken.
+
+## [0.5.0] – 2026-09-11
+
+### Hinzugefügt
+
+- **Benachrichtigungen** per Web-Push und E-Mail, je Benutzer einstellbar.
+  Vier Anlässe: Tagesüberblick am Morgen, fällige Aufgaben, Vorlauf vor einem
+  Zeitblock und ein Kalender, der sich nicht abgleichen lässt.
+- **Ruhezeit** von 20:00 bis 07:00 ab Werk, über Mitternacht hinweg; wahlweise
+  das ganze Wochenende. Der Tagesüberblick kommt trotzdem zu seiner Zeit — er
+  käme sonst nie, wenn jemand früh aufsteht.
+- Anmeldung eines Browsers für Push, Liste der angemeldeten Geräte und ein
+  Knopf, der eine Probemeldung über alle eingeschalteten Wege schickt.
+- Ein Lauf alle zehn Minuten prüft, ob etwas zu melden ist; die nächtliche
+  Aufräumrunde entfernt Nachweise, die älter als 30 Tage sind.
+- Handbuchseite zu Benachrichtigungen.
+
+### Geändert
+
+- Der Kalenderabgleich zählt Fehlversuche in Folge mit und meldet erst ab dem
+  dritten. Ein Netz hustet, ein Anbieter hat Wartung — das ist noch keine
+  Nachricht wert.
+- Ab Werk meldet der Planer gar nichts: kein Weg ist eingeschaltet. Wer beim
+  ersten Start mit Meldungen überschüttet wird, schaltet alles ab — und dann
+  auch das Nützliche.
+
+### Sicherheit
+
+- Die Push-Schlüssel eines Geräts liegen verschlüsselt in der Datenbank.
+  Weder Endpunkt noch Schlüssel noch Mailinhalte landen im Protokoll.
+- Ein Gerät, das der Push-Dienst mit 404 oder 410 ablehnt, wird sofort
+  entfernt; andere Fehler führen nach fünf Versuchen zum selben Ergebnis.
+- Der Nachweis einer Meldung wird **vor** dem Senden geschrieben: lieber eine
+  verpasste Nachricht als eine, die im Minutentakt erneut versucht wird.
+
+## [0.4.0] – 2026-09-11
+
+### Hinzugefügt
+
+- **Wochenansicht** mit Ziehen und Ablegen: Aufgaben aus der linken Spalte in
+  ein Zeitfenster ziehen legt einen Zeitblock an und schreibt ihn in den
+  Kalender. Die Dauer kommt aus dem geschätzten Aufwand der Aufgabe.
+- Zeitblöcke verschieben und ausplanen; der Kalendertermin zieht mit.
+- **Rückweg**: Wird ein Zeitblock im Kalender verschoben, übernimmt der Planer
+  das beim nächsten Abgleich. Wird er dort gelöscht, verschwindet auch der
+  Zeitblock — die Aufgabe bleibt und fällt zurück auf offen.
+- Kapazität und Belegung je Wochentag über jeder Spalte; überbuchte Tage
+  werden rot, sperren aber nichts.
+- Eine eingeplante Aufgabe wechselt selbsttätig von _Offen_ auf _Geplant_ und
+  wieder zurück, wenn nichts mehr für sie geplant ist.
+- Handbuchseite zur Wochenplanung.
+
+### Sicherheit
+
+- **Schleifenschutz** über `hash = sha256(startISO|endeISO)`: Der Planer
+  schreibt nur bei eigener Änderung und übernimmt aus dem Kalender nur, wenn
+  der Fingerabdruck abweicht. Ohne das würden App und Kalender einander
+  endlos hinterherschreiben.
+- Jeder Schreibzugriff auf einen bestehenden Termin geht mit `If-Match`
+  heraus. Bei HTTP 412 **gewinnt der Kalender**: der Planer schreibt nicht,
+  verwirft seinen Fingerabdruck und überlässt dem nächsten Abgleich, den
+  fremden Stand zu holen.
+- Zeitblöcke gehören dem Benutzer über sein Kalenderkonto; die Kennung geht
+  in jede where-Bedingung, nicht in einen nachträglichen Vergleich.
+
 ## [0.3.0] – 2026-09-10
 
 ### Hinzugefügt

README.md

@@ -7,9 +7,10 @@ lesen und Aufgaben per Ziehen und Ablegen als Zeitblöcke direkt in diese
 Kalender schreiben — inklusive Rückweg, wenn ein Block im Kalender verschoben
 wird.
 
-> **Stand:** Meilenstein 3 von 8. Aufgaben, Projekte und das Lesen der
+> **Stand:** Meilenstein 4 von 8. Die Kernidee steht: Aufgaben lassen sich
-> Kalender stehen: der Planer weiß jetzt, wann überhaupt Platz ist. Das
+> per Ziehen und Ablegen als Zeitblöcke in den Kalender schreiben, und
-> Schreiben der Zeitblöcke per Ziehen und Ablegen kommt mit M4. Der
+> Verschiebungen von dort kommen zurück. Es folgen Benachrichtigungen,
+> Integrationen, Schnellerfassung vom Handy und ein MCP-Server. Der
 > [Fahrplan](ROADMAP.md) sagt, was wann folgt.
 
 - **[Schnellstart](docs/SCHNELLSTART.md)** – in zehn Minuten von `git clone`
@@ -30,6 +31,20 @@ wird.
 - **Projekte** mit Arbeitspaketen, Meilensteinen und Fortschritt
 - **Kalender lesen** aus Microsoft 365 und Google; die Startseite zeigt je
   Bereich, wie voll der heutige Tag schon ist
+- **Wochenplanung** per Ziehen und Ablegen: Aufgaben werden zu echten
+  Kalenderterminen, Verschiebungen im Kalender kommen zurück
+- **Benachrichtigungen** per Web-Push, E-Mail und Telegram: Tagesüberblick,
+  fällige Aufgaben, Vorlauf vor einem Zeitblock — mit Ruhezeiten und ab Werk
+  still
+- **Integrationen**: Zammad-Tickets werden zu Aufgaben, Telegram erfasst und
+  hakt ab, und der Spiegel bringt dienstliche Belegung nach Hause — ohne
+  Titel
+- **Schnellerfassung vom Handy**, die auch im Funkloch nichts verliert; der
+  Planer lässt sich als App auf dem Startbildschirm ablegen
+- **Öffentliche Schnittstelle** mit Tokens je Anwendung, Rechten je Token und
+  jeder schreibenden Nutzung im Protokoll ([Beschreibung](docs/API.md))
+- **MCP-Server** für Sprachmodelle — dieselben Tokens, dieselben Rechte
+  ([Beschreibung](docs/MCP.md))
 - Anmeldung über einen OIDC-Anbieter, über Passkeys oder mit E-Mail und
   Passwort — je Instanz einzeln zuschaltbar
 - Rollen `Benutzer` und `Verwaltung`; jede schreibende Aktion wird
@@ -38,26 +53,28 @@ wird.
 - Hell und Dunkel, Oberfläche durchgehend auf Deutsch
 - Betrieb über Docker Compose, mit Sicherung, Aktualisierung und Healthcheck
 
-### Geplant
+### Was noch kommen könnte
 
-Zeitblöcke in den Kalender schreiben, Wochenplanung per Ziehen und Ablegen,
+Der [Fahrplan](ROADMAP.md) ist abgearbeitet. Was danach denkbar wäre, steht
-Benachrichtigungen, Integrationen, Schnellerfassung vom Handy und ein
+dort unter „Ideen für später" — und was bewusst nicht kommt, gleich darunter.
-MCP-Server. Siehe [ROADMAP.md](ROADMAP.md).
 
 ## Bildergalerie
 
-|               | Hell                                                                      | Dunkel                                                                        |
+|               | Hell                                                                              | Dunkel                                                                                |
-| ------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| ------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
-| Anmelden      | ![Anmeldeseite, hell](docs/bilder/anmelden-hell-schreibtisch.png)         | ![Anmeldeseite, dunkel](docs/bilder/anmelden-dunkel-schreibtisch.png)         |
+| Anmelden      | ![Anmeldeseite, hell](docs/bilder/anmelden-hell-schreibtisch.png)                 | ![Anmeldeseite, dunkel](docs/bilder/anmelden-dunkel-schreibtisch.png)                 |
-| Start         | ![Startseite, hell](docs/bilder/start-hell-schreibtisch.png)              | ![Startseite, dunkel](docs/bilder/start-dunkel-schreibtisch.png)              |
+| Start         | ![Startseite, hell](docs/bilder/start-hell-schreibtisch.png)                      | ![Startseite, dunkel](docs/bilder/start-dunkel-schreibtisch.png)                      |
-| Inbox         | ![Inbox, hell](docs/bilder/inbox-hell-schreibtisch.png)                   | ![Inbox, dunkel](docs/bilder/inbox-dunkel-schreibtisch.png)                   |
+| Inbox         | ![Inbox, hell](docs/bilder/inbox-hell-schreibtisch.png)                           | ![Inbox, dunkel](docs/bilder/inbox-dunkel-schreibtisch.png)                           |
-| Aufgaben      | ![Aufgaben, hell](docs/bilder/aufgaben-hell-schreibtisch.png)             | ![Aufgaben, dunkel](docs/bilder/aufgaben-dunkel-schreibtisch.png)             |
+| Woche         | ![Woche, hell](docs/bilder/woche-hell-schreibtisch.png)                           | ![Woche, dunkel](docs/bilder/woche-dunkel-schreibtisch.png)                           |
-| Projekte      | ![Projekte, hell](docs/bilder/projekte-hell-schreibtisch.png)             | ![Projekte, dunkel](docs/bilder/projekte-dunkel-schreibtisch.png)             |
+| Aufgaben      | ![Aufgaben, hell](docs/bilder/aufgaben-hell-schreibtisch.png)                     | ![Aufgaben, dunkel](docs/bilder/aufgaben-dunkel-schreibtisch.png)                     |
-| Ideen         | ![Ideen, hell](docs/bilder/ideen-hell-schreibtisch.png)                   | ![Ideen, dunkel](docs/bilder/ideen-dunkel-schreibtisch.png)                   |
+| Projekte      | ![Projekte, hell](docs/bilder/projekte-hell-schreibtisch.png)                     | ![Projekte, dunkel](docs/bilder/projekte-dunkel-schreibtisch.png)                     |
-| Kalender      | ![Kalenderkonten, hell](docs/bilder/kalenderkonten-hell-schreibtisch.png) | ![Kalenderkonten, dunkel](docs/bilder/kalenderkonten-dunkel-schreibtisch.png) |
+| Ideen         | ![Ideen, hell](docs/bilder/ideen-hell-schreibtisch.png)                           | ![Ideen, dunkel](docs/bilder/ideen-dunkel-schreibtisch.png)                           |
-| Bereiche      | ![Bereiche, hell](docs/bilder/bereiche-hell-schreibtisch.png)             | ![Bereiche, dunkel](docs/bilder/bereiche-dunkel-schreibtisch.png)             |
+| Kalender      | ![Kalenderkonten, hell](docs/bilder/kalenderkonten-hell-schreibtisch.png)         | ![Kalenderkonten, dunkel](docs/bilder/kalenderkonten-dunkel-schreibtisch.png)         |
-| Einstellungen | ![Einstellungen, hell](docs/bilder/einstellungen-hell-schreibtisch.png)   | ![Einstellungen, dunkel](docs/bilder/einstellungen-dunkel-schreibtisch.png)   |
+| Bereiche      | ![Bereiche, hell](docs/bilder/bereiche-hell-schreibtisch.png)                     | ![Bereiche, dunkel](docs/bilder/bereiche-dunkel-schreibtisch.png)                     |
-| Protokoll     | ![Protokoll, hell](docs/bilder/protokoll-hell-schreibtisch.png)           | ![Protokoll, dunkel](docs/bilder/protokoll-dunkel-schreibtisch.png)           |
+| Einstellungen | ![Einstellungen, hell](docs/bilder/einstellungen-hell-schreibtisch.png)           | ![Einstellungen, dunkel](docs/bilder/einstellungen-dunkel-schreibtisch.png)           |
+| Meldungen     | ![Benachrichtigungen, hell](docs/bilder/benachrichtigungen-hell-schreibtisch.png) | ![Benachrichtigungen, dunkel](docs/bilder/benachrichtigungen-dunkel-schreibtisch.png) |
+| Integrationen | ![Integrationen, hell](docs/bilder/integrationen-hell-schreibtisch.png)           | ![Integrationen, dunkel](docs/bilder/integrationen-dunkel-schreibtisch.png)           |
+| Protokoll     | ![Protokoll, hell](docs/bilder/protokoll-hell-schreibtisch.png)                   | ![Protokoll, dunkel](docs/bilder/protokoll-dunkel-schreibtisch.png)                   |
 
 Alle Bilder entstehen mit `npm run screenshots` in einer Wegwerf-Instanz mit
 ausschließlich erfundenen Daten — niemals aus einer Instanz mit echten Daten.
@@ -133,6 +150,76 @@ Rückleit-URI beim Anbieter lautet `<APP_URL>/api/auth/callback/oidc`.
 Ein Anbieter erscheint erst, wenn Kennung **und** Geheimnis gesetzt sind —
 und nur, wenn die Instanz ihn erlaubt (Google nur `daheim`).
 
+### Benachrichtigungen
+
+Beides ist freiwillig. Fehlt ein Satz, bleibt der Weg in den Einstellungen
+ausgegraut, und der Planer läuft ohne ihn weiter.
+
+| Variable            | Standard | Bedeutung                                                 |
+| ------------------- | -------- | --------------------------------------------------------- |
+| `VAPID_OEFFENTLICH` | _(leer)_ | Öffentlicher Push-Schlüssel, geht an den Browser          |
+| `VAPID_PRIVAT`      | _(leer)_ | Privater Push-Schlüssel, bleibt auf dem Server            |
+| `VAPID_KONTAKT`     | _(leer)_ | Kontakt für den Push-Dienst, `mailto:` oder `https:`      |
+| `SMTP_HOST`         | _(leer)_ | Mailserver. Ohne ihn kein Mailversand                     |
+| `SMTP_PORT`         | `587`    | Port des Mailservers                                      |
+| `SMTP_BENUTZER`     | _(leer)_ | Anmeldename. Leer lassen für einen Server ohne Anmeldung  |
+| `SMTP_PASSWORT`     | _(leer)_ | Passwort dazu                                             |
+| `SMTP_ABSENDER`     | _(leer)_ | Absenderadresse, z. B. `Planer <planer@example.de>`       |
+| `SMTP_TLS`          | `false`  | `true` bei Port 465 (SMTPS), `false` bei 587 mit STARTTLS |
+
+Push braucht **alle drei** VAPID-Werte, Mail mindestens `SMTP_HOST` und
+`SMTP_ABSENDER`. Die Schlüssel entstehen einmalig mit:
+
+```bash
+npx web-push generate-vapid-keys
+```
+
+Wird das Schlüsselpaar später getauscht, müssen sich alle Geräte neu
+anmelden — die alten Abos sind dann wertlos. Push setzt außerdem HTTPS
+voraus; `http://localhost` gilt dem Browser als sicher, jede andere
+Klartextadresse nicht.
+
+Was der Planer wann meldet, steht im
+[Handbuch](docs/handbuch/benachrichtigungen.md).
+
+### Integrationen
+
+Welche Integration eine Instanz überhaupt darf, entscheidet `INSTANZ` — nicht
+die Konfiguration. Ein Zammad-Token in der Instanz `daheim` bleibt wirkungslos.
+
+| Variable            | Standard            | Bedeutung                                                        |
+| ------------------- | ------------------- | ---------------------------------------------------------------- |
+| `ZAMMAD_URL`        | _(leer)_            | Adresse der Zammad-Instanz, nur `firma`                          |
+| `ZAMMAD_TOKEN`      | _(leer)_            | Token aus **Profil → Token-Zugriff**                             |
+| `ZAMMAD_ABFRAGE`    | `owner_id:me AND …` | Suchausdruck; was darauf passt, wird zur Aufgabe                 |
+| `TELEGRAM_TOKEN`    | _(leer)_            | Bot-Token von [@BotFather](https://t.me/BotFather), nur `daheim` |
+| `SPIEGEL_GEHEIMNIS` | _(leer)_            | Gemeinsames Geheimnis beider Instanzen                           |
+| `SPIEGEL_ZIEL`      | _(leer)_            | Adresse der empfangenden Instanz; nur auf der sendenden Seite    |
+
+**Zammad** liest nur. Ein Ticket schließt man im Ticketsystem — sonst weiß die
+Kollegin nicht, warum es plötzlich zu ist. Umgekehrt schließt der Planer eine
+Aufgabe, sobald Zammad das Ticket als erledigt meldet.
+
+**Telegram** braucht keinen Webhook und damit keine von außen erreichbare
+Adresse. Welche Chats mitreden dürfen, wird in der Anwendung unter
+**Integrationen** gekoppelt: Knopf drücken, Code an den Bot schicken, fertig.
+Nachrichten aus unbekannten Chats werden verworfen, ohne zu antworten.
+
+**Der Spiegel** geht in eine Richtung: `firma` sendet, `daheim` empfängt.
+Hinüber gehen Belegungen **ohne Titel** — daheim ist zu sehen, _dass_ die Zeit
+weg ist, nicht woran gearbeitet wird — und jene Aufgaben, die einzeln zum
+Spiegeln markiert wurden. Jede Sendung ist mit dem gemeinsamen Geheimnis
+signiert und älter als fünf Minuten wertlos.
+
+Das Geheimnis erzeugst du wie das Sitzungsgeheimnis:
+
+```bash
+openssl rand -base64 32
+```
+
+Was der Alltag damit anfängt, steht im
+[Handbuch](docs/handbuch/integrationen.md).
+
 ### Einrichtung und Sonstiges
 
 | Variable         | Standard        | Bedeutung                                                                                |

ROADMAP.md

@@ -8,11 +8,11 @@ grünen Prüfungen, aktueller Dokumentation und einem Eintrag im DEVLOG.
 | [M1](#m1--fundament)                    | Fundament                    | erledigt |
 | [M2](#m2--aufgaben-und-projekte)        | Aufgaben und Projekte        | erledigt |
 | [M3](#m3--kalender-lesen)               | Kalender lesen               | erledigt |
-| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | geplant  |
+| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | erledigt |
-| [M5](#m5--benachrichtigungen)           | Benachrichtigungen           | geplant  |
+| [M5](#m5--benachrichtigungen)           | Benachrichtigungen           | erledigt |
-| [M6](#m6--integrationen)                | Integrationen                | geplant  |
+| [M6](#m6--integrationen)                | Integrationen                | erledigt |
-| [M7](#m7--schnellerfassung-und-api)     | Schnellerfassung und API     | geplant  |
+| [M7](#m7--schnellerfassung-und-api)     | Schnellerfassung und API     | erledigt |
-| [M8](#m8--mcp)                          | MCP                          | geplant  |
+| [M8](#m8--mcp)                          | MCP                          | erledigt |
 
 ---
 
@@ -76,41 +76,99 @@ später" und wartet darauf, ob es im Alltag wirklich fehlt.
 
 ## M4 – Wochenplanung und Zeitblöcke
 
+**Erledigt am 11.09.2026 mit Version 0.4.0.**
+
 **Ziel:** Aufgaben per Ziehen und Ablegen in den Kalender schreiben — und
 Verschiebungen von dort zurückholen.
 
-- [ ] `Zeitblock` an genau einer Aufgabe und einem Kalenderkonto
+- [x] `Zeitblock` an genau einer Aufgabe und einem Kalenderkonto
-- [ ] Wochenansicht mit `@dnd-kit/core`
+- [x] Wochenansicht mit `@dnd-kit/core`
-- [ ] Schreiben in den Kalender, Rückweg beim Verschieben
+- [x] Schreiben in den Kalender, Rückweg beim Verschieben
-- [ ] Schleifenschutz über `hash = sha256(startISO|endeISO)`
+- [x] Schleifenschutz über `hash = sha256(startISO|endeISO)`
-- [ ] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
+- [x] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
-- [ ] Belegung gegen die Tageskapazität des Bereichs
+- [x] Belegung gegen die Tageskapazität des Bereichs
+
+**Bewusst offen gelassen:** Die Dauer lässt sich nicht am Balken ziehen, und
+ein Zeitblock landet immer im ersten verbundenen Kalender. Beides steht unter
+"Ideen für später" — erst zeigt der Alltag, ob es wirklich fehlt.
 
 ## M5 – Benachrichtigungen
 
-- [ ] Web-Push mit `web-push`
+**Erledigt am 11.09.2026 mit Version 0.5.0.**
-- [ ] Tagesüberblick per E-Mail über nodemailer
+
-- [ ] Erinnerungen an Fälligkeiten, Jobs über node-cron
+**Ziel:** Sagen, was ansteht — und dabei so selten stören, dass niemand auf
-- [ ] Je Benutzer einstellbar, mit Ruhezeiten
+die Idee kommt, alles abzuschalten.
+
+- [x] Web-Push mit `web-push`, Anmeldung je Browser
+- [x] Tagesüberblick per E-Mail über nodemailer
+- [x] Erinnerungen an Fälligkeiten und vor Zeitblöcken, Jobs über node-cron
+- [x] Je Benutzer einstellbar, mit Ruhezeiten über Mitternacht
+- [x] Wiederholungssperre je Anlass, Sache und Tag
+- [x] Abgleichfehler erst nach mehreren Versuchen hintereinander
+
+**Bewusst offen gelassen:** Keine Sammelmeldung mehrerer Anlässe in einer
+Nachricht und kein Nachholen dessen, was in die Ruhezeit fiel. Eine
+Erinnerung an einen Zeitblock, der längst begonnen hat, hilft niemandem.
 
 ## M6 – Integrationen
 
-- [ ] Zammad und Wartungsplaner-API (nur `firma`)
+**Erledigt am 12.09.2026 mit Version 0.6.0.**
-- [ ] Telegram (nur `daheim`)
+
-- [ ] Spiegel: `firma` sendet, `daheim` empfängt
+**Ziel:** Aufgaben dort abholen, wo sie entstehen — ohne dass die Planung
-- [ ] Jede Integration upsertet über `[quelle, quelleRef]`
+darunter leidet, die hier passiert.
+
+- [x] Gemeinsame Aufnahmestelle: jede Integration liefert nur Funde
+- [x] Zammad (nur `firma`), lesend
+- [ ] **Wartungsplaner-API** — Schnittstelle steht noch nicht fest
+- [x] Telegram (nur `daheim`): erfassen, melden, abhaken
+- [x] Spiegel: `firma` sendet, `daheim` empfängt
+- [x] Jede Integration upsertet über `[quelle, quelleRef]`
+
+**Offen geblieben:** Der **Wartungsplaner** ist nicht angebunden. Die
+Aufnahmestelle steht bereit und die Seite „Integrationen" führt ihn als
+sichtbare Lücke; es fehlt allein das Abholen, und dafür muss erst feststehen,
+was das Produkt an Schnittstelle hergibt.
+
+**Bewusst offen gelassen:** Zammad wird nur gelesen. Ein Ticket schließt man
+im Ticketsystem — sonst weiß die Kollegin nicht, warum es plötzlich zu ist.
 
 ## M7 – Schnellerfassung und API
 
-- [ ] Erfassung vom Handy, auch offline
+**Erledigt am 12.09.2026 mit Version 0.7.0.**
-- [ ] Öffentliche API mit Token je Anwendung
+
-- [ ] Rechte je Token, jede Nutzung im Protokoll
+**Ziel:** Etwas festhalten können, wo man gerade steht — und andere
+Anwendungen hereinlassen, ohne ihnen die Schlüssel zum ganzen Haus zu geben.
+
+- [x] Erfassung vom Handy, auch offline
+- [x] Öffentliche API mit Token je Anwendung
+- [x] Rechte je Token, jede schreibende Nutzung im Protokoll
+- [x] Als App ablegbar (Manifest, eigenes Symbol)
+
+**Offen geblieben:** Die Bilder der Erfassungsseite im Handbuch zeigen noch
+eine falsche Inbox-Zahl; der Fehler selbst ist behoben, nur der Bildlauf
+kam danach nicht mehr durch.
+
+**Bewusst offen gelassen:** Die Schnittstelle kann keine Bereiche, Projekte
+oder Zeitblöcke anfassen und nichts löschen. Was von außen kommt, landet in
+der Inbox; die Einordnung bleibt bei dem, der plant. Auch eine Begrenzung der
+Aufrufzahl gibt es nicht — bei einer Handvoll eigener Tokens wäre sie mehr
+Zeremonie als Schutz.
 
 ## M8 – MCP
 
-- [ ] MCP-Server über `@modelcontextprotocol/sdk`
+**Erledigt am 13.09.2026 mit Version 0.8.0.**
-- [ ] Lesen und Anlegen von Aufgaben und Zeitblöcken
+
-- [ ] Rechte wie bei der API, jede Nutzung im Protokoll
+**Ziel:** Ein Sprachmodell soll den Alltag erleichtern können — ohne einen
+eigenen, weicheren Zugang zu bekommen als jede andere fremde Anwendung.
+
+- [x] MCP-Server über `@modelcontextprotocol/sdk`
+- [x] Lesen und Anlegen von Aufgaben und Zeitblöcken
+- [x] Rechte wie bei der API, jede schreibende Nutzung im Protokoll
+- [x] Werkzeugliste richtet sich nach den Rechten des Tokens
+
+**Bewusst offen gelassen:** Der Server kann nichts löschen, keine Bereiche
+oder Projekte anlegen und keine Einstellungen anfassen. Ein Modell soll den
+Alltag erleichtern, nicht die Ordnung umbauen.
 
 ---
 

devlog/DEVLOG.md

@@ -5,12 +5,465 @@ die Übersicht aus `scripts/zeit.sh summe`.
 
 ## Zeit je Meilenstein
 
-| Meilenstein | Art    | Minuten | Stunden  |
+| Meilenstein | Art    | Minuten  | Stunden   |
-| ----------- | ------ | ------- | -------- |
+| ----------- | ------ | -------- | --------- |
-| M1          | claude | 161     | 2,68     |
+| M1          | claude | 161      | 2,68      |
-| M2          | claude | 44      | 0,73     |
+| M2          | claude | 44       | 0,73      |
-| M3          | claude | 41      | 0,68     |
+| M3          | claude | 41       | 0,68      |
-| **Gesamt**  |        | **246** | **4,10** |
+| M4          | claude | 167      | 2,78      |
+| M5          | claude | 420      | 7,00      |
+| M6          | claude | 733      | 12,22     |
+| M7          | claude | 886      | 14,77     |
+| M8          | claude | 69       | 1,15      |
+| **Gesamt**  |        | **2521** | **42,02** |
+
+---
+
+## 2026-09-13 – M8: MCP
+
+**Dauer:** 69 Minuten (14:10–15:19), Art `claude`.
+
+> Der kürzeste Meilenstein — weil das Fundament schon stand. Tokens, Rechte
+> und Protokoll kamen mit M7, der Kalenderschreibweg mit M4. Übrig blieb das
+> Zusammenstecken.
+
+**Ziel der Sitzung:** Ein Sprachmodell soll den Alltag erleichtern können —
+ohne einen eigenen, weicheren Zugang zu bekommen als jede andere fremde
+Anwendung.
+
+### Erledigt
+
+- MCP-Server unter `/api/mcp` über `@modelcontextprotocol/sdk`
+- Sechs Werkzeuge: suchen, Woche ansehen, Kalender auflisten, anlegen,
+  abhaken, einplanen
+- Das Einplanen aus der Serveraktion herausgelöst, damit Oberfläche und MCP
+  dieselbe Stelle benutzen
+- 6 neue E2E-Tests, Beschreibung in `docs/MCP.md`
+
+### Entscheidungen mit Begründung
+
+**Dieselben Tokens, dieselben Rechte wie die Schnittstelle.** Ein
+Sprachmodell ist aus Sicht des Planers eine fremde Anwendung wie jede andere.
+Ein eigener Zugangsweg wäre ein zweiter Satz Regeln — und der zweite Satz ist
+immer der, den man vergisst zu pflegen.
+
+**Die Werkzeugliste richtet sich nach den Rechten.** Was ein Token nicht
+darf, taucht gar nicht erst auf. Ein Modell soll nicht gegen eine Tür laufen,
+die für es verschlossen ist; und eine Fehlermeldung als Antwort auf einen
+Werkzeugaufruf ist verschwendeter Kontext.
+
+**Wenige, grob geschnittene Werkzeuge.** Ein Modell, das zwischen zwanzig
+fast gleichen wählen muss, wählt falsch. Jedes weitere Werkzeug ist zudem
+eine zusätzliche Möglichkeit, versehentlich etwas zu ändern.
+
+**Der Server kann nichts löschen.** Abhaken ja, wegräumen nein. Auch keine
+Bereiche, Projekte oder Einstellungen anfassen. Ein Modell soll den Alltag
+erleichtern, nicht die Ordnung umbauen.
+
+**Das Einplanen liegt jetzt an einer gemeinsamen Stelle** — und die liegt
+bewusst **nicht** in einer Datei mit `'use server'`. Dort wird jede
+exportierte Funktion zu einem Endpunkt, den der Browser aufrufen kann; eine
+Funktion, die den Akteur als Parameter nimmt, wäre dann ein offenes Tor.
+
+**Zustandslos.** Der Planer hat keine langlaufenden Vorgänge, und eine
+Sitzungsverwaltung wäre Zustand, den mehrere Container nicht teilen könnten.
+
+### Probleme und Lösungen
+
+| Problem                                                         | Lösung                                                                                                                              |
+| --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| Der SDK-Transport erwartet Node-Streams, Next liefert `Request` | Das SDK bringt seit 1.30 `WebStandardStreamableHTTPServerTransport` mit — `handleRequest(Request): Promise<Response>` passt direkt. |
+| ESLint beanstandete das Auslesen der Formularfelder             | `FormData.get` kann auch eine Datei liefern; die würde beim Stringify zu `[object Object]`. Ein Helfer nimmt jetzt nur Text.        |
+
+### Offene Punkte
+
+- Der Server ist gegen die eigenen Tests geprüft, nicht gegen einen echten
+  Client. Ein Lauf mit Claude Code gegen die laufende Instanz wäre der
+  Beweis, dass Handschlag und Werkzeugbeschreibungen auch dort taugen.
+- Die Handbuchbilder sind unverändert aus M7 — der MCP-Server hat keine
+  Oberfläche, es gibt nichts abzubilden.
+
+### Commits
+
+- 5f45dff refactor: Einplanen aus der Serveraktion herauslösen
+- bdc4260 feat: MCP-Server über denselben Token wie die API
+- (docs) MCP beschreiben, Fahrplan abschließen
+
+---
+
+## 2026-09-13 – M7: Schnellerfassung und API
+
+**Dauer:** 886 Minuten (10:15–01:01), Art `claude`.
+
+> Wie schon bei M6 sagt die Zahl mehr über den Rechner als über die Arbeit:
+> Fünf hängende Docker-Bauten, einer davon mit einem einzelnen Schritt über
+> drei Stunden. Die Bildaufnahme musste achtmal angestoßen werden.
+
+**Ziel der Sitzung:** Etwas festhalten können, wo man gerade steht — und
+andere Anwendungen hereinlassen, ohne ihnen die Schlüssel zum ganzen Haus zu
+geben.
+
+### Erledigt
+
+- Regeln der Schnittstelle als reine Logik: Rechte, Tokenaufbau, Eingaben
+  (30 Tests)
+- `/api/v1`: Aufgaben lesen, anlegen, ändern, abhaken
+- Tokens mit Rechten und wahlweise Ablauf, verwaltbar in der Anwendung
+- Schnellerfassung fürs Handy mit Warteschlange in IndexedDB
+- Manifest und Symbol: der Planer lässt sich als App ablegen
+- 10 neue E2E-Tests, 6 neue Integrationsprüfungen, Handbuchseite, API-Doku
+
+### Entscheidungen mit Begründung
+
+**Von einem Token liegt nur der Hash in der Datenbank.** Ein Token ist ein
+Passwort; es gibt keinen Grund, es zurücklesen zu können, und jeden Grund,
+es nicht zu können. SHA-256 ohne Salz ist hier richtig — der Wert hat 32
+Byte Zufall, gegen so etwas hilft kein Wörterbuch, und die Prüfung muss bei
+jeder Anfrage schnell sein.
+
+**Kein Recht schließt ein anderes ein.** „Erfassen" darf nicht lesen. Ein
+Dienst, der nur meldet „hier ist etwas Neues", braucht den Bestand nicht zu
+sehen — und das ist der häufigste Fall.
+
+**Der sichtbare Anfang heißt `planer_`.** Wer so einen Wert versehentlich in
+ein öffentliches Verzeichnis schiebt, soll ihn beim Durchsehen erkennen.
+
+**`/selbst` braucht kein Recht.** Sonst müsste man beim Einrichten raten, ob
+der Token falsch ist oder nur zu wenig darf.
+
+**Die Schnittstelle kann Bereich und Projekt nicht setzen.** Was von außen
+kommt, landet in der Inbox. Die Einordnung ist Sache dessen, der plant,
+nicht dessen, der meldet. Löschen kann sie auch nicht: Ein Fehler im fremden
+Skript soll keine Planung vernichten.
+
+**Erst anstellen, dann senden.** Die Schnellerfassung schreibt zuerst in die
+Warteschlange des Geräts und versucht dann zu senden. Andersherum wäre der
+Eintrag weg, wenn der Browser mitten im Senden geschlossen wird.
+
+**IndexedDB statt localStorage.** Das sind echte Daten des Benutzers. Ein
+Eintrag, der beim Aufräumen des Speichers verschwindet, ist eine verlorene
+Aufgabe — genau das, was der Planer verhindern soll.
+
+**Der Dienstarbeiter hält genau eine Seite vor.** Ein halb veralteter Planer
+wäre schlimmer als gar keiner; ein leeres Eingabefeld dagegen veraltet
+nicht. Und ohne die Seite nützte die Warteschlange niemandem: Man käme gar
+nicht erst hin.
+
+**Die Navigation wurde geteilt statt weiter gedehnt.** Nach M6 hatte ich die
+Leiste verbreitert; mit dem dreizehnten Eintrag verschluckte sie erneut
+Punkte. Das war die falsche Antwort: Das Problem ist nicht die Breite,
+sondern die Vermischung. Alltag steht in der Leiste, Einrichtung und
+Verwaltung liegen hinter „Mehr".
+
+### Probleme und Lösungen
+
+| Problem                                                                          | Lösung                                                                                                                                                                    |
+| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Die Erfassungsseite zählte die Inbox anders als die Kopfleiste                   | Sie zählte Ideen mit. Jetzt benutzt sie dieselbe Abfrage. Derselbe Fehlertyp wie in M2 — und wieder nur im Bild aufgefallen, im Code sah jede Seite für sich richtig aus. |
+| Die Leiste verschluckte mit dem dreizehnten Eintrag wieder Punkte                | Aufgeteilt statt verbreitert, siehe oben. Zwei E2E-Tests greifen den neuen Weg über „Mehr" auf.                                                                           |
+| Ein E2E-Test brach mit `ERR_ABORTED` ab                                          | Die Erfolgsmeldung kommt, bevor das Neuladen der Liste fertig ist; wer dann navigiert, bricht es ab. Der Test wartet jetzt darauf.                                        |
+| `exactOptionalPropertyTypes` und Prismas Update-Typen vertragen kein `undefined` | Das Datenobjekt wird Feld für Feld gebaut statt per Spread. Ein gesetztes `undefined` ist etwas anderes als ein fehlendes Feld.                                           |
+| Ein Devanagari-Zeichen war in ein Token-Präfix der Demo-Daten geraten            | Entfernt. Beim Schreiben über die Shell passiert so etwas; die Datei danach durchsucht.                                                                                   |
+| Fünf hängende Docker-Bauten, einer über drei Stunden                             | Kein Codeproblem: Nach Abbruch und Neustart lief derselbe Bau in Minuten durch. Zweimal scheiterte zusätzlich das Anlegen des Compose-Netzes.                             |
+
+### Offene Punkte
+
+- **Die Bilder der Erfassungsseite zeigen die alte Inbox-Zahl.** Der Bildlauf
+  ließ sich nach der Korrektur nicht mehr durchbringen. Ein Lauf, wenn Docker
+  wieder mitspielt, räumt das auf.
+- Keine Begrenzung der Aufrufzahl je Token. Bei einer Handvoll eigener
+  Tokens wäre sie mehr Zeremonie als Schutz — bei einem Token, der außer
+  Haus geht, sähe das anders aus.
+- Die Warteschlange kennt keinen Abbruch: Ein Eintrag, der dauerhaft
+  scheitert, wird ewig erneut versucht. Bisher gibt es keinen Fall, in dem
+  das passieren könnte, ohne dass gleichzeitig die Anmeldung fehlt.
+
+### Commits
+
+- d5c7974 feat: Datenmodell und Regeln für die öffentliche Schnittstelle
+- 6d3ebd0 feat: API v1 für Aufgaben
+- b17c42a feat: Tokens verwalten
+- 9565b9a feat: Schnellerfassung vom Handy, auch ohne Netz
+- 10b49cf test: Die Tür der Schnittstelle scharf prüfen
+- 2e57713 docs: Handbuchseite zum Erfassen und Beschreibung der Schnittstelle
+- 7919149 fix: Navigation aufteilen, statt sie weiter zu dehnen
+- f9a616e docs: Handbuchbilder für M7 aufnehmen
+
+---
+
+## 2026-09-12 – M6: Integrationen
+
+**Dauer:** 733 Minuten (20:47–09:00), Art `claude`.
+
+> Die Zahl täuscht. Ein großer Teil davon war Warten auf Docker-Bauten, die
+> in der Nacht dreimal hängen blieben — einmal 39 Minuten ohne eine Zeile
+> Ausgabe. Die eigentliche Arbeit war knapper.
+
+**Ziel der Sitzung:** Aufgaben dort abholen, wo sie entstehen — ohne dass die
+Planung darunter leidet, die hier passiert.
+
+### Erledigt
+
+- Gemeinsame Aufnahmestelle für alle Integrationen (21 Tests)
+- Zammad, lesend, mit Suchausdruck aus der Konfiguration
+- Telegram: erfassen, melden, abhaken — mit Kopplung über Einmalcode
+- Spiegel zwischen den Instanzen: Belegung ohne Titel, Aufgaben nur markiert
+- Seite „Integrationen" mit Zustand, Fehler und Knopf für den Sofortlauf
+- Gespiegelte Belegung in der Wochenansicht
+- 4 neue E2E-Tests, 9 neue Integrationsprüfungen, Handbuchseite
+
+### Entscheidungen mit Begründung
+
+**Das Ursprungssystem führt Titel, Notiz, Verweis und Fälligkeit — mehr
+nicht.** Bereich, Projekt, Priorität und geschätzter Aufwand gehören der
+Planung. Wer ein Ticket einsortiert und schätzt, muss sich darauf verlassen
+können, dass der nächste Abgleich das nicht wegräumt. Ohne diese Trennung
+wäre die Wochenplanung nach jedem Lauf kaputt.
+
+**Zammad wird nur gelesen.** Ein Ticket schließt man im Ticketsystem, sonst
+weiß die Kollegin nicht, warum es plötzlich zu ist. Umgekehrt darf Zammad
+hier abhaken — dort ist die Wahrheit über den Zustand des Tickets.
+
+**Telegram holt ab, statt einen Webhook zu bekommen.** Ein Webhook verlangt
+eine von außen erreichbare Adresse mit gültigem Zertifikat. Der Planer soll
+auch hinter einem Anschluss ohne feste Adresse laufen, und der Preis dafür
+sind zwei Minuten Verzögerung.
+
+**Unbekannte Chats bekommen keine Antwort — auch keine Fehlermeldung.** Wer
+die Kennung des Bots kennt, könnte ihm sonst schreiben und daran erkennen,
+dass es diesen Planer gibt. Die einzige Ausnahme ist ein gültiger
+Kopplungscode.
+
+**Der Kopplungscode entstand aus einem Widerspruch.** Erst sollte die
+Chatkennung von Hand eingetragen werden. Nur: Um sie zu erfahren, müsste der
+Bot Unbekannten antworten — genau das, was er nicht darf. Der Code dreht die
+Richtung um: Er kommt aus der Anwendung, in die man sich anmelden muss.
+
+**Der Spiegel schickt Belegung ohne Titel.** Daheim soll zu sehen sein,
+_dass_ die Zeit weg ist, nicht woran gearbeitet wird. Aufgaben gehen nur
+einzeln markiert mit — ein Schalter für einen ganzen Bereich würde zu leicht
+Kundennamen nach Hause schicken.
+
+**Was der Sender nicht mehr schickt, verschwindet beim Empfänger.** Sonst
+stünde daheim für immer eine Sperre, die es längst nicht mehr gibt. Für
+Aufgaben gilt das nicht: Sie sind Planung, keine Sperre.
+
+**Jede Sendung ist fünf Minuten gültig.** Ohne Frist ließe sich ein
+abgefangenes Paket beliebig oft erneut einspielen. Der Empfänger antwortet
+auf jeden Fehlschlag gleich — falsches Geheimnis, verstellte Uhr und Unsinn
+im Inhalt sind von außen nicht zu unterscheiden.
+
+**Die Demo-Instanz redet mit niemandem.** Sie ist mit erfundenen Daten
+gefüllt und steht nur für Bilder. Solange `DEMO_MODUS` gilt, starten die
+Jobs für Zammad, Telegram und den Spiegel gar nicht erst.
+
+### Probleme und Lösungen
+
+| Problem                                                                            | Lösung                                                                                                                                                                                         |
+| ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Die Kopfleiste verschluckte mit dem elften Eintrag „Einstellungen" und „Protokoll" | Sie ist jetzt breiter als die Inhaltsspalte. Eine Leiste, die Punkte stillschweigend abschneidet, ist schlimmer als eine, die nicht bündig mit dem Text steht. Gefunden im aufgenommenen Bild. |
+| Der Kartentext erklärte noch den Weg von vor dem Kopplungscode                     | Ersetzt. Ebenfalls erst im Bild aufgefallen — im Code war beides für sich stimmig.                                                                                                             |
+| Ein Kürzungstest schlug an der Grenze fehl                                         | Nicht der Test war falsch, sondern der Vergleich: Eine Worttrennung bei genau der halben Titellänge wurde abgelehnt. Jetzt `>=`.                                                               |
+| Ein regulärer Ausdruck ging beim Schreiben über die Shell kaputt                   | Das Muster steht jetzt als benannte Konstante im Code, geschrieben mit dem Edit-Werkzeug statt über ein Skript.                                                                                |
+| Ein unsichtbares Zeichen (U+200B) landete mitten in einem Funktionsnamen           | Entfernt und die Datei danach abgesucht.                                                                                                                                                       |
+| Das Aufräumen im Integrationstest hätte fremde Telegram-Chats treffen können       | Es trifft jetzt genau die Kennung, die der Lauf selbst angelegt hat.                                                                                                                           |
+| Docker-Bauten blieben dreimal hängen, einmal 39 Minuten ohne Ausgabe               | Kein Codeproblem: Nach Abbruch und Neustart lief derselbe Bau in Minuten durch. Die Bilder mussten deshalb viermal angestoßen werden.                                                          |
+
+### Offene Punkte
+
+- **Der Wartungsplaner ist nicht angebunden.** Die Aufnahmestelle steht
+  bereit und die Seite führt ihn als sichtbare Lücke; es fehlt allein das
+  Abholen. Dafür muss erst feststehen, was das Produkt an Schnittstelle
+  hergibt.
+- Zammad und Telegram sind gegen die Logik geprüft, nicht gegen die echten
+  Dienste — dafür fehlen Zugangsdaten. Der Spiegel dagegen ist end-to-end
+  geprüft, weil beide Enden dieselbe Anwendung sind.
+- Ein Telegram-Chat lässt sich nicht umbenennen. Fällt das im Alltag auf,
+  ist es ein Einzeiler.
+
+### Commits
+
+- 7f8f505 feat: Datenmodell und Umgebung für Integrationen
+- e4d3547 feat: Aufnahmeregeln für Integrationen als reine Logik
+- 6dad333 feat: Zammad, Telegram und den Spiegel anbinden
+- bc60e5f feat: Integrationen takten und Telegram als dritten Meldeweg
+- 1281c3e feat: Integrationen sichtbar und bedienbar machen
+- 0d0f850 feat: Gespiegelte Belegung in der Wochenansicht zeigen
+- 4da2f3d test: Spiegel-Eingang und Integrationstabellen absichern
+- 3befcc1 feat: Aufgaben einzeln zum Spiegeln freigeben
+- f5eadef feat: Lauf von Hand anstoßen und Spiegelschalter in der Liste
+- 3c7cdbb chore: Demo-Daten, Bildaufnahme und Platz in der Kopfleiste
+- 475b1d5 docs: Handbuchseite, README und Fahrplan für M6
+- 98d170b docs: Handbuchbilder für M6 neu aufnehmen
+
+---
+
+## 2026-09-11 – M5: Benachrichtigungen
+
+**Dauer:** 420 Minuten (06:35–13:35), Art `claude`.
+
+**Ziel der Sitzung:** Sagen, was ansteht — und dabei so selten stören, dass
+niemand auf die Idee kommt, alles abzuschalten.
+
+### Erledigt
+
+- Regeln als reine Logik: Anlässe, Ruhezeit, Wiederholungssperre (30 Tests)
+- Web-Push über VAPID samt Service Worker, An- und Abmeldung je Browser
+- Mailversand über nodemailer, als Text und als HTML
+- Vier Anlässe: Tagesüberblick, Fälligkeit, Vorlauf vor einem Zeitblock,
+  Abgleichfehler
+- Bedienung in den Einstellungen mit Probemeldung und Geräteliste
+- Ein Lauf alle zehn Minuten, Nachweise räumt die Nachtrunde weg
+- 2 neue E2E-Tests, 7 neue Integrationsprüfungen, Handbuchseite
+
+### Entscheidungen mit Begründung
+
+**Ab Werk meldet der Planer gar nichts.** Kein Weg ist eingeschaltet. Wer
+beim ersten Start mit Meldungen überschüttet wird, schaltet alles ab — und
+dann auch das Nützliche. Die Einrichtung ist ein bewusster Handgriff, und
+das ist der Preis dafür, dass die Meldungen später ernst genommen werden.
+
+**Der Tagesüberblick ist von der Ruhezeit ausgenommen.** Sonst bekäme ihn
+nie, wer ihn auf 06:00 stellt — die voreingestellte Ruhezeit läuft bis
+07:00. Die Ruhezeit schützt vor Störungen, nicht vor der Nachricht, um die
+ausdrücklich gebeten wurde.
+
+**Der Nachweis wird vor dem Senden geschrieben, nicht danach.** Bricht der
+Versand mittendrin ab, gilt die Meldung als zugestellt und kommt nicht
+wieder. Andersherum würde ein hängender Mailserver dieselbe Nachricht alle
+zehn Minuten erneut versuchen. Lieber eine verpasste Nachricht als eine,
+die im Minutentakt klopft.
+
+**Was in die Ruhezeit fällt, wird nicht nachgeholt.** Eine Erinnerung an
+einen Zeitblock, der längst begonnen hat, ist nur der Beweis, dass die
+Anwendung zu spät kommt.
+
+**Abgleichfehler erst ab dem dritten Versuch in Folge.** Ein Netz hustet,
+ein Anbieter hat Wartung. Beim ersten Fehlschlag zu melden hieße, für
+Dinge zu wecken, die sich von selbst erledigen. Nach dem dritten Mal ist es
+dagegen dringend — solange steht die Wochenansicht auf altem Stand.
+
+**Der Tagesüberblick entfällt, wenn es nichts zu sagen gibt.** „Heute steht
+nichts an" ist keine Information, sondern Lärm.
+
+**Tote Abos putzen sich selbst weg.** 404 und 410 heißen endgültig, das
+Gerät verschwindet sofort; andere Fehler zählen hoch und führen nach fünf
+Versuchen zum selben Ergebnis. Eine Liste, die von Hand gepflegt werden
+muss, wird nicht gepflegt.
+
+**Push-Schlüssel liegen verschlüsselt, Endpunkte nie im Protokoll.** Ein
+Endpunkt genügt, um jemandem Nachrichten zu schicken — er gehört damit in
+dieselbe Klasse wie ein Token.
+
+### Probleme und Lösungen
+
+| Problem                                                                                 | Lösung                                                                                                                                                                              |
+| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `pushManager.subscribe` lehnte den VAPID-Schlüssel als `Uint8Array<ArrayBufferLike>` ab | Der Puffer wird jetzt ausdrücklich als `ArrayBuffer` angelegt; ein geteilter Puffer ist dort nicht erlaubt.                                                                         |
+| Der Integrationstest brach mit einem Fremdschlüsselfehler ab                            | Die neuen Prüfungen standen hinter dem Löschen des Testbenutzers. Jetzt davor — und danach wird geprüft, dass Geräte und Nachweise mit ihm verschwinden.                            |
+| E2E-Läufe scheiterten unter Last immer wieder beim Anmelden                             | Ein Klick, der vor der Hydratation ankommt, verpufft folgenlos. Der Anmeldehelfer liegt jetzt einmal in `e2e/hilfe.ts` und fasst nach, bis die Startseite da ist.                   |
+| Die Karte meldete gleichzeitig „Browser blockiert" und „Server nicht eingerichtet"      | Zwei Aussagen, von denen nur eine zählt. Der Serverzustand geht jetzt vor. Gefunden nur durch das Ansehen des aufgenommenen Bildes.                                                 |
+| Das erfundene Push-Gerät in den Demo-Daten wäre beim ersten Versandlauf gelöscht worden | Seine Schlüssel lagen als Klartext-Platzhalter, und unlesbare Schlüssel führen zum Entfernen. Die Demo-Daten enthalten jetzt kein Gerät mehr — die Bilder zeigen den Zustand davor. |
+| Im Bild meldet der Browser „blockiert", obwohl die Erlaubnis erteilt wurde              | Chromium im Kopflosbetrieb antwortet auf `Notification.permission` immer mit `denied`; `grantPermissions` ändert daran nichts. Das Handbuch schreibt es jetzt unter das Bild.       |
+| Ein Docker-Bau brauchte 14 Minuten, ein E2E-Lauf 18                                     | Systemlast, kein Codeproblem: dieselben Läufe danach in 1,5 beziehungsweise 0,4 Minuten. Ein vergessener Testserver auf Port 3100 hat kräftig mitgeholfen.                          |
+
+### Offene Punkte
+
+- Der Versandweg ist gegen die Logik geprüft, nicht gegen echte Dienste:
+  ohne VAPID-Schlüssel und SMTP-Zugang geht lokal nichts hinaus. Das braucht
+  einen Lauf auf dem Server.
+- Mehrere Anlässe erscheinen als mehrere Nachrichten. Ob eine Sammelmeldung
+  fehlt, zeigt erst der Alltag.
+
+### Commits
+
+- 24f613d feat: Datenmodell und Umgebung für Benachrichtigungen
+- ddb13d7 feat: Regeln für Benachrichtigungen als reine Logik
+- e0e11c8 feat: Versand per Web-Push und E-Mail
+- b622c1b feat: Benachrichtigungen in den Einstellungen bedienen
+- 047a4a1 feat: Meldungen alle zehn Minuten prüfen und verschicken
+- 5bbbdd5 chore: Demo-Daten und Bildaufnahme für Benachrichtigungen
+- f03ea73 docs: Handbuchseite und README-Abschnitt zu Benachrichtigungen
+- 6e1f279 test: Benachrichtigungen end-to-end und in der Datenbank absichern
+- 7bef435 fix: Serverzustand geht der Browsermeldung vor
+- 35ecb2f chore: Screenshot-Instanz mit eingerichteten Meldewegen
+- bb7b189 docs: Handbuchbilder für M5 neu aufnehmen
+
+---
+
+## 2026-09-10 – M4: Wochenplanung und Zeitblöcke
+
+**Dauer:** 167 Minuten (20:42–23:29), Art `claude`.
+
+**Ziel der Sitzung:** Die Kernidee des Projekts — Aufgaben per Ziehen und
+Ablegen in echte Kalendertermine verwandeln, mit Rückweg.
+
+### Erledigt
+
+- `Zeitblock` samt Migration und Schleifenschutz (30 Tests)
+- Schreibweg zu Graph und Google mit `If-Match`, Rückweg im Abgleich
+- Rasterlogik für die Wochenansicht (21 Tests)
+- Wochenansicht mit `@dnd-kit/core`: einplanen, verschieben, ausplanen
+- Kapazität und Belegung je Wochentag
+- 3 neue E2E-Tests, Handbuchseite
+
+### Entscheidungen mit Begründung
+
+**Der Fingerabdruck geht nur über Beginn und Ende.** Titel und Beschreibung
+ändern sich auch aus harmlosen Gründen — etwa weil der Aufgabentitel
+bearbeitet wurde. Für die Planung zählt allein, wann der Block liegt; alles
+andere in den Fingerabdruck zu nehmen hieße, den Anbieter grundlos zu
+behelligen.
+
+**Der Kalender gewinnt, ausnahmslos.** Wer im Kalender etwas verschiebt,
+meint es so. Säße der Planer am längeren Hebel, zöge er dem Benutzer den
+Termin wieder weg — und der wüsste nicht, warum. Bei HTTP 412 verwirft der
+Planer sogar seinen eigenen Fingerabdruck, damit der nächste Abgleich die
+fremde Änderung sicher als solche erkennt.
+
+**Scheitert das Schreiben, überlebt die Planung.** Der Zeitblock bleibt mit
+vermerktem Fehler stehen. Ihn zu verwerfen hieße, die Planung des Benutzers
+wegen eines Netzproblems zu vergessen; das nächste Verschieben trägt ihn
+nach. Beim Löschen ist es umgekehrt: Da verschwindet der Zeitblock auch bei
+unerreichbarem Kalender, sonst wäre die Planung blockiert.
+
+**Die Dauer kommt aus dem geschätzten Aufwand.** Wer schätzt, bekommt die
+passende Blockgröße geschenkt. Das belohnt genau die Gewohnheit, die die
+Planung überhaupt erst tragfähig macht.
+
+**Ziehen beginnt erst nach acht Pixeln.** Ohne diese Schwelle löst jeder
+Klick einen Zug aus und die Knöpfe im Block wären nicht mehr bedienbar.
+
+**Überbuchte Tage werden rot, aber nicht gesperrt.** Der Planer ist ein
+Werkzeug, kein Aufpasser. Manchmal muss ein Tag überbucht sein.
+
+### Probleme und Lösungen
+
+| Problem                                                                                                               | Lösung                                                                                                       |
+| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| Ein Zeitblock steht auch im Terminspiegel und erschien doppelt — einmal als eigene Planung, einmal als fremder Termin | Die Wochenabfrage filtert Termine heraus, deren `extId` zu einem Zeitblock gehört.                           |
+| Ein Build lief 32 Minuten statt Sekunden                                                                              | Systemlast durch einen gleichzeitigen Docker-Bau. Ein sauberer Neubau danach: 46 Sekunden. Kein Codeproblem. |
+| Sich überschneidende Termine lagen unsichtbar übereinander                                                            | `spurenVerteilen` legt sie nebeneinander und gibt eine Spur wieder frei, sobald sie zu Ende ist.             |
+
+### Offene Punkte
+
+- **Der Schreibweg ist nicht gegen die echten APIs geprüft.** Wie in M3
+  fehlen die Zugangsdaten. Die Logik ist getestet, der erste echte Schreib-
+  und Rückweg ist Florians.
+- Die Dauer lässt sich nicht am Balken ziehen; wer eine andere will, ändert
+  den Aufwand der Aufgabe.
+- Ein Zeitblock landet immer im ersten verbundenen Kalender. Das
+  Standard-Kalenderkonto je Bereich ist im Datenmodell vorbereitet, aber
+  noch nicht in der Oberfläche.
+
+### Commits
+
+- 5791047 feat(zeitbloecke): Datenmodell und Schleifenschutz
+- 9c1c916 feat(zeitbloecke): Schreibweg in den Kalender und Rückweg zurück
+- bcb4b8e feat(woche): Rasterlogik für die Wochenansicht
+- fada445 feat(woche): Wochenansicht mit Ziehen und Ablegen
+- 5b1e998 test: Wochenansicht und Ausplanen absichern
+- 0974695 docs: Handbuchseite zur Wochenplanung
 
 ---
 

devlog/zeiten.csv

@@ -2,3 +2,8 @@ datum;start;ende;minuten;meilenstein;art;notiz
 2026-09-10;12:06;14:47;161;M1;claude;M1 Fundament fertiggestellt
 2026-09-10;15:57;16:41;44;M2;claude;M2 Aufgaben und Projekte fertig
 2026-09-10;17:48;18:29;41;M3;claude;M3 Kalender lesen fertig
+2026-09-10;20:42;23:29;167;M4;claude;M4 Wochenplanung fertig
+2026-09-11;06:35;13:35;420;M5;claude;M5 Benachrichtigungen fertig
+2026-09-11;20:47;09:00;733;M6;claude;M6 Integrationen fertig
+2026-09-12;10:15;01:01;886;M7;claude;M7 Schnellerfassung und API fertig
+2026-09-13;14:10;15:19;69;M8;claude;M8 MCP fertig

docker-compose.screenshots.yml

@@ -57,5 +57,21 @@ services:
       WEBAUTHN_RP_NAME: Planer
       WEBAUTHN_ORIGIN: http://127.0.0.1:${SCREENSHOT_APP_PORT:-3200}
       DEMO_MODUS: 'true'
+      # Damit die Karte "Benachrichtigungen" den Normalfall zeigt und nicht
+      # den Hinweis, dass nichts eingerichtet ist. Das Schluesselpaar erzeugt
+      # scripts/screenshots.ts fuer jeden Lauf neu – es steht bewusst nirgends
+      # im Verzeichnis.
+      VAPID_OEFFENTLICH: ${SCREENSHOT_VAPID_OEFFENTLICH:-}
+      VAPID_PRIVAT: ${SCREENSHOT_VAPID_PRIVAT:-}
+      VAPID_KONTAKT: mailto:planer@planer.invalid
+      # Ein Host, den es nie geben wird: die Oberflaeche zeigt E-Mail als
+      # moeglich, hinaus geht trotzdem nichts.
+      SMTP_HOST: smtp.planer.invalid
+      SMTP_ABSENDER: Planer <planer@planer.invalid>
+      # Erfundene Werte, damit die Seite "Integrationen" den eingerichteten
+      # Fall zeigt. Nach draussen geht davon nichts: Die Jobs schweigen,
+      # solange DEMO_MODUS true ist.
+      TELEGRAM_TOKEN: 000000:demo-token-ohne-funktion
+      SPIEGEL_GEHEIMNIS: demo-geheimnis-ohne-funktion
     ports:
       - '${SCREENSHOT_APP_PORT:-3200}:3000'

docs/API.md

@@ -0,0 +1,158 @@
+# Öffentliche Schnittstelle
+
+Für fremde Anwendungen, Skripte und Automaten. Wer den Planer selbst bedient,
+braucht sie nicht.
+
+Basisadresse: `<APP_URL>/api/v1`
+
+## Ausweisen
+
+Jede Anfrage trägt einen Token:
+
+```bash
+curl -H "Authorization: Bearer planer_ab12cd34_…" \
+     https://planer.example.de/api/v1/selbst
+```
+
+Alternativ `X-Planer-Token: planer_…`, falls das Werkzeug keine
+Authorization-Kopfzeile kann.
+
+Tokens legst du in der Anwendung unter **API** an (nur Verwaltung). Der Wert
+erscheint **einmal**; danach liegt in der Datenbank nur sein Fingerabdruck.
+Wer ihn verliert, legt einen neuen an.
+
+## Rechte
+
+Drei Stück, und **keines schließt ein anderes ein**:
+
+| Recht       | Was damit geht                         |
+| ----------- | -------------------------------------- |
+| `lesen`     | Aufgaben abfragen                      |
+| `erfassen`  | Neue Aufgaben anlegen — mehr nicht     |
+| `schreiben` | Bestehende Aufgaben ändern und abhaken |
+
+Ein Dienst, der nur meldet „hier ist etwas Neues", bekommt `erfassen` und
+sonst nichts. Das ist der häufigste Fall und der, bei dem ein mitgelesener
+Token am wenigsten anrichtet.
+
+## Fehler
+
+| Status | Bedeutung                                                   |
+| ------ | ----------------------------------------------------------- |
+| 400    | Die Anfrage war fehlerhaft (Feldliste steht in der Antwort) |
+| 401    | Kein gültiger Token                                         |
+| 403    | Dieser Token darf das nicht                                 |
+| 404    | Gibt es nicht                                               |
+
+401 sieht immer gleich aus — ob ein Token unbekannt, abgelaufen oder
+zurückgezogen ist, verrät die Schnittstelle nicht. Von außen soll sich nicht
+abfragen lassen, welche Tokens es gibt.
+
+## Endpunkte
+
+### `GET /selbst`
+
+Wer bin ich, was darf ich? Braucht **kein** Recht — sonst müsste man raten,
+ob der Token falsch ist oder nur zu wenig darf.
+
+```json
+{ "name": "Wartungsplaner-Import", "rechte": ["erfassen"] }
+```
+
+### `GET /aufgaben` · Recht `lesen`
+
+| Parameter | Standard | Bedeutung           |
+| --------- | -------- | ------------------- |
+| `grenze`  | 25       | Höchstens 100       |
+| `versatz` | 0        | Zum Blättern        |
+| `offen`   | —        | `true` oder `false` |
+
+```json
+{
+  "aufgaben": [
+    {
+      "id": "clx…",
+      "titel": "#4711 Drucker klemmt",
+      "notiz": null,
+      "status": "OFFEN",
+      "prioritaet": 3,
+      "aufwandMinuten": null,
+      "faelligAm": null,
+      "quelle": "API",
+      "ref": "ticket-4711",
+      "url": "https://…",
+      "erstelltAm": "2026-03-17T08:20:00.000Z",
+      "bereich": null,
+      "projekt": null
+    }
+  ],
+  "gesamt": 42,
+  "grenze": 25,
+  "versatz": 0
+}
+```
+
+### `POST /aufgaben` · Recht `erfassen`
+
+```bash
+curl -X POST https://planer.example.de/api/v1/aufgaben \
+  -H "Authorization: Bearer planer_…" \
+  -H "Content-Type: application/json" \
+  -d '{"titel":"Drucker klemmt","ref":"ticket-4711"}'
+```
+
+| Feld             | Pflicht | Bemerkung                           |
+| ---------------- | ------- | ----------------------------------- |
+| `titel`          | ja      | bis 200 Zeichen                     |
+| `notiz`          | nein    | bis 4000 Zeichen                    |
+| `ref`            | nein    | Kennung beim Aufrufer — siehe unten |
+| `url`            | nein    | Verweis ins Ursprungssystem         |
+| `faelligAm`      | nein    | `JJJJ-MM-TT`                        |
+| `prioritaet`     | nein    | 1 (dringend) bis 5 (irgendwann)     |
+| `aufwandMinuten` | nein    | 1 bis 1440                          |
+
+Antwort: `201` mit der angelegten Aufgabe.
+
+**`ref` macht den Aufruf wiederholbar.** Zweimal dieselbe Kennung ergibt
+**eine** Aufgabe, nicht zwei — der zweite Aufruf frischt Titel, Notiz und
+Verweis auf. Ohne `ref` entsteht jedes Mal eine neue Aufgabe; dann hast du es
+so gewollt.
+
+Benutze `ref`, wann immer es drüben eine stabile Kennung gibt. Das ist der
+Unterschied zwischen einer Schnittstelle, die man nach einem Netzhänger
+gefahrlos wiederholen kann, und einer, die dabei Karteileichen anlegt.
+
+### `GET /aufgaben/<id>` · Recht `lesen`
+
+### `PATCH /aufgaben/<id>` · Recht `schreiben`
+
+```bash
+curl -X PATCH https://planer.example.de/api/v1/aufgaben/clx… \
+  -H "Authorization: Bearer planer_…" \
+  -H "Content-Type: application/json" \
+  -d '{"erledigt":true}'
+```
+
+Änderbar sind `titel`, `notiz`, `faelligAm`, `prioritaet`, `aufwandMinuten`
+und `erledigt`. Mindestens ein Feld muss dabei sein.
+
+## Was die Schnittstelle bewusst **nicht** kann
+
+- **Bereich und Projekt setzen.** Was von außen kommt, landet in der Inbox.
+  Die Einordnung ist Sache dessen, der plant, nicht dessen, der meldet —
+  sonst räumt ein fremder Dienst die eigene Ordnung um.
+- **Aufgaben löschen.** Abhaken ja, löschen nein. Ein Fehler im fremden
+  Skript soll keine Planung vernichten.
+- **Zeitblöcke, Bereiche, Projekte oder Kalender anfassen.**
+
+Fehlt dir etwas davon, ist das eine Entscheidung und kein Versehen — sag
+Bescheid, dann wird darüber geredet.
+
+## Protokoll
+
+Jede **schreibende** Nutzung landet im Protokoll, mit dem Token, über den sie
+kam. Lesen nicht: Ein Dienst, der im Minutentakt abfragt, würde das Protokoll
+unbrauchbar machen.
+
+Auch ein abgewiesener Zugriff wird vermerkt. Ein Dienst, der immer wieder an
+dieselbe Wand läuft, ist entweder falsch eingerichtet oder versucht etwas.

docs/MCP.md

@@ -0,0 +1,83 @@
+# MCP-Server
+
+Der Planer spricht das Model Context Protocol. Damit kann ein Sprachmodell
+Aufgaben suchen, anlegen, abhaken und einplanen — mit denselben Tokens und
+denselben Rechten wie die [Schnittstelle](API.md).
+
+Adresse: `<APP_URL>/api/mcp`
+
+## Einrichten
+
+1. In der Anwendung unter **API** einen Token anlegen. Gib ihm nur, was das
+   Modell wirklich braucht.
+2. Den Client auf die Adresse zeigen lassen, mit dem Token als Bearer.
+
+Für Claude Code:
+
+```bash
+claude mcp add planer --transport http https://planer.example.de/api/mcp \
+  --header "Authorization: Bearer planer_…"
+```
+
+Für Clients, die nur stdio können, dazwischen `mcp-remote` setzen:
+
+```json
+{
+  "mcpServers": {
+    "planer": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "mcp-remote",
+        "https://planer.example.de/api/mcp",
+        "--header",
+        "Authorization: Bearer planer_…"
+      ]
+    }
+  }
+}
+```
+
+## Werkzeuge
+
+Welche ein Modell zu sehen bekommt, hängt am Token. Was nicht erlaubt ist,
+taucht gar nicht erst in der Liste auf — ein Modell soll nicht gegen eine Tür
+laufen, die für es verschlossen ist.
+
+| Werkzeug             | Recht       | Was es tut                                      |
+| -------------------- | ----------- | ----------------------------------------------- |
+| `aufgaben_suchen`    | `lesen`     | Aufgaben auflisten, optional gefiltert          |
+| `woche_ansehen`      | `lesen`     | Zeitblöcke einer Woche mit Summe                |
+| `kalender_auflisten` | `lesen`     | Verbundene Kalender samt Kennung                |
+| `aufgabe_anlegen`    | `erfassen`  | Neue Aufgabe in der Inbox                       |
+| `aufgabe_abhaken`    | `schreiben` | Aufgabe auf erledigt setzen                     |
+| `zeitblock_anlegen`  | `schreiben` | Aufgabe einplanen und in den Kalender schreiben |
+
+Zum Einplanen braucht es die Kennung eines Kalenderkontos — daher erst
+`kalender_auflisten`, dann `zeitblock_anlegen`.
+
+`zeitblock_anlegen` geht durch dieselbe Stelle wie das Ziehen in der
+Wochenansicht: Rasterprüfung, Kalenderschreibweg, Schleifenschutz, Protokoll.
+Ein über MCP angelegter Zeitblock verhält sich also genau wie ein von Hand
+gezogener.
+
+## Was der Server bewusst **nicht** kann
+
+- **Löschen.** Weder Aufgaben noch Zeitblöcke. Abhaken ja, wegräumen nein.
+- **Bereich oder Projekt setzen.** Was hier entsteht, landet in der Inbox.
+- **Bereiche, Projekte oder Kalenderkonten anlegen und ändern.**
+- **Einstellungen oder Tokens anfassen.**
+
+Ein Modell soll den Alltag erleichtern, nicht die Ordnung umbauen.
+
+## Protokoll
+
+Jede schreibende Nutzung landet im Protokoll — mit dem Vermerk, dass sie über
+MCP kam, und mit dem Token. Ein Modell, das Aufgaben anlegt, muss genauso
+nachvollziehbar sein wie ein Mensch. Eher noch mehr.
+
+## Ohne Sitzungen
+
+Der Server ist zustandslos: Jede Anfrage steht für sich. Der Planer hat keine
+langlaufenden Vorgänge, und eine Sitzungsverwaltung wäre Zustand, den mehrere
+Container nicht teilen könnten.

docs/handbuch/README.md

@@ -13,31 +13,27 @@ Anleitung für den Alltag mit dem Planer. Eine Seite je Thema.
 
 3. **[Aufgaben erfassen und wiederfinden](aufgaben.md)** – Schnellerfassung,
    Inbox leeren, Filter, Status und Fälligkeit
-4. **[Ideen](ideen.md)** – festhalten, was noch keine Aufgabe ist
+4. **[Schnellerfassung vom Handy](erfassen.md)** – als App ablegen, auch
-5. **[Projekte](projekte.md)** – mehrere Aufgaben unter einem Ziel, mit
+   ohne Netz erfassen
+5. **[Ideen](ideen.md)** – festhalten, was noch keine Aufgabe ist
+6. **[Projekte](projekte.md)** – mehrere Aufgaben unter einem Ziel, mit
    Fortschritt
-6. **[Kalenderkonten](kalenderkonten.md)** – Microsoft 365 und Google
+7. **[Kalenderkonten](kalenderkonten.md)** – Microsoft 365 und Google
    verbinden, Belegung verstehen
+8. **[Wochenplanung](woche.md)** – Aufgaben per Ziehen und Ablegen in den
+   Kalender legen
+9. **[Benachrichtigungen](benachrichtigungen.md)** – Push, E-Mail und
+   Telegram einrichten, Ruhezeiten setzen
+10. **[Integrationen](integrationen.md)** – Zammad, Telegram und der Spiegel
+    zwischen Firma und Daheim
 
 ## Verwaltung
 
-7. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
+11. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
-
-## Was noch kommt
-
-Diese Seiten entstehen mit den nächsten Meilensteinen:
-
-| Thema                           | Meilenstein |
-| ------------------------------- | ----------- |
-| Wochenplanung und Zeitblöcke    | M4          |
-| Benachrichtigungen              | M5          |
-| Integrationen                   | M6          |
-| Schnellerfassung vom Handy, API | M7          |
-| MCP                             | M8          |
-
-Der [Fahrplan](../../ROADMAP.md) sagt, was in welchem Meilenstein steckt.
 
 ---
 
+Für fremde Anwendungen und Skripte: [Schnittstelle](../API.md).
+Für Sprachmodelle: [MCP-Server](../MCP.md).
 Zur Einrichtung einer neuen Instanz: [Schnellstart](../SCHNELLSTART.md).
 Für Betrieb, Sicherung und alle Umgebungsvariablen: [README](../../README.md).

docs/handbuch/benachrichtigungen.md

@@ -0,0 +1,108 @@
+# Benachrichtigungen
+
+Ab Werk meldet der Planer **gar nichts**. Das ist Absicht: Eine Anwendung,
+die zu oft meldet, wird stummgeschaltet — und dann verpasst du auch das
+Wichtige. Was du hier einschaltest, kommt. Alles andere nicht.
+
+![Benachrichtigungen in den Einstellungen](../bilder/benachrichtigungen-hell-schreibtisch.png)
+
+_Der Browser auf dem Bild hat Benachrichtigungen blockiert — so sieht die
+Karte aus, wenn die Erlaubnis fehlt. Wie du sie erteilst, steht weiter unten._
+
+Du findest die Einstellung unter **Einstellungen → Benachrichtigungen**.
+
+## Die zwei Wege
+
+|           | Web-Push                                 | E-Mail                                   |
+| --------- | ---------------------------------------- | ---------------------------------------- |
+| Kommt an  | als Systemmeldung auf dem Gerät          | im Postfach                              |
+| Braucht   | Erlaubnis des Browsers, je Gerät einzeln | nichts weiter                            |
+| Gut für   | „gleich beginnt ein Zeitblock"           | den Tagesüberblick am Morgen             |
+| Fällt aus | wenn der Browser die Erlaubnis entzieht  | wenn der Mailserver nicht erreichbar ist |
+
+Beide Wege lassen sich gleichzeitig einschalten. Dann kommt jede Meldung
+über beide — der Planer verschickt sie trotzdem nur **einmal je Anlass**.
+
+Ist ein Weg auf dem Server nicht eingerichtet, steht das direkt daneben.
+Was dafür nötig ist, steht im [README](../../README.md), Abschnitt
+_Benachrichtigungen_.
+
+## Push auf einem Gerät einschalten
+
+1. Auf **Anmelden** klicken.
+2. Der Browser fragt nach Erlaubnis — **Zulassen**.
+3. Das Gerät erscheint in der Liste darunter.
+
+Das gilt **je Gerät und je Browser**. Der Rechner im Büro und das Handy
+sind zwei Anmeldungen; Firefox und Chrome auf demselben Rechner ebenfalls.
+
+> **Der Knopf fehlt oder ist grau?** Push braucht HTTPS. Unter
+> `http://localhost` geht es zum Entwickeln, unter jeder anderen
+> Klartextadresse nicht. Hat der Browser Benachrichtigungen einmal
+> blockiert, lässt sich das nur in seinen eigenen Einstellungen
+> zurücknehmen — die Anwendung darf dann nicht mehr fragen.
+
+Ein Gerät, das der Push-Dienst dauerhaft ablehnt, entfernt der Planer von
+selbst aus der Liste. Du musst nichts aufräumen.
+
+## Was gemeldet wird
+
+| Anlass                                   | Wann                                                                     |
+| ---------------------------------------- | ------------------------------------------------------------------------ |
+| **Tagesüberblick**                       | einmal morgens zur eingestellten Zeit                                    |
+| **Fällige Aufgaben**                     | wenn eine Aufgabe an diesem Tag fällig wird, höchstens einmal je Aufgabe |
+| **Gleich beginnt ein Zeitblock**         | kurz vor dem Beginn, Vorlauf einstellbar                                 |
+| **Kalender lässt sich nicht abgleichen** | erst nach dem dritten Fehlversuch hintereinander                         |
+
+Eingeschaltet sind anfangs nur Tagesüberblick und fällige Aufgaben — und
+selbst die kommen erst, wenn du einen Weg (Push oder E-Mail) aktiviert hast.
+
+Der **Tagesüberblick** entfällt an Tagen, an denen es nichts zu sagen gibt.
+Eine Meldung „heute steht nichts an" ist keine Information, sondern Lärm.
+
+Der **Abgleichfehler** kommt bewusst spät: Ein Netz hustet, ein Anbieter hat
+Wartung. Erst wenn es dreimal hintereinander nicht klappt, ist es eine
+Nachricht wert — dann allerdings dringend, denn solange bleibt deine
+Wochenansicht auf einem alten Stand.
+
+## Ruhezeit
+
+Voreingestellt ist **20:00 bis 07:00**. In diesem Fenster kommt nichts.
+
+- Die Ruhezeit läuft über Mitternacht hinweg — das ist der Normalfall.
+- Gleiche Start- und Endzeit heißt: **keine** Ruhezeit.
+- **Am Wochenende still** legt Samstag und Sonntag komplett still.
+
+Eine Ausnahme: Der **Tagesüberblick** kommt zu seiner festen Zeit, auch wenn
+die noch in der Ruhezeit liegt. Wer ihn auf 06:00 stellt, steht um 06:00 auf
+und will ihn dann auch haben.
+
+Was in der Ruhezeit anfällt, wird **nicht nachgeholt**. Eine Erinnerung an
+einen Zeitblock, der längst begonnen hat, hilft niemandem.
+
+## Ausprobieren
+
+Der Knopf **Probe senden** schickt eine Testmeldung über alle
+eingeschalteten Wege — er umgeht Ruhezeit und Wiederholungssperre. Wer
+darauf drückt, will jetzt wissen, ob es ankommt.
+
+Die Rückmeldung sagt, was passiert ist: an wie viele Geräte der Push ging,
+ob die Mail hinausging. Kommt „kein Gerät für Push angemeldet", fehlt die
+Anmeldung dieses Browsers.
+
+## Wenn nichts ankommt
+
+| Symptom                                   | Ursache                                                           |
+| ----------------------------------------- | ----------------------------------------------------------------- |
+| Probe sagt „verschickt", nichts kommt an  | Betriebssystem blendet Browsermeldungen aus (Fokus, Nicht stören) |
+| Gerät verschwindet immer wieder           | Der Push-Dienst lehnt das Abo ab — neu anmelden                   |
+| Gar nichts, seit der Server umgezogen ist | Neues Schlüsselpaar auf dem Server. Alle Geräte neu anmelden      |
+| Mail fehlt, Push kommt                    | SMTP prüfen; Fehler stehen im Serverprotokoll                     |
+
+Der Planer prüft alle zehn Minuten, ob etwas zu melden ist. Eine Erinnerung
+kann also ein paar Minuten vor der eingestellten Zeit kommen — nie danach.
+
+---
+
+Weiter zur [Wochenplanung](woche.md) oder zurück zum
+[Handbuch](README.md).

docs/handbuch/erfassen.md

@@ -0,0 +1,61 @@
+# Schnellerfassung vom Handy
+
+Die Seite **Erfassen** ist für den Moment gemacht, in dem dir etwas einfällt
+und du keine Zeit hast, es einzusortieren: ein Feld, ein Knopf, fertig.
+
+![Die Seite Erfassen](../bilder/erfassen-hell-handy.png)
+
+Alles, was hier hereinkommt, landet in der **Inbox** — ohne Bereich, ohne
+Termin. Das Einsortieren passiert später am Rechner, wenn Ruhe dafür ist.
+
+## Als Anwendung ablegen
+
+Der Planer lässt sich auf dem Startbildschirm ablegen und verhält sich dann
+wie eine App: eigenes Symbol, kein Browserrahmen, direkt auf dieser Seite.
+
+| Gerät                 | Weg                                          |
+| --------------------- | -------------------------------------------- |
+| Android (Chrome)      | Menü ⋮ → **App installieren**                |
+| iPhone (Safari)       | Teilen-Symbol → **Zum Home-Bildschirm**      |
+| Rechner (Chrome/Edge) | Symbol in der Adresszeile → **Installieren** |
+
+## Ohne Netz
+
+**Das ist der eigentliche Punkt dieser Seite.** Im Keller, im Aufzug, im Zug
+zwischen zwei Funkzellen: Erfasst wird trotzdem.
+
+Was passiert:
+
+1. Das Erfasste wird **zuerst im Gerät gemerkt**, dann verschickt. Nicht
+   andersherum — sonst wäre es weg, wenn du den Browser mitten im Senden
+   schließt.
+2. Ohne Netz bleibt es liegen und steht unter dem Feld als „wartet".
+3. Sobald wieder Netz da ist, geht es von selbst hinaus. Du bekommst eine
+   kurze Rückmeldung.
+
+Der Knopf **Jetzt versuchen** stößt das von Hand an, wenn du nicht warten
+magst.
+
+> **Geht dabei etwas verloren?** Nein. Jede Erfassung bekommt eine eigene
+> Kennung, die mitgeschickt wird. Kommt dieselbe Nachricht zweimal an — weil
+> die Verbindung beim ersten Versuch abbrach, die Anfrage aber trotzdem
+> durchging —, entsteht trotzdem nur **eine** Aufgabe.
+
+Die Warteschlange liegt in der Datenbank des Browsers, nicht im flüchtigen
+Speicher. Sie übersteht das Schließen des Tabs und einen Neustart des
+Geräts.
+
+Damit die Seite ohne Netz überhaupt aufgeht, hält der Planer genau **diese
+eine Seite** vor. Alle anderen Seiten holt er immer frisch: Ein halb
+veralteter Planer wäre schlimmer als gar keiner — ein leeres Eingabefeld
+dagegen veraltet nicht.
+
+## Warum nicht die Erfassung auf der Startseite?
+
+Die gibt es weiterhin, und sie ist am Rechner meist der kürzere Weg. Der
+Unterschied ist die Verlässlichkeit: Die Schnellerfassung ist die einzige
+Stelle, die ohne Netz nichts verliert.
+
+---
+
+Weiter zur [Inbox](aufgaben.md) oder zurück zum [Handbuch](README.md).

docs/handbuch/integrationen.md

@@ -0,0 +1,151 @@
+# Integrationen
+
+Was von außen hereinkommt — und was diese Instanz hinausgibt. Du findest den
+Überblick im Menü unter **Integrationen**.
+
+![Die Seite Integrationen](../bilder/integrationen-hell-schreibtisch.png)
+
+Welche Integration es überhaupt gibt, hängt an der Instanz und ist nicht
+verhandelbar:
+
+|                | Firma  | Daheim   |
+| -------------- | ------ | -------- |
+| Zammad         | ja     | nein     |
+| Wartungsplaner | ja     | nein     |
+| Telegram       | nein   | ja       |
+| Spiegel        | sendet | empfängt |
+
+Eine Integration, die deine Instanz nicht vorsieht, lässt sich auch mit
+vollständiger Konfiguration nicht anschalten. Das steckt in der Anwendung,
+nicht in einer Einstellung, die sich versehentlich verstellen ließe.
+
+## Was jede Integration mit deinen Aufgaben darf
+
+Für alle gilt dieselbe Regel — und die ist wichtiger als jedes Detail
+darunter:
+
+| Führt das Ursprungssystem         | Führst du                                        |
+| --------------------------------- | ------------------------------------------------ |
+| Titel, Notiz, Verweis, Fälligkeit | Bereich, Projekt, Priorität, geschätzter Aufwand |
+
+Wer ein Ticket in einen Bereich einsortiert und den Aufwand schätzt, muss
+sich darauf verlassen können, dass der nächste Abgleich das nicht wegräumt.
+Umgekehrt: Ändert sich drüben der Titel, zieht er hier mit.
+
+Dieselbe Sache ergibt nie eine zweite Aufgabe. Der Planer merkt sich zu jeder
+Aufgabe, woher sie kam und unter welcher Kennung.
+
+## Zammad
+
+Tickets, auf die der Suchausdruck passt, werden zu Aufgaben. Voreingestellt
+sind die dir zugewiesenen offenen Tickets; der Ausdruck steht in der
+Konfiguration (`ZAMMAD_ABFRAGE`) und versteht Zammads Suchsyntax.
+
+- Der Titel wird `#Nummer Betreff`, der Verweis führt direkt ins Ticket.
+- Ein Ticket, das Zammad als geschlossen meldet, hakt der Planer ab.
+- **Geschrieben wird nach Zammad nichts.** Ein Ticket schließt man im
+  Ticketsystem — sonst weiß die Kollegin nicht, warum es plötzlich zu ist.
+
+Der Token gehört einem Benutzer und sieht genau das, was dieser Benutzer
+sehen darf. Der Planer umgeht keine Rechte.
+
+## Wartungsplaner
+
+Noch nicht angebunden. Die Aufnahmestelle steht bereit — es fehlt allein das
+Abholen, und dafür muss die Schnittstelle feststehen. Auf der Seite
+**Integrationen** ist der Punkt als offene Lücke sichtbar, damit er nicht in
+Vergessenheit gerät.
+
+## Telegram
+
+Drei Dinge in einem Kanal.
+
+### Chat verbinden
+
+1. Unter **Integrationen** auf **Chat verbinden**.
+2. Der achtstellige Code erscheint. Er gilt **zehn Minuten** und genau
+   **einmal**.
+3. Schick ihn dem Bot — als Nachricht oder als `/start ABCD2345`.
+4. Der Bot bestätigt, und der Chat erscheint in der Liste.
+
+> **Warum der Umweg?** Wer nicht in der Liste steht, bekommt vom Bot keine
+> Antwort — auch keine Fehlermeldung. Sonst könnte jeder, der die Kennung des
+> Bots kennt, herausfinden, dass es dich gibt. Der Code ist der Beweis, dass
+> jemand mit Zugang zur Anwendung diesen Chat wirklich will.
+
+### Erfassen
+
+Jede Nachricht an den Bot wird eine Aufgabe. Lange Texte werden gekürzt; der
+Rest landet in der Notiz und geht nicht verloren. Die Aufgabe hat keinen
+Bereich — sie liegt also in der **Inbox** und will einsortiert werden.
+
+### Melden und abhaken
+
+Ist Telegram in den [Benachrichtigungen](benachrichtigungen.md) als Weg
+eingeschaltet, kommen Meldungen auch hier an. Geht es um genau eine Aufgabe,
+hängt darunter ein Knopf **✓ Erledigt** — ein Druck, und sie ist abgehakt,
+ohne die Anwendung zu öffnen.
+
+Mehr kann der Knopf nicht. Löschen oder Verschieben aus einem Chat heraus
+wäre zu leicht versehentlich getroffen.
+
+Je Chat lässt sich einzeln einstellen, ob er Meldungen bekommt: Das Glöckchen
+in der Liste schaltet um.
+
+## Der Spiegel
+
+Die Firma schickt nach Hause, nicht umgekehrt. Zwei Dinge gehen hinüber.
+
+**Belegungen.** Wann dienstlich Zeit verplant ist — ohne Titel, ohne Aufgabe,
+ohne Kunde. Daheim erscheinen sie in der Wochenansicht als gestreifte Balken
+mit der Aufschrift „Dienstlich belegt" und zählen gegen die Tageskapazität.
+So kollidiert die private Planung nicht mit der dienstlichen, und trotzdem
+verlässt kein Firmeninhalt die Firma.
+
+**Markierte Aufgaben.** Nur was du an der Aufgabe ausdrücklich zum Spiegeln
+freigibst, geht mit Titel hinüber. Das ist eine Einzelentscheidung je
+Aufgabe, kein Schalter für alles: Wer versehentlich einen ganzen Bereich
+spiegelt, schickt Kundennamen nach Hause.
+
+Was der Sender nicht mehr schickt, verschwindet auch drüben. Wird ein
+Zeitblock in der Firma ausgeplant, ist die Sperre daheim beim nächsten Lauf
+weg — sonst stünde dort für immer eine Blockade, die es längst nicht mehr
+gibt.
+
+## Wann läuft was
+
+| Integration | Takt            |
+| ----------- | --------------- |
+| Telegram    | alle 2 Minuten  |
+| Zammad      | alle 15 Minuten |
+| Spiegel     | alle 15 Minuten |
+
+Wer dem Bot etwas schickt, erwartet die Aufgabe gleich in der Liste. In
+Zammad ändert sich dagegen nichts im Minutentakt.
+
+Warten muss man trotzdem nicht: Auf der Seite **Integrationen** stößt
+**Jetzt abrufen** einen Lauf von Hand an. Das lohnt vor allem direkt nach dem
+Einrichten — sonst wüsstest du erst beim nächsten Takt, ob die Zugangsdaten
+stimmen.
+
+## Wenn etwas klemmt
+
+Unter jeder Integration steht, wann sie zuletzt geglückt ist und woran sie
+zuletzt gescheitert ist. Nach dem dritten Fehlschlag hintereinander gilt sie
+als **gestört** — und dann meldet sich der Planer auch, sofern du den Anlass
+„Ein Kalender lässt sich nicht abgleichen" eingeschaltet hast.
+
+Erst nach dem dritten Mal: Ein Netz hustet, ein Anbieter hat Wartung. Beim
+ersten Fehlschlag zu melden hieße, dich für Dinge zu wecken, die sich von
+selbst erledigen.
+
+| Symptom                                  | Ursache                                                                           |
+| ---------------------------------------- | --------------------------------------------------------------------------------- |
+| „Nicht eingerichtet" trotz Konfiguration | Die Instanz sieht diese Integration nicht vor                                     |
+| Zammad findet nichts                     | Der Suchausdruck passt auf kein Ticket — in Zammad selbst probieren               |
+| Der Bot antwortet nicht                  | Der Chat ist nicht verbunden, oder der Code war abgelaufen                        |
+| Der Spiegel wird abgelehnt               | Verschiedene Geheimnisse, oder die Uhren laufen mehr als fünf Minuten auseinander |
+
+---
+
+Zurück zum [Handbuch](README.md).

docs/handbuch/woche.md

@@ -0,0 +1,106 @@
+# Wochenplanung und Zeitblöcke
+
+Hier wird aus einer Aufgabe ein Termin. Du ziehst sie in ein Zeitfenster, und
+der Planer legt sie als **Zeitblock** in deinen echten Kalender.
+
+![Die Wochenansicht](../bilder/woche-hell-schreibtisch.png)
+
+## Der Aufbau
+
+| Wo                    | Was                                                                                                           |
+| --------------------- | ------------------------------------------------------------------------------------------------------------- |
+| **Links**             | Alles, was noch eingeplant werden kann — offen, geplant oder wartend. Ideen bleiben draußen                   |
+| **Rechts**            | Sieben Tage im Viertelstundenraster                                                                           |
+| **Über jeder Spalte** | Belegte Zeit gegen die Kapazität dieses Tages                                                                 |
+| **Graue Balken**      | Termine aus deinem Kalender. Sie gehören dem Kalender, nicht dem Planer — hier lassen sie sich nicht anfassen |
+| **Farbige Balken**    | Deine Zeitblöcke, in der Farbe ihres Bereichs                                                                 |
+
+Das sichtbare Stundenfenster ergibt sich aus den Arbeitsfenstern **aller**
+Bereiche, mit einer Stunde Luft nach oben und unten.
+
+## Eine Aufgabe einplanen
+
+Aufgabe links am Griff packen und in ein Zeitfenster ziehen. Fertig — der
+Zeitblock steht sofort im Raster und wenige Augenblicke später in deinem
+Kalender.
+
+> **Die Dauer kommt aus dem geschätzten Aufwand.** Wer bei der Aufgabe
+> „90 Minuten" einträgt, bekommt einen 90-Minuten-Block. Ohne Schätzung sind
+> es 60 Minuten, die du danach anpassen kannst.
+
+Eine eingeplante Aufgabe wechselt automatisch von _Offen_ auf _Geplant_.
+
+## Verschieben
+
+Am Griff im Block packen und woandershin ziehen. Der Planer zieht den
+Kalendertermin nach.
+
+## Ausplanen
+
+Das Kreuz im Block. Der Termin verschwindet aus dem Kalender; die Aufgabe
+bleibt und fällt zurück auf _Offen_, wenn nichts anderes mehr für sie geplant
+ist.
+
+## Wenn du im Kalender verschiebst
+
+Das darfst du — und der Planer zieht nach. Beim nächsten Abgleich (spätestens
+nach 15 Minuten) steht der Block dort, wo du ihn im Kalender hingelegt hast.
+
+> **Der Kalender gewinnt.** Immer. Wer dort etwas verschiebt, meint es so;
+> säße der Planer am längeren Hebel, würde er dir den Termin wieder wegziehen
+> und du wüsstest nicht, warum.
+>
+> Löschst du den Termin im Kalender, verschwindet auch der Zeitblock. Die
+> Aufgabe selbst bleibt.
+
+### Warum sich das nicht aufschaukelt
+
+Der Planer merkt sich zu jedem Zeitblock einen Fingerabdruck des Zeitraums,
+den er zuletzt geschrieben hat. Findet er beim Abgleich genau diesen
+Fingerabdruck wieder, war es seine eigene Änderung — er tut nichts. Weicht er
+ab, hat jemand anderes verschoben.
+
+Ohne diesen Kniff würden App und Kalender einander endlos hinterherschreiben.
+
+## Das Warnzeichen im Block
+
+Ein kleines Dreieck heißt: **noch nicht im Kalender**. Meist war der Anbieter
+gerade nicht erreichbar.
+
+Der Zeitblock bleibt trotzdem stehen — deine Planung soll nicht verlorengehen,
+bloß weil ein Server hustet. Verschiebe den Block einmal, dann trägt der
+Planer ihn nach.
+
+## Die Zahl über der Spalte
+
+`3 h / 6 h` heißt: sechs Stunden Kapazität an diesem Tag, drei davon schon
+belegt. Gezählt werden Kalendertermine **und** deine Zeitblöcke.
+
+Wird die Zahl rot, ist der Tag überbucht. Das ist keine Sperre — der Planer
+lässt dich weiterplanen. Es ist ein Hinweis, dass der Tag nicht aufgeht.
+
+Ganztägige Termine zählen nicht mit. Ein Urlaubstag im Kalender blockiert
+sonst rechnerisch den ganzen Tag, obwohl er gar keine Arbeitszeit kostet.
+
+## Blättern
+
+**Zurück**, **Diese Woche** und **Weiter**. Die Woche steht in der Adresse —
+eine bestimmte Woche lässt sich also als Lesezeichen ablegen.
+
+## Wenn es klemmt
+
+| Was du siehst                                            | Was dahintersteckt                                                                                                                    |
+| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| „Ohne verbundenen Kalender lässt sich nichts einplanen." | Erst unter [Kalender](kalenderkonten.md) ein Konto verbinden                                                                          |
+| „Eingeplant, aber nicht in den Kalender geschrieben"     | Der Anbieter war nicht erreichbar. Der Block steht, verschiebe ihn einmal zum Nachtragen                                              |
+| „Der Termin wurde inzwischen im Kalender geändert."      | Jemand war schneller. Der Kalender gewinnt; der nächste Abgleich holt den dortigen Stand                                              |
+| „Zeitblöcke rasten in 15-Minuten-Schritten ein."         | Das Raster ist Absicht. Genauer zu planen bringt nichts                                                                               |
+| Ein Block ist nicht zu sehen                             | Er liegt außerhalb des sichtbaren Stundenfensters. Das Fenster folgt den Arbeitsfenstern der Bereiche — siehe [Bereiche](bereiche.md) |
+
+## Was noch nicht geht
+
+- **Ein Zeitblock landet immer im ersten verbundenen Kalender.** Die Auswahl
+  je Bereich ist im Datenmodell vorbereitet, aber noch nicht in der
+  Oberfläche.
+- **Die Dauer lässt sich nicht am Balken ziehen.** Wer eine andere Dauer will,
+  ändert den Aufwand der Aufgabe und plant neu ein.

e2e/anmeldung.spec.ts

@@ -50,7 +50,11 @@ test.describe('Anmeldung', () => {
     await page.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
 
     await expect(page.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
-    // exact, weil die Startseite zusätzlich einen Link "Bereiche verwalten" hat.
+    // Alltagspunkte stehen in der Leiste, Einrichtung liegt hinter "Mehr".
+    await expect(page.getByRole('link', { name: 'Aufgaben', exact: true })).toBeVisible()
+    await expect(page.getByRole('link', { name: 'Bereiche', exact: true })).toBeHidden()
+
+    await page.getByText('Mehr', { exact: true }).click()
     await expect(page.getByRole('link', { name: 'Bereiche', exact: true })).toBeVisible()
 
     await page.getByTitle('Abmelden').click()
@@ -64,6 +68,8 @@ test.describe('Anmeldung', () => {
     await page.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
     await expect(page.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
 
+    // Das Protokoll liegt hinter "Mehr" – aufklappen, dann hin.
+    await page.getByText('Mehr', { exact: true }).click()
     await page.getByRole('link', { name: 'Protokoll' }).click()
     await expect(page.getByRole('heading', { name: 'Protokoll' })).toBeVisible()
   })

e2e/api.spec.ts

@@ -0,0 +1,187 @@
+import { createHash, randomBytes } from 'node:crypto'
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+import { EMAIL, VERBINDUNG } from './hilfe'
+
+/**
+ * Die öffentliche Schnittstelle.
+ *
+ * Geprüft wird vor allem, was **nicht** geht: ohne Token, mit falschem
+ * Token, mit zu wenig Rechten, mit abgelaufenem oder zurückgezogenem Token.
+ * Der gute Fall ist schnell erzählt — die Tür ist das Interessante.
+ */
+
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+const PRAEFIX = `E2E-API-${Date.now()}`
+
+/** Legt einen Token direkt in der Datenbank an und gibt den Klartext zurück. */
+async function tokenBauen(
+  benutzerId: string,
+  rechte: string,
+  zusatz: { gueltigBis?: Date; widerrufenAm?: Date } = {},
+): Promise<string> {
+  const praefix = randomBytes(4).toString('hex')
+  const klartext = `planer_${praefix}_${randomBytes(32).toString('base64url')}`
+  await db.apiToken.create({
+    data: {
+      benutzerId,
+      name: `${PRAEFIX} ${rechte}`,
+      praefix,
+      hash: createHash('sha256').update(klartext, 'utf8').digest('hex'),
+      rechte,
+      ...zusatz,
+    },
+  })
+  return klartext
+}
+
+test.describe('API v1', () => {
+  test.skip(!EMAIL || !VERBINDUNG, 'Ohne ADMIN_EMAIL und DATABASE_URL kein Testkonto.')
+
+  let benutzerId = ''
+
+  test.beforeAll(async () => {
+    const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
+    benutzerId = benutzer.id
+  })
+
+  test.afterAll(async () => {
+    await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
+    await db.aufgabe.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } })
+    await db.apiToken.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'api.' } } })
+    await db.$disconnect()
+  })
+
+  test('weist eine Anfrage ohne Token ab', async ({ request }) => {
+    const antwort = await request.get('/api/v1/aufgaben')
+    expect(antwort.status()).toBe(401)
+    // Sagt Werkzeugen, wie sie sich ausweisen sollen.
+    expect(antwort.headers()['www-authenticate']).toBe('Bearer')
+  })
+
+  test('weist einen erfundenen Token ab', async ({ request }) => {
+    const antwort = await request.get('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer planer_abcdefgh_${'x'.repeat(43)}` },
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('sagt einem gültigen Token, was er darf', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen,erfassen')
+    const antwort = await request.get('/api/v1/selbst', {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+    expect(antwort.ok()).toBe(true)
+    expect(await antwort.json()).toMatchObject({ rechte: ['lesen', 'erfassen'] })
+  })
+
+  test('lässt einen Nur-Lesen-Token nicht erfassen', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen')
+    const antwort = await request.post('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+      data: { titel: `${PRAEFIX} darf nicht` },
+    })
+    expect(antwort.status()).toBe(403)
+    expect(await db.aufgabe.count({ where: { titel: `${PRAEFIX} darf nicht` } })).toBe(0)
+  })
+
+  test('lässt einen Nur-Erfassen-Token nicht lesen', async ({ request }) => {
+    // Erfassen schließt Lesen ausdrücklich nicht ein.
+    const token = await tokenBauen(benutzerId, 'erfassen')
+    const antwort = await request.get('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+    expect(antwort.status()).toBe(403)
+  })
+
+  test('weist einen abgelaufenen Token ab', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen', {
+      gueltigBis: new Date(Date.now() - 60_000),
+    })
+    const antwort = await request.get('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('weist einen zurückgezogenen Token ab', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen', { widerrufenAm: new Date() })
+    const antwort = await request.get('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('erfasst, wiederholt sich nicht und ändert', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen,erfassen,schreiben')
+    const kopf = { Authorization: `Bearer ${token}` }
+    const ref = `${PRAEFIX}-ref`
+
+    const erste = await request.post('/api/v1/aufgaben', {
+      headers: kopf,
+      data: { titel: `${PRAEFIX} Angebot schreiben`, ref },
+    })
+    expect(erste.status()).toBe(201)
+    const angelegt = (await erste.json()) as { id: string; titel: string }
+
+    // Dasselbe noch einmal: eine Aufgabe, nicht zwei.
+    const zweite = await request.post('/api/v1/aufgaben', {
+      headers: kopf,
+      data: { titel: `${PRAEFIX} Angebot schreiben`, ref },
+    })
+    expect(zweite.ok()).toBe(true)
+    expect(await db.aufgabe.count({ where: { quelle: 'API', quelleRef: ref } })).toBe(1)
+
+    // Abhaken über die Schnittstelle.
+    const geaendert = await request.patch(`/api/v1/aufgaben/${angelegt.id}`, {
+      headers: kopf,
+      data: { erledigt: true },
+    })
+    expect(geaendert.ok()).toBe(true)
+    expect((await geaendert.json()) as { status: string }).toMatchObject({
+      status: 'ERLEDIGT',
+    })
+
+    // Und im Protokoll steht, dass es über die Schnittstelle kam.
+    const protokoll = await db.auditEintrag.findFirst({
+      where: { aktion: 'api.geaendert', objektId: angelegt.id },
+      select: { details: true },
+    })
+    expect(protokoll).not.toBeNull()
+    expect(JSON.stringify(protokoll?.details)).toContain('api')
+  })
+
+  test('lehnt eine Aufgabe ohne Titel ab', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'erfassen')
+    const antwort = await request.post('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+      data: { titel: '   ' },
+    })
+    expect(antwort.status()).toBe(400)
+  })
+
+  test('setzt weder Status noch Bereich aus der Anfrage', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'erfassen')
+    const bereich = await db.bereich.findFirst({ select: { id: true } })
+
+    const antwort = await request.post('/api/v1/aufgaben', {
+      headers: { Authorization: `Bearer ${token}` },
+      data: {
+        titel: `${PRAEFIX} Einordnung bleibt hier`,
+        status: 'ERLEDIGT',
+        bereichId: bereich?.id ?? null,
+      },
+    })
+    expect(antwort.status()).toBe(201)
+
+    const angelegt = await db.aufgabe.findFirstOrThrow({
+      where: { titel: `${PRAEFIX} Einordnung bleibt hier` },
+      select: { status: true, bereichId: true },
+    })
+    // Was von außen kommt, landet offen in der Inbox.
+    expect(angelegt.status).toBe('OFFEN')
+    expect(angelegt.bereichId).toBeNull()
+  })
+})

e2e/aufgaben.spec.ts

@@ -1,6 +1,7 @@
 import { PrismaPg } from '@prisma/adapter-pg'
-import { expect, test, type Page } from '@playwright/test'
+import { expect, test } from '@playwright/test'
 import { PrismaClient } from '../src/generated/prisma/client.js'
+import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
 
 /**
  * Der Weg, der in M2 wirklich zählt: erfassen, einsortieren, abhaken.
@@ -9,16 +10,13 @@ import { PrismaClient } from '../src/generated/prisma/client.js'
  * damit die Entwicklungsdatenbank hinterher aussieht wie vorher.
  */
 
-const EMAIL = process.env.ADMIN_EMAIL ?? ''
-const PASSWORT = process.env.ADMIN_PASSWORT ?? ''
 const PRAEFIX = `E2E-${Date.now()}`
 
-const verbindung = process.env.DATABASE_URL ?? ''
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
-const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: verbindung }) })
 
 test.describe('Aufgaben', () => {
   test.skip(
-    !EMAIL || !PASSWORT || !verbindung,
+    !EMAIL || !PASSWORT || !VERBINDUNG,
     'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
   )
 
@@ -29,14 +27,6 @@ test.describe('Aufgaben', () => {
     await db.$disconnect()
   })
 
-  async function anmelden(seite: Page): Promise<void> {
-    await seite.goto('/anmelden')
-    await seite.getByLabel('E-Mail-Adresse').fill(EMAIL)
-    await seite.getByLabel('Passwort').fill(PASSWORT)
-    await seite.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
-    await expect(seite.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
-  }
-
   test('erfasst schnell, sortiert ein und hakt ab', async ({ page }) => {
     const titel = `${PRAEFIX} Angebot schreiben`
     await anmelden(page)
@@ -62,6 +52,10 @@ test.describe('Aufgaben', () => {
     await zeile.getByLabel('Einsortieren nach').selectOption(bereich!.id)
     await expect(page.getByText(`liegt jetzt in ${bereich!.name}`)).toBeVisible()
 
+    // Die Meldung kommt, bevor das Neuladen der Liste fertig ist. Wer jetzt
+    // navigiert, bricht es ab — und Chromium meldet ERR_ABORTED.
+    await page.waitForLoadState('networkidle')
+
     // Aus der Inbox ist sie damit verschwunden.
     await page.goto('/inbox')
     await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)

e2e/benachrichtigungen.spec.ts

@@ -0,0 +1,91 @@
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
+
+/**
+ * Was in M5 wirklich zählt: die Einstellung hält, und ohne eingeschalteten
+ * Weg geht nichts hinaus.
+ *
+ * Der Test rührt nur an der Einstellung des Testkontos und stellt sie am
+ * Ende wieder her.
+ */
+
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+
+test.describe('Benachrichtigungen', () => {
+  test.skip(
+    !EMAIL || !PASSWORT || !VERBINDUNG,
+    'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
+  )
+
+  test.afterAll(async () => {
+    const benutzer = await db.benutzer.findUnique({
+      where: { email: EMAIL },
+      select: { id: true },
+    })
+    if (benutzer) {
+      await db.benachrichtigungseinstellung.deleteMany({
+        where: { benutzerId: benutzer.id },
+      })
+      await db.meldungsnachweis.deleteMany({ where: { benutzerId: benutzer.id } })
+    }
+    await db.auditEintrag.deleteMany({
+      where: { aktion: { startsWith: 'benachrichtigung.' } },
+    })
+    await db.$disconnect()
+  })
+
+  test('speichert die Einstellung und hält sie', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen')
+
+    const karte = page.locator('[data-bild="benachrichtigungen"]')
+    await expect(karte).toBeVisible()
+
+    // --- Ab Werk ist nichts eingeschaltet ---------------------------------
+    await expect(karte.locator('input[name="perPush"]')).not.toBeChecked()
+    await expect(karte.locator('input[name="perMail"]')).not.toBeChecked()
+
+    // --- Ohne Weg keine Probe ---------------------------------------------
+    await karte.getByRole('button', { name: 'Probe schicken' }).click()
+    await expect(page.getByText('Erst einen Weg einschalten')).toBeVisible()
+
+    // --- Ändern und speichern ---------------------------------------------
+    await karte.locator('input[name="perMail"]').check()
+    await karte.locator('input[value="zeitblock"]').check()
+    await karte.getByLabel('Tagesüberblick um').fill('06:30')
+    await karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)').fill('20')
+    await karte.getByLabel('Am Wochenende gar nichts melden').check()
+    await karte.getByRole('button', { name: 'Speichern' }).click()
+    await expect(page.getByText('Einstellungen gespeichert.')).toBeVisible()
+
+    // --- Nach dem Neuladen steht alles noch da ----------------------------
+    await page.reload()
+    await expect(karte.locator('input[name="perMail"]')).toBeChecked()
+    await expect(karte.locator('input[value="zeitblock"]')).toBeChecked()
+    await expect(karte.getByLabel('Tagesüberblick um')).toHaveValue('06:30')
+    await expect(karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)')).toHaveValue(
+      '20',
+    )
+    await expect(karte.getByLabel('Am Wochenende gar nichts melden')).toBeChecked()
+  })
+
+  test('weist eine unsinnige Vorlaufzeit zurück', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/einstellungen')
+
+    const karte = page.locator('[data-bild="benachrichtigungen"]')
+    const vorlauf = karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)')
+    // Das Zahlenfeld begrenzt auf 120; der Server darf sich darauf nicht
+    // verlassen, deshalb kommt der Wert an der Oberfläche vorbei.
+    await vorlauf.evaluate((feld: HTMLInputElement) => {
+      feld.max = '600'
+      feld.value = '300'
+    })
+    await karte.getByRole('button', { name: 'Speichern' }).click()
+
+    await expect(page.getByText('Bitte die markierten Felder prüfen.')).toBeVisible()
+    await expect(karte.getByText('Mehr als zwei Stunden Vorlauf')).toBeVisible()
+  })
+})

e2e/hilfe.ts

@@ -0,0 +1,45 @@
+import { expect, type Page } from '@playwright/test'
+
+/** Gemeinsames für alle E2E-Tests. */
+
+export const EMAIL = process.env.ADMIN_EMAIL ?? ''
+export const PASSWORT = process.env.ADMIN_PASSWORT ?? ''
+export const VERBINDUNG = process.env.DATABASE_URL ?? ''
+
+/**
+ * Geheimnis fuer den Spiegel im Test.
+ *
+ * Der Testserver bekommt denselben Wert ueber playwright.config.ts, sonst
+ * liesse sich die Tuer gar nicht pruefen — und eine Pruefung, die immer
+ * uebersprungen wird, prueft nichts.
+ */
+export const SPIEGEL_GEHEIMNIS =
+  process.env.SPIEGEL_GEHEIMNIS ?? 'e2e-spiegel-geheimnis-nur-lokal'
+
+/**
+ * Meldet das Testkonto mit Passwort an.
+ *
+ * Der Knopf gehört zu einem Client-Formular. Ein Klick, der vor der
+ * Hydratation ankommt, verpufft folgenlos — die Seite bleibt einfach stehen.
+ * Deshalb wird so lange nachgefasst, bis die Startseite da ist; hat der erste
+ * Klick schon gewirkt, wird nicht noch einmal geklickt.
+ */
+export async function anmelden(
+  seite: Page,
+  email: string = EMAIL,
+  passwort: string = PASSWORT,
+): Promise<void> {
+  await seite.goto('/anmelden')
+  await seite.getByLabel('E-Mail-Adresse').fill(email)
+  await seite.getByLabel('Passwort').fill(passwort)
+
+  const knopf = seite.getByRole('button', { name: 'Mit Passwort anmelden' })
+  const begruessung = seite.getByRole('heading', { name: /Guten Tag/ })
+
+  await expect(async () => {
+    if (new URL(seite.url()).pathname === '/anmelden') {
+      await knopf.click({ timeout: 5_000 })
+    }
+    await expect(begruessung).toBeVisible({ timeout: 5_000 })
+  }).toPass({ timeout: 45_000 })
+}

e2e/mcp.spec.ts

@@ -0,0 +1,173 @@
+import { createHash, randomBytes } from 'node:crypto'
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test, type APIRequestContext } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+import { EMAIL, VERBINDUNG } from './hilfe'
+
+/**
+ * Der MCP-Endpunkt.
+ *
+ * Er spricht JSON-RPC, also wird hier auch JSON-RPC gesprochen — kein
+ * Nachbau der Bibliothek, sondern echte Aufrufe gegen den laufenden Server.
+ *
+ * Der wichtigste Punkt: Die Werkzeugliste hängt an den Rechten des Tokens.
+ * Was ein Token nicht darf, soll ein Modell gar nicht erst sehen.
+ */
+
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+const PRAEFIX = `E2E-MCP-${Date.now()}`
+
+async function tokenBauen(benutzerId: string, rechte: string): Promise<string> {
+  const praefix = randomBytes(4).toString('hex')
+  const klartext = `planer_${praefix}_${randomBytes(32).toString('base64url')}`
+  await db.apiToken.create({
+    data: {
+      benutzerId,
+      name: `${PRAEFIX} ${rechte}`,
+      praefix,
+      hash: createHash('sha256').update(klartext, 'utf8').digest('hex'),
+      rechte,
+    },
+  })
+  return klartext
+}
+
+type Antwort = {
+  result?: { tools?: { name: string }[]; content?: { text: string }[]; isError?: boolean }
+  error?: { message: string }
+}
+
+/** Ein JSON-RPC-Aufruf gegen den Endpunkt. */
+async function rufen(
+  request: APIRequestContext,
+  token: string | null,
+  methode: string,
+  parameter: Record<string, unknown> = {},
+) {
+  const antwort = await request.post('/api/mcp', {
+    headers: {
+      'Content-Type': 'application/json',
+      // Der Streamable-HTTP-Transport besteht auf beidem.
+      Accept: 'application/json, text/event-stream',
+      ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    },
+    data: { jsonrpc: '2.0', id: 1, method: methode, params: parameter },
+  })
+  return antwort
+}
+
+/** Der Handschlag, den jede MCP-Verbindung zuerst führt. */
+const HANDSCHLAG = {
+  protocolVersion: '2025-06-18',
+  capabilities: {},
+  clientInfo: { name: 'e2e', version: '1.0.0' },
+}
+
+test.describe('MCP', () => {
+  test.skip(!EMAIL || !VERBINDUNG, 'Ohne ADMIN_EMAIL und DATABASE_URL kein Testkonto.')
+
+  let benutzerId = ''
+
+  test.beforeAll(async () => {
+    const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
+    benutzerId = benutzer.id
+  })
+
+  test.afterAll(async () => {
+    await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
+    await db.apiToken.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'mcp.' } } })
+    await db.$disconnect()
+  })
+
+  test('weist eine Anfrage ohne Token ab', async ({ request }) => {
+    const antwort = await rufen(request, null, 'initialize', HANDSCHLAG)
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('führt den Handschlag mit gültigem Token', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen')
+    const antwort = await rufen(request, token, 'initialize', HANDSCHLAG)
+
+    expect(antwort.ok()).toBe(true)
+    const inhalt = (await antwort.json()) as {
+      result?: { serverInfo?: { name: string } }
+    }
+    expect(inhalt.result?.serverInfo?.name).toBe('planer')
+  })
+
+  test('zeigt nur die Werkzeuge, die der Token erlaubt', async ({ request }) => {
+    const nurLesen = await tokenBauen(benutzerId, 'lesen')
+    await rufen(request, nurLesen, 'initialize', HANDSCHLAG)
+
+    const antwort = await rufen(request, nurLesen, 'tools/list')
+    const namen = (((await antwort.json()) as Antwort).result?.tools ?? []).map(
+      (w) => w.name,
+    )
+
+    expect(namen).toContain('aufgaben_suchen')
+    expect(namen).toContain('woche_ansehen')
+    // Erfassen und Schreiben fehlen dem Token – und damit der Liste.
+    expect(namen).not.toContain('aufgabe_anlegen')
+    expect(namen).not.toContain('aufgabe_abhaken')
+    expect(namen).not.toContain('zeitblock_anlegen')
+  })
+
+  test('zeigt einem Erfassen-Token nur das Anlegen', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'erfassen')
+    await rufen(request, token, 'initialize', HANDSCHLAG)
+
+    const antwort = await rufen(request, token, 'tools/list')
+    const namen = (((await antwort.json()) as Antwort).result?.tools ?? []).map(
+      (w) => w.name,
+    )
+
+    expect(namen).toEqual(['aufgabe_anlegen'])
+  })
+
+  test('legt eine Aufgabe an und protokolliert das', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'erfassen')
+    await rufen(request, token, 'initialize', HANDSCHLAG)
+
+    const titel = `${PRAEFIX} Angebot schreiben`
+    const antwort = await rufen(request, token, 'tools/call', {
+      name: 'aufgabe_anlegen',
+      arguments: { titel, aufwandMinuten: 45 },
+    })
+
+    expect(antwort.ok()).toBe(true)
+    const inhalt = (await antwort.json()) as Antwort
+    expect(inhalt.result?.content?.[0]?.text).toContain('Angelegt')
+
+    const aufgabe = await db.aufgabe.findFirstOrThrow({
+      where: { titel },
+      select: { quelle: true, bereichId: true, status: true, aufwandMinuten: true },
+    })
+    expect(aufgabe.quelle).toBe('MCP')
+    expect(aufgabe.aufwandMinuten).toBe(45)
+    // Wie über die Schnittstelle: offen und in der Inbox.
+    expect(aufgabe.status).toBe('OFFEN')
+    expect(aufgabe.bereichId).toBeNull()
+
+    const eintrag = await db.auditEintrag.findFirst({
+      where: { aktion: 'mcp.erfasst' },
+      select: { details: true },
+    })
+    expect(JSON.stringify(eintrag?.details)).toContain('mcp')
+  })
+
+  test('lässt ein Werkzeug ohne Recht gar nicht erst aufrufen', async ({ request }) => {
+    const token = await tokenBauen(benutzerId, 'lesen')
+    await rufen(request, token, 'initialize', HANDSCHLAG)
+
+    const antwort = await rufen(request, token, 'tools/call', {
+      name: 'aufgabe_anlegen',
+      arguments: { titel: `${PRAEFIX} darf nicht` },
+    })
+
+    const inhalt = (await antwort.json()) as Antwort
+    // Unbekanntes Werkzeug: Es ist für diesen Token nicht registriert.
+    expect(inhalt.error ?? inhalt.result?.isError).toBeTruthy()
+    expect(await db.aufgabe.count({ where: { titel: `${PRAEFIX} darf nicht` } })).toBe(0)
+  })
+})

e2e/rollen.spec.ts

@@ -1,7 +1,8 @@
 import { PrismaPg } from '@prisma/adapter-pg'
-import { expect, test, type Page } from '@playwright/test'
+import { expect, test } from '@playwright/test'
 import bcrypt from 'bcryptjs'
 import { PrismaClient } from '../src/generated/prisma/client.js'
+import { anmelden as anmeldenMit } from './hilfe'
 
 /**
  * Prüft, dass die Rollentrennung serverseitig hält.
@@ -38,23 +39,15 @@ test.describe('Rollentrennung', () => {
     await db.$disconnect()
   })
 
-  async function anmelden(seite: Page): Promise<void> {
-    await seite.goto('/anmelden')
-    await seite.getByLabel('E-Mail-Adresse').fill(EMAIL)
-    await seite.getByLabel('Passwort').fill(PASSWORT)
-    await seite.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
-    await expect(seite.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
-  }
-
   test('zeigt einem Benutzer den Menüpunkt Protokoll gar nicht', async ({ page }) => {
-    await anmelden(page)
+    await anmeldenMit(page, EMAIL, PASSWORT)
     await expect(page.getByRole('link', { name: 'Protokoll' })).toHaveCount(0)
   })
 
   test('lässt einen Benutzer auch beim direkten Aufruf nicht ins Protokoll', async ({
     page,
   }) => {
-    await anmelden(page)
+    await anmeldenMit(page, EMAIL, PASSWORT)
     await page.goto('/verwaltung/protokoll')
 
     await expect(page).toHaveURL(/\/keine-berechtigung/)
@@ -64,7 +57,7 @@ test.describe('Rollentrennung', () => {
   })
 
   test('zeigt einem Benutzer die Bereiche, aber ohne Formulare', async ({ page }) => {
-    await anmelden(page)
+    await anmeldenMit(page, EMAIL, PASSWORT)
     await page.goto('/bereiche')
 
     await expect(page.getByRole('heading', { name: 'Bereiche' })).toBeVisible()

e2e/spiegel.spec.ts

@@ -0,0 +1,138 @@
+import { createHmac } from 'node:crypto'
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+import { SPIEGEL_GEHEIMNIS, VERBINDUNG } from './hilfe'
+
+/**
+ * Der Eingang des Spiegels.
+ *
+ * Hier meldet sich kein Mensch an — die Gegenstelle weist sich allein über
+ * eine Signatur aus. Deshalb wird hier nicht die Oberfläche geprüft, sondern
+ * genau diese Tür: Sie muss zu sein, wenn irgendetwas nicht stimmt.
+ */
+
+const GEHEIMNIS = SPIEGEL_GEHEIMNIS
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+
+const PRAEFIX = `E2E-S-${Date.now()}`
+
+function signieren(koerper: string, geheimnis = GEHEIMNIS): string {
+  return createHmac('sha256', geheimnis).update(koerper).digest('hex')
+}
+
+function sendung(teile: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    gesendetAm: new Date().toISOString(),
+    belegungen: [],
+    aufgaben: [],
+    ...teile,
+  })
+}
+
+test.describe('Spiegel', () => {
+  test.afterAll(async () => {
+    await db.spiegelbelegung.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } })
+    await db.aufgabe.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: 'spiegel.empfangen' } })
+    await db.$disconnect()
+  })
+
+  test('weist eine Sendung ohne Signatur ab', async ({ request }) => {
+    const antwort = await request.post('/api/spiegel', {
+      headers: { 'Content-Type': 'application/json' },
+      data: sendung(),
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('weist eine falsch signierte Sendung ab', async ({ request }) => {
+    const koerper = sendung()
+    const antwort = await request.post('/api/spiegel', {
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Planer-Signatur': signieren(koerper, 'das-ist-nicht-das-geheimnis'),
+      },
+      data: koerper,
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('weist eine Sendung ab, die zu lange unterwegs war', async ({ request }) => {
+    test.skip(!GEHEIMNIS, 'Ohne SPIEGEL_GEHEIMNIS ist der Eingang ohnehin zu.')
+
+    // Eine Stunde alt: richtig signiert, trotzdem wertlos. Sonst ließe sich
+    // ein abgefangenes Paket beliebig oft erneut einspielen.
+    const koerper = sendung({
+      gesendetAm: new Date(Date.now() - 3_600_000).toISOString(),
+    })
+    const antwort = await request.post('/api/spiegel', {
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Planer-Signatur': signieren(koerper),
+      },
+      data: koerper,
+    })
+    expect(antwort.status()).toBe(401)
+  })
+
+  test('nimmt eine gültige Sendung an und räumt Veraltetes weg', async ({ request }) => {
+    test.skip(
+      !GEHEIMNIS,
+      'Ohne SPIEGEL_GEHEIMNIS auf dem Testserver lässt sich das nicht prüfen.',
+    )
+
+    const beginn = new Date(Date.now() + 86_400_000)
+    const ende = new Date(beginn.getTime() + 3_600_000)
+
+    const erste = sendung({
+      belegungen: [
+        {
+          ref: `${PRAEFIX}-a`,
+          beginn: beginn.toISOString(),
+          ende: ende.toISOString(),
+        },
+      ],
+      aufgaben: [{ ref: `${PRAEFIX}-1`, titel: `${PRAEFIX} Angebot schreiben` }],
+    })
+
+    const antwort = await request.post('/api/spiegel', {
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Planer-Signatur': signieren(erste),
+      },
+      data: erste,
+    })
+    expect(antwort.ok()).toBe(true)
+
+    expect(await db.spiegelbelegung.count({ where: { quelleRef: `${PRAEFIX}-a` } })).toBe(
+      1,
+    )
+    const aufgabe = await db.aufgabe.findFirst({
+      where: { quelle: 'SPIEGEL', quelleRef: `${PRAEFIX}-1` },
+      select: { titel: true },
+    })
+    expect(aufgabe?.titel).toBe(`${PRAEFIX} Angebot schreiben`)
+
+    // Zweite Runde ohne die Belegung: Sie wurde drüben ausgeplant und muss
+    // auch hier verschwinden — sonst stünde für immer eine Sperre, die es
+    // längst nicht mehr gibt.
+    const zweite = sendung({ aufgaben: [] })
+    const nachher = await request.post('/api/spiegel', {
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Planer-Signatur': signieren(zweite),
+      },
+      data: zweite,
+    })
+    expect(nachher.ok()).toBe(true)
+    expect(await db.spiegelbelegung.count({ where: { quelleRef: `${PRAEFIX}-a` } })).toBe(
+      0,
+    )
+
+    // Die Aufgabe bleibt: Sie ist Planung, keine Sperre.
+    expect(
+      await db.aufgabe.count({ where: { quelle: 'SPIEGEL', quelleRef: `${PRAEFIX}-1` } }),
+    ).toBe(1)
+  })
+})

e2e/woche.spec.ts

@@ -0,0 +1,116 @@
+import { PrismaPg } from '@prisma/adapter-pg'
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '../src/generated/prisma/client.js'
+import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
+
+/**
+ * Wochenansicht und Zeitblöcke.
+ *
+ * Ohne echtes Kalenderkonto lässt sich der Schreibweg zum Anbieter nicht
+ * prüfen — er scheitert dann und der Zeitblock trägt einen Fehler. Genau das
+ * ist aber selbst prüfenswert: Die Planung muss auch dann überleben, wenn der
+ * Kalender nicht erreichbar ist.
+ */
+
+const PRAEFIX = `E2E-W-${Date.now()}`
+
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+
+test.describe('Woche', () => {
+  test.skip(
+    !EMAIL || !PASSWORT || !VERBINDUNG,
+    'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
+  )
+
+  test.afterAll(async () => {
+    await db.zeitblock.deleteMany({
+      where: { aufgabe: { titel: { startsWith: PRAEFIX } } },
+    })
+    await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
+    await db.kalenderkonto.deleteMany({ where: { extKontoId: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'zeitblock.' } } })
+    await db.$disconnect()
+  })
+
+  test('weist ohne verbundenen Kalender darauf hin', async ({ page }) => {
+    await db.kalenderkonto.deleteMany({})
+    await anmelden(page)
+    await page.goto('/woche')
+
+    await expect(page.getByRole('heading', { name: 'Woche' })).toBeVisible()
+    await expect(page.getByText('Noch kein Kalender verbunden')).toBeVisible()
+    await expect(
+      page.getByText('Ohne verbundenen Kalender lässt sich nichts'),
+    ).toBeVisible()
+  })
+
+  test('zeigt einen Zeitblock im Raster und plant ihn wieder aus', async ({ page }) => {
+    const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
+
+    // Ein Kalenderkonto ohne gültige Tokens: die Ansicht funktioniert, der
+    // Schreibweg zum Anbieter nicht.
+    const konto = await db.kalenderkonto.create({
+      data: {
+        benutzerId: benutzer.id,
+        anbieter: 'GRAPH',
+        anzeigename: `${PRAEFIX} Testkalender`,
+        extKontoId: `${PRAEFIX}-konto`,
+      },
+    })
+
+    const aufgabe = await db.aufgabe.create({
+      data: { titel: `${PRAEFIX} Angebot schreiben`, aufwandMinuten: 60 },
+    })
+
+    // Zeitblock auf 10:00 Uhr des Montags dieser Woche legen.
+    const jetzt = new Date()
+    const montag = new Date(jetzt)
+    montag.setUTCHours(0, 0, 0, 0)
+    montag.setUTCDate(montag.getUTCDate() - ((montag.getUTCDay() + 6) % 7))
+    const beginn = new Date(montag.getTime() + 10 * 60 * 60 * 1000)
+
+    await db.zeitblock.create({
+      data: {
+        aufgabeId: aufgabe.id,
+        kalenderkontoId: konto.id,
+        beginn,
+        ende: new Date(beginn.getTime() + 60 * 60 * 1000),
+      },
+    })
+    await db.aufgabe.update({
+      where: { id: aufgabe.id },
+      data: { status: 'GEPLANT' },
+    })
+
+    await anmelden(page)
+    await page.goto('/woche')
+
+    const block = page.getByTitle(new RegExp(`${PRAEFIX} Angebot schreiben`))
+    await expect(block).toBeVisible()
+
+    // Ausplanen: der Block verschwindet, die Aufgabe fällt zurück auf offen.
+    await block.getByRole('button', { name: 'Ausplanen' }).click()
+    await expect(page.getByText('ausgeplant')).toBeVisible()
+
+    await expect
+      .poll(async () => db.zeitblock.count({ where: { aufgabeId: aufgabe.id } }))
+      .toBe(0)
+
+    const danach = await db.aufgabe.findUniqueOrThrow({ where: { id: aufgabe.id } })
+    expect(danach.status).toBe('OFFEN')
+  })
+
+  test('lässt sich durch die Wochen blättern', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/woche')
+
+    await page.getByRole('link', { name: 'Weiter' }).click()
+    await expect(page).toHaveURL(/versatz=1/)
+
+    await page.getByRole('link', { name: 'Zurück' }).click()
+    await expect(page).toHaveURL(/versatz=0/)
+
+    await page.getByRole('link', { name: 'Diese Woche' }).click()
+    await expect(page).toHaveURL(/\/woche$/)
+  })
+})

eslint.config.mjs

@@ -16,6 +16,8 @@ export default tseslint.config(
       // Vom Generator erzeugt, nicht von Hand gepflegt.
       'src/generated/**',
       'next-env.d.ts',
+      // Service Worker: laeuft im Browser, nicht in unserer Werkzeugkette.
+      'public/sw.js',
     ],
   },
   ...naechstesWebVitals,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "planer",
-  "version": "0.3.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Aufgaben, Ideen, Projekte und Zeitblöcke mit Anbindung an Microsoft 365 und Google Kalender",
   "type": "module",
@@ -40,6 +40,9 @@
   "dependencies": {
     "@auth/prisma-adapter": "2.11.3",
     "@date-fns/tz": "1.5.0",
+    "@dnd-kit/core": "6.3.1",
+    "@dnd-kit/utilities": "3.2.2",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "@prisma/adapter-pg": "7.10.0",
     "@prisma/client": "7.10.0",
     "@radix-ui/react-avatar": "1.2.6",
@@ -66,6 +69,7 @@
     "server-only": "0.0.1",
     "sonner": "2.0.8",
     "tailwind-merge": "3.6.0",
+    "web-push": "3.6.7",
     "zod": "4.6.1"
   },
   "devDependencies": {
@@ -77,6 +81,7 @@
     "@types/pg": "8.23.1",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
+    "@types/web-push": "3.6.4",
     "@vitejs/plugin-react": "6.1.1",
     "@vitest/coverage-v8": "5.0.0",
     "dotenv": "17.4.2",

playwright.config.ts

@@ -1,5 +1,6 @@
 import { defineConfig, devices } from '@playwright/test'
 import 'dotenv/config'
+import { SPIEGEL_GEHEIMNIS } from './e2e/hilfe'
 
 const PORT = Number(process.env.E2E_PORT ?? 3100)
 const BASIS = `http://127.0.0.1:${PORT}`
@@ -41,6 +42,8 @@ export default defineConfig({
       APP_URL: BASIS,
       WEBAUTHN_ORIGIN: BASIS,
       WEBAUTHN_RP_ID: '127.0.0.1',
+      // Ohne Geheimnis waere der Spiegel-Eingang zu und sein Test sinnlos.
+      SPIEGEL_GEHEIMNIS,
     },
   },
 })

prisma/demo-seed.ts

@@ -373,6 +373,37 @@ async function main(): Promise<void> {
     },
   })
 
+  // --- Zeitblöcke: eingeplante Aufgaben im Kalender -------------------------
+  await db.zeitblock.deleteMany({})
+  const einzuplanen = await db.aufgabe.findMany({
+    where: {
+      titel: {
+        in: [
+          'Wochenbericht an die Geschäftsführung',
+          'Angebot Heizungstausch nachfassen',
+        ],
+      },
+    },
+    select: { id: true, titel: true, aufwandMinuten: true },
+  })
+
+  let blockStunde = 15
+  for (const aufgabe of einzuplanen) {
+    const beginn = new Date(Date.UTC(2026, 2, 17, blockStunde - 1, 0))
+    await db.zeitblock.create({
+      data: {
+        aufgabeId: aufgabe.id,
+        kalenderkontoId: kalenderkonto.id,
+        beginn,
+        ende: new Date(beginn.getTime() + (aufgabe.aufwandMinuten ?? 60) * 60_000),
+        extId: `demo-block-${aufgabe.id}`,
+        hash: 'demo',
+      },
+    })
+    await db.aufgabe.update({ where: { id: aufgabe.id }, data: { status: 'GEPLANT' } })
+    blockStunde += 2
+  }
+
   // Eine Aufgabe, die von außen kam – zeigt die Herkunft in der Liste.
   await db.aufgabe.create({
     data: {
@@ -387,6 +418,115 @@ async function main(): Promise<void> {
     },
   })
 
+  // --- Benachrichtigungen ---------------------------------------------------
+  // Für die Bilder eingeschaltet. Eine leere Karte zeigt nichts von dem,
+  // was das Kapitel erklärt.
+  await db.benachrichtigungseinstellung.upsert({
+    where: { benutzerId: benutzer.id },
+    update: {},
+    create: {
+      benutzerId: benutzer.id,
+      anlaesse: 'tagesueberblick,faelligkeit,zeitblock',
+      perPush: true,
+      perMail: true,
+      perTelegram: true,
+      ueberblickUm: 7 * 60,
+      ruheVon: 20 * 60,
+      ruheBis: 7 * 60,
+      ruheAmWochenende: false,
+      zeitblockVorlaufMinuten: 10,
+    },
+  })
+
+  // Kein Push-Gerät in den Demo-Daten: Seine Schlüssel liegen
+  // verschlüsselt, und der Versand entfernt jedes Gerät, dessen Schlüssel er
+  // nicht lesen kann. Ein erfundener Eintrag verschwände beim ersten Lauf
+  // wieder — die Bilder zeigen deshalb den Zustand vor der ersten Anmeldung.
+
+  // --- Integrationen --------------------------------------------------------
+  await db.integrationszustand.deleteMany({})
+  await db.integrationszustand.create({
+    data: {
+      quelle: 'TELEGRAM',
+      merker: '4711',
+      letzterLauf: new Date(Date.UTC(2026, 2, 17, 8, 18)),
+      letzterErfolg: new Date(Date.UTC(2026, 2, 17, 8, 18)),
+    },
+  })
+  await db.integrationszustand.create({
+    data: {
+      quelle: 'SPIEGEL',
+      letzterLauf: new Date(Date.UTC(2026, 2, 17, 8, 15)),
+      letzterErfolg: new Date(Date.UTC(2026, 2, 17, 8, 15)),
+    },
+  })
+
+  await db.telegramChat.deleteMany({})
+  await db.telegramChat.create({
+    data: {
+      // Erfunden. Der Bot ist ohnehin abgeschaltet, solange DEMO_MODUS gilt.
+      chatId: BigInt(147258369),
+      benutzerId: benutzer.id,
+      bezeichnung: 'Martina',
+      erstelltAm: new Date(Date.UTC(2026, 1, 3, 8, 25)),
+      zuletztBenutzt: new Date(Date.UTC(2026, 2, 17, 6, 40)),
+    },
+  })
+
+  // Dienstliche Belegung, wie sie aus der Firma hereinkaeme: ohne Titel.
+  await db.spiegelbelegung.deleteMany({})
+  for (const [tag, stunde, dauer] of [
+    [17, 9, 2],
+    [18, 13, 3],
+    [19, 8, 1],
+  ] as const) {
+    await db.spiegelbelegung.create({
+      data: {
+        quelleRef: `demo-spiegel-${tag}-${stunde}`,
+        beginn: new Date(Date.UTC(2026, 2, tag, stunde - 1, 0)),
+        ende: new Date(Date.UTC(2026, 2, tag, stunde - 1 + dauer, 0)),
+      },
+    })
+  }
+
+  // --- API-Tokens -----------------------------------------------------------
+  // Erfundene Hashes: Mit diesen Zeilen laesst sich nichts aufrufen, sie
+  // zeigen nur, wie die Liste aussieht.
+  await db.apiToken.deleteMany({})
+  await db.apiToken.create({
+    data: {
+      benutzerId: benutzer.id,
+      name: 'Wartungsplaner-Import',
+      praefix: 'k7m2xq4b',
+      hash: 'demo-1',
+      rechte: 'erfassen',
+      erstelltAm: new Date(Date.UTC(2026, 0, 14, 9, 30)),
+      letzteNutzung: new Date(Date.UTC(2026, 2, 17, 5, 12)),
+    },
+  })
+  await db.apiToken.create({
+    data: {
+      benutzerId: benutzer.id,
+      name: 'Auswertung Homelab',
+      praefix: 'r3wp9dt4',
+      hash: 'demo-2',
+      rechte: 'lesen',
+      gueltigBis: new Date(Date.UTC(2026, 8, 30, 22, 0)),
+      erstelltAm: new Date(Date.UTC(2026, 1, 2, 18, 45)),
+    },
+  })
+  await db.apiToken.create({
+    data: {
+      benutzerId: benutzer.id,
+      name: 'Altes Skript',
+      praefix: 'z8n4vt6c',
+      hash: 'demo-3',
+      rechte: 'lesen,schreiben',
+      erstelltAm: new Date(Date.UTC(2025, 10, 3, 11, 0)),
+      widerrufenAm: new Date(Date.UTC(2026, 1, 20, 8, 15)),
+    },
+  })
+
   console.log(`Demo-Daten stehen bereit. Anmeldung: ${DEMO_EMAIL}`)
 }
 

prisma/migrations/20260910184542_zeitbloecke/migration.sql

@@ -0,0 +1,31 @@
+-- CreateTable
+CREATE TABLE "zeitblock" (
+    "id" TEXT NOT NULL,
+    "aufgabeId" TEXT NOT NULL,
+    "kalenderkontoId" TEXT NOT NULL,
+    "beginn" TIMESTAMP(3) NOT NULL,
+    "ende" TIMESTAMP(3) NOT NULL,
+    "extId" TEXT,
+    "etag" TEXT,
+    "hash" TEXT,
+    "letzterFehler" TEXT,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "zeitblock_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "zeitblock_beginn_ende_idx" ON "zeitblock"("beginn", "ende");
+
+-- CreateIndex
+CREATE INDEX "zeitblock_aufgabeId_idx" ON "zeitblock"("aufgabeId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "zeitblock_kalenderkontoId_extId_key" ON "zeitblock"("kalenderkontoId", "extId");
+
+-- AddForeignKey
+ALTER TABLE "zeitblock" ADD CONSTRAINT "zeitblock_aufgabeId_fkey" FOREIGN KEY ("aufgabeId") REFERENCES "aufgabe"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "zeitblock" ADD CONSTRAINT "zeitblock_kalenderkontoId_fkey" FOREIGN KEY ("kalenderkontoId") REFERENCES "kalenderkonto"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20260911044207_benachrichtigungen/migration.sql

@@ -0,0 +1,66 @@
+-- CreateTable
+CREATE TABLE "benachrichtigungseinstellung" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "anlaesse" TEXT NOT NULL DEFAULT 'tagesueberblick,faelligkeit',
+    "perPush" BOOLEAN NOT NULL DEFAULT false,
+    "perMail" BOOLEAN NOT NULL DEFAULT false,
+    "ueberblickUm" INTEGER NOT NULL DEFAULT 420,
+    "ruheVon" INTEGER NOT NULL DEFAULT 1200,
+    "ruheBis" INTEGER NOT NULL DEFAULT 420,
+    "ruheAmWochenende" BOOLEAN NOT NULL DEFAULT false,
+    "zeitblockVorlaufMinuten" INTEGER NOT NULL DEFAULT 10,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "benachrichtigungseinstellung_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "push_geraet" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "endpunkt" TEXT NOT NULL,
+    "p256dh" TEXT NOT NULL,
+    "auth" TEXT NOT NULL,
+    "bezeichnung" TEXT,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztBenutzt" TIMESTAMP(3),
+    "fehlversuche" INTEGER NOT NULL DEFAULT 0,
+
+    CONSTRAINT "push_geraet_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "meldungsnachweis" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "schluessel" TEXT NOT NULL,
+    "gesendetAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "meldungsnachweis_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "benachrichtigungseinstellung_benutzerId_key" ON "benachrichtigungseinstellung"("benutzerId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "push_geraet_endpunkt_key" ON "push_geraet"("endpunkt");
+
+-- CreateIndex
+CREATE INDEX "push_geraet_benutzerId_idx" ON "push_geraet"("benutzerId");
+
+-- CreateIndex
+CREATE INDEX "meldungsnachweis_gesendetAm_idx" ON "meldungsnachweis"("gesendetAm");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "meldungsnachweis_benutzerId_schluessel_key" ON "meldungsnachweis"("benutzerId", "schluessel");
+
+-- AddForeignKey
+ALTER TABLE "benachrichtigungseinstellung" ADD CONSTRAINT "benachrichtigungseinstellung_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "push_geraet" ADD CONSTRAINT "push_geraet_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "meldungsnachweis" ADD CONSTRAINT "meldungsnachweis_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20260911045857_abgleich_fehlversuche/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "kalenderkonto" ADD COLUMN     "fehlversuche" INTEGER NOT NULL DEFAULT 0;

prisma/migrations/20260911185221_integrationen/migration.sql

@@ -0,0 +1,62 @@
+-- AlterTable
+ALTER TABLE "aufgabe" ADD COLUMN     "spiegeln" BOOLEAN NOT NULL DEFAULT false;
+
+-- AlterTable
+ALTER TABLE "benachrichtigungseinstellung" ADD COLUMN     "perTelegram" BOOLEAN NOT NULL DEFAULT false;
+
+-- CreateTable
+CREATE TABLE "integrationszustand" (
+    "id" TEXT NOT NULL,
+    "quelle" "Quelle" NOT NULL,
+    "merker" TEXT,
+    "letzterLauf" TIMESTAMP(3),
+    "letzterErfolg" TIMESTAMP(3),
+    "letzterFehler" TEXT,
+    "fehlversuche" INTEGER NOT NULL DEFAULT 0,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "integrationszustand_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "spiegelbelegung" (
+    "id" TEXT NOT NULL,
+    "quelleRef" TEXT NOT NULL,
+    "beginn" TIMESTAMP(3) NOT NULL,
+    "ende" TIMESTAMP(3) NOT NULL,
+    "empfangenAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "spiegelbelegung_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "telegram_chat" (
+    "id" TEXT NOT NULL,
+    "chatId" BIGINT NOT NULL,
+    "bezeichnung" TEXT,
+    "benutzerId" TEXT,
+    "meldungen" BOOLEAN NOT NULL DEFAULT true,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztBenutzt" TIMESTAMP(3),
+
+    CONSTRAINT "telegram_chat_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "integrationszustand_quelle_key" ON "integrationszustand"("quelle");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "spiegelbelegung_quelleRef_key" ON "spiegelbelegung"("quelleRef");
+
+-- CreateIndex
+CREATE INDEX "spiegelbelegung_beginn_idx" ON "spiegelbelegung"("beginn");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "telegram_chat_chatId_key" ON "telegram_chat"("chatId");
+
+-- CreateIndex
+CREATE INDEX "telegram_chat_benutzerId_idx" ON "telegram_chat"("benutzerId");
+
+-- AddForeignKey
+ALTER TABLE "telegram_chat" ADD CONSTRAINT "telegram_chat_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE SET NULL ON UPDATE CASCADE;

prisma/migrations/20260911204204_telegram_kopplung/migration.sql

@@ -0,0 +1,16 @@
+-- CreateTable
+CREATE TABLE "telegram_kopplung" (
+    "id" TEXT NOT NULL,
+    "code" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "gueltigBis" TIMESTAMP(3) NOT NULL,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "telegram_kopplung_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "telegram_kopplung_code_key" ON "telegram_kopplung"("code");
+
+-- CreateIndex
+CREATE INDEX "telegram_kopplung_gueltigBis_idx" ON "telegram_kopplung"("gueltigBis");

prisma/migrations/20260912082447_api_token/migration.sql

@@ -0,0 +1,27 @@
+-- CreateTable
+CREATE TABLE "api_token" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "praefix" TEXT NOT NULL,
+    "hash" TEXT NOT NULL,
+    "rechte" TEXT NOT NULL,
+    "gueltigBis" TIMESTAMP(3),
+    "letzteNutzung" TIMESTAMP(3),
+    "widerrufenAm" TIMESTAMP(3),
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "api_token_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "api_token_praefix_key" ON "api_token"("praefix");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "api_token_hash_key" ON "api_token"("hash");
+
+-- CreateIndex
+CREATE INDEX "api_token_benutzerId_idx" ON "api_token"("benutzerId");
+
+-- AddForeignKey
+ALTER TABLE "api_token" ADD CONSTRAINT "api_token_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/schema.prisma

@@ -31,10 +31,15 @@ model Benutzer {
   erstelltAm     DateTime  @default(now())
   aktualisiertAm DateTime  @updatedAt
 
-  konten         Konto[]
+  konten           Konto[]
-  passkeys       Passkey[]
+  passkeys         Passkey[]
-  audit          AuditEintrag[]
+  audit            AuditEintrag[]
-  kalenderkonten Kalenderkonto[]
+  kalenderkonten   Kalenderkonto[]
+  benachrichtigung Benachrichtigungseinstellung?
+  pushGeraete      PushGeraet[]
+  meldungen        Meldungsnachweis[]
+  telegramChats    TelegramChat[]
+  apiTokens        ApiToken[]
 
   @@index([aktiv])
   @@map("benutzer")
@@ -219,11 +224,16 @@ model Aufgabe {
   /// Kennung beim Ursprungssystem, z. B. die Ticketnummer.
   quelleRef String?
 
+  /// Ausdruecklich zum Spiegeln freigegeben. Nur was hier true ist, verlaesst
+  /// die Instanz mit Titel – alles andere bleibt, wo es ist.
+  spiegeln Boolean @default(false)
+
   erstelltAm     DateTime @default(now())
   aktualisiertAm DateTime @updatedAt
 
-  bereich Bereich? @relation(fields: [bereichId], references: [id], onDelete: SetNull)
+  bereich     Bereich?    @relation(fields: [bereichId], references: [id], onDelete: SetNull)
-  projekt Projekt? @relation(fields: [projektId], references: [id], onDelete: SetNull)
+  projekt     Projekt?    @relation(fields: [projektId], references: [id], onDelete: SetNull)
+  zeitbloecke Zeitblock[]
 
   /// Integrationen upserten immer ueber diese beiden Felder. Von Hand
   /// erfasste Aufgaben haben quelleRef = null; PostgreSQL sieht NULL-Werte
@@ -299,15 +309,19 @@ model Kalenderkonto {
   letzterAbgleich DateTime?
   /// Klartextmeldung des letzten Fehlschlags, ohne Tokens.
   letzterFehler   String?
+  /// Wie oft der Abgleich hintereinander scheiterte. Ein Aussetzer ist keine
+  /// Nachricht wert; gemeldet wird erst ab mehreren.
+  fehlversuche    Int       @default(0)
 
   aktiv Boolean @default(true)
 
   erstelltAm     DateTime @default(now())
   aktualisiertAm DateTime @updatedAt
 
-  benutzer             Benutzer  @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+  benutzer             Benutzer    @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
   termine              Termin[]
-  standardFuerBereiche Bereich[] @relation("StandardKalenderkonto")
+  standardFuerBereiche Bereich[]   @relation("StandardKalenderkonto")
+  zeitblocks           Zeitblock[]
 
   /// Dasselbe Konto und derselbe Kalender nur einmal je Benutzer.
   @@unique([benutzerId, anbieter, extKontoId, kalenderId])
@@ -340,3 +354,219 @@ model Termin {
   @@index([beginn, ende])
   @@map("termin")
 }
+
+/// Eine Aufgabe, die zu einer bestimmten Zeit in einem Kalender steht.
+///
+/// Der Zeitblock lebt an zwei Orten: hier und im Kalender des Anbieters.
+/// Beide Seiten duerfen ihn verschieben; der Fingerabdruck "hash" verhindert,
+/// dass sich beide gegenseitig hochschaukeln. Siehe src/lib/zeitblock.ts.
+model Zeitblock {
+  id              String @id @default(cuid())
+  aufgabeId       String
+  kalenderkontoId String
+
+  beginn DateTime
+  ende   DateTime
+
+  /// Kennung des Termins beim Anbieter; null, solange noch nicht geschrieben.
+  extId String?
+  /// Fuer bedingte Schreibzugriffe (If-Match).
+  etag  String?
+  /// sha256(startISO|endeISO) dessen, was zuletzt geschrieben wurde.
+  hash  String?
+
+  /// Klartextmeldung des letzten Fehlschlags beim Schreiben, ohne Tokens.
+  letzterFehler String?
+
+  erstelltAm     DateTime @default(now())
+  aktualisiertAm DateTime @updatedAt
+
+  aufgabe       Aufgabe       @relation(fields: [aufgabeId], references: [id], onDelete: Cascade)
+  kalenderkonto Kalenderkonto @relation(fields: [kalenderkontoId], references: [id], onDelete: Cascade)
+
+  /// Ein Termin im Kalender gehoert zu hoechstens einem Zeitblock.
+  @@unique([kalenderkontoId, extId])
+  @@index([beginn, ende])
+  @@index([aufgabeId])
+  @@map("zeitblock")
+}
+
+/// Wie und worueber ein Benutzer benachrichtigt werden will.
+model Benachrichtigungseinstellung {
+  id         String @id @default(cuid())
+  benutzerId String @unique
+
+  /// Kommagetrennte Anlaesse, siehe src/lib/benachrichtigung.ts.
+  anlaesse    String  @default("tagesueberblick,faelligkeit")
+  perPush     Boolean @default(false)
+  perMail     Boolean @default(false)
+  perTelegram Boolean @default(false)
+
+  /// Alles als Minuten seit Mitternacht, Europe/Berlin.
+  ueberblickUm Int @default(420)
+  ruheVon      Int @default(1200)
+  ruheBis      Int @default(420)
+
+  ruheAmWochenende        Boolean @default(false)
+  zeitblockVorlaufMinuten Int     @default(10)
+
+  erstelltAm     DateTime @default(now())
+  aktualisiertAm DateTime @updatedAt
+
+  benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+
+  @@map("benachrichtigungseinstellung")
+}
+
+/// Ein Browser, der Push-Nachrichten empfangen darf.
+model PushGeraet {
+  id         String @id @default(cuid())
+  benutzerId String
+
+  /// Vom Browser vergebene Adresse; eindeutig je Geraet.
+  endpunkt String @unique
+  /// Schluessel aus der Push-Anmeldung, verschluesselt abgelegt.
+  p256dh   String
+  auth     String
+
+  bezeichnung    String?
+  erstelltAm     DateTime  @default(now())
+  zuletztBenutzt DateTime?
+  /// Wie oft der Versand hintereinander scheiterte; ab einer Grenze weg.
+  fehlversuche   Int       @default(0)
+
+  benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+
+  @@index([benutzerId])
+  @@map("push_geraet")
+}
+
+/// Nachweis, dass eine Meldung schon hinausging – verhindert Wiederholungen.
+model Meldungsnachweis {
+  id         String   @id @default(cuid())
+  benutzerId String
+  /// anlass:sache:tag, siehe meldungsSchluessel().
+  schluessel String
+  gesendetAm DateTime @default(now())
+
+  benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+
+  @@unique([benutzerId, schluessel])
+  @@index([gesendetAm])
+  @@map("meldungsnachweis")
+}
+
+/// Zustand einer Integration: wie weit sie gelesen hat und ob es klappt.
+///
+/// Eine Zeile je Quelle. Der Merker ist bewusst ein freier Text – jede
+/// Integration legt darin ab, was sie zum Fortsetzen braucht: Zammad einen
+/// Zeitstempel, Telegram den Zaehler der zuletzt geholten Nachricht.
+model Integrationszustand {
+  id     String @id @default(cuid())
+  quelle Quelle @unique
+
+  /// Woher es weitergeht. Bedeutung haengt an der Quelle.
+  merker String?
+
+  letzterLauf   DateTime?
+  letzterErfolg DateTime?
+  letzterFehler String?
+  /// Fehlschlaege in Folge; bei Erfolg wieder null.
+  fehlversuche  Int       @default(0)
+
+  erstelltAm     DateTime @default(now())
+  aktualisiertAm DateTime @updatedAt
+
+  @@map("integrationszustand")
+}
+
+/// Dienstliche Belegung, die aus der anderen Instanz kommt.
+///
+/// Bewusst ohne Titel: Daheim soll sehen, *dass* die Zeit weg ist, nicht
+/// woran gearbeitet wird. Firmeninhalte verlassen die Firma nicht.
+model Spiegelbelegung {
+  id String @id @default(cuid())
+
+  /// Kennung des Zeitblocks in der sendenden Instanz.
+  quelleRef String @unique
+
+  beginn DateTime
+  ende   DateTime
+
+  empfangenAm DateTime @default(now())
+
+  @@index([beginn])
+  @@map("spiegelbelegung")
+}
+
+/// Ein Telegram-Chat, der mit dem Planer reden darf.
+///
+/// Wer nicht hier steht, wird verworfen – ein Bot-Token laesst sich erraten
+/// oder abgreifen, die Chatkennung ist der zweite Riegel.
+model TelegramChat {
+  id     String @id @default(cuid())
+  /// Chatkennung bei Telegram; kann negativ sein (Gruppen).
+  chatId BigInt @unique
+
+  bezeichnung String?
+  benutzerId  String?
+
+  /// Empfaengt dieser Chat auch Meldungen, nicht nur Aufgaben?
+  meldungen Boolean @default(true)
+
+  erstelltAm     DateTime  @default(now())
+  zuletztBenutzt DateTime?
+
+  benutzer Benutzer? @relation(fields: [benutzerId], references: [id], onDelete: SetNull)
+
+  @@index([benutzerId])
+  @@map("telegram_chat")
+}
+
+/// Einmalcode, mit dem sich ein Telegram-Chat anmeldet.
+///
+/// Ohne ihn muesste die Chatkennung von Hand eingetragen werden – und um sie
+/// zu erfahren, muesste der Planer auf Nachrichten Unbekannter antworten.
+/// Genau das soll er nicht.
+model TelegramKopplung {
+  id         String   @id @default(cuid())
+  code       String   @unique
+  benutzerId String
+  gueltigBis DateTime
+
+  erstelltAm DateTime @default(now())
+
+  @@index([gueltigBis])
+  @@map("telegram_kopplung")
+}
+
+/// Zugangstoken fuer die oeffentliche Schnittstelle.
+///
+/// Gespeichert wird nur der Hash. Der Klartext existiert genau einmal – beim
+/// Anlegen, auf dem Bildschirm. Ein Token ist ein Passwort; wer es verliert,
+/// legt ein neues an, statt das alte irgendwo nachzuschlagen.
+model ApiToken {
+  id         String @id @default(cuid())
+  benutzerId String
+
+  name    String
+  /// Sichtbarer Anfang, macht die Zeile auffindbar und wiedererkennbar.
+  praefix String @unique
+  /// SHA-256 des vollstaendigen Tokens.
+  hash    String @unique
+
+  /// Kommagetrennt, siehe src/lib/api.ts.
+  rechte String
+
+  gueltigBis    DateTime?
+  letzteNutzung DateTime?
+  /// Gesetzt heisst: gilt nicht mehr. Die Zeile bleibt fuer das Protokoll.
+  widerrufenAm  DateTime?
+
+  erstelltAm DateTime @default(now())
+
+  benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+
+  @@index([benutzerId])
+  @@map("api_token")
+}

public/manifest.webmanifest

@@ -0,0 +1,39 @@
+{
+  "name": "Planer",
+  "short_name": "Planer",
+  "description": "Aufgaben, Ideen, Projekte und Zeitblöcke.",
+  "lang": "de",
+  "dir": "ltr",
+  "start_url": "/erfassen",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "portrait",
+  "background_color": "#f7f8fa",
+  "theme_color": "#f7f8fa",
+  "icons": [
+    {
+      "src": "/symbol.svg",
+      "sizes": "any",
+      "type": "image/svg+xml",
+      "purpose": "any"
+    },
+    {
+      "src": "/symbol-flaeche.svg",
+      "sizes": "any",
+      "type": "image/svg+xml",
+      "purpose": "maskable"
+    }
+  ],
+  "shortcuts": [
+    {
+      "name": "Erfassen",
+      "short_name": "Erfassen",
+      "url": "/erfassen"
+    },
+    {
+      "name": "Heute",
+      "short_name": "Heute",
+      "url": "/"
+    }
+  ]
+}

public/sw.js

@@ -0,0 +1,107 @@
+/*
+ * Service Worker des Planers.
+ *
+ * Zwei Aufgaben: Push-Nachrichten anzeigen, und die Seite "Erfassen" auch
+ * ohne Netz bereithalten.
+ *
+ * Zwischengespeichert wird **genau diese eine Seite** und sonst nichts. Ein
+ * halb veralteter Planer wäre schlimmer als gar keiner — ein Eingabefeld
+ * dagegen veraltet nicht, und ohne die Seite nützte die Warteschlange im
+ * Gerät niemandem: Man käme gar nicht erst hin.
+ */
+
+const LAGER = 'planer-erfassen-v1'
+const OFFLINE_SEITE = '/erfassen'
+
+self.addEventListener('install', (ereignis) => {
+  ereignis.waitUntil(
+    caches
+      .open(LAGER)
+      .then((lager) => lager.add(new Request(OFFLINE_SEITE, { cache: 'reload' })))
+      .catch(() => undefined),
+  )
+  // Sofort übernehmen, nicht auf das Schließen aller Tabs warten.
+  self.skipWaiting()
+})
+
+self.addEventListener('activate', (ereignis) => {
+  ereignis.waitUntil(
+    caches
+      .keys()
+      .then((namen) =>
+        Promise.all(namen.filter((n) => n !== LAGER).map((n) => caches.delete(n))),
+      )
+      .then(() => self.clients.claim()),
+  )
+})
+
+self.addEventListener('fetch', (ereignis) => {
+  const anfrage = ereignis.request
+  if (anfrage.method !== 'GET') return
+
+  const adresse = new URL(anfrage.url)
+  if (adresse.origin !== self.location.origin) return
+  if (adresse.pathname !== OFFLINE_SEITE) return
+
+  // Zuerst das Netz: Wer online ist, bekommt die frische Seite. Erst wenn das
+  // scheitert, kommt die aufgehobene Fassung.
+  ereignis.respondWith(
+    fetch(anfrage)
+      .then((antwort) => {
+        if (antwort.ok) {
+          const kopie = antwort.clone()
+          void caches.open(LAGER).then((lager) => lager.put(OFFLINE_SEITE, kopie))
+        }
+        return antwort
+      })
+      .catch(() =>
+        caches
+          .match(OFFLINE_SEITE)
+          .then(
+            (aufgehoben) =>
+              aufgehoben ??
+              new Response('Offline und nichts aufgehoben.', {
+                status: 503,
+                headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+              }),
+          ),
+      ),
+  )
+})
+
+self.addEventListener('push', (ereignis) => {
+  let daten = { titel: 'Planer', text: '', pfad: '/' }
+  try {
+    if (ereignis.data) daten = { ...daten, ...ereignis.data.json() }
+  } catch {
+    // Kaputte Nutzlast: lieber eine karge Meldung als gar keine.
+  }
+
+  ereignis.waitUntil(
+    self.registration.showNotification(daten.titel, {
+      body: daten.text,
+      lang: 'de',
+      // Gleiche Anlässe überschreiben einander, statt sich zu stapeln.
+      tag: daten.anlass || 'planer',
+      data: { pfad: daten.pfad },
+    }),
+  )
+})
+
+self.addEventListener('notificationclick', (ereignis) => {
+  ereignis.notification.close()
+  const pfad = (ereignis.notification.data && ereignis.notification.data.pfad) || '/'
+
+  ereignis.waitUntil(
+    self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then((fenster) => {
+      // Ist der Planer schon offen, dorthin wechseln statt ein zweites
+      // Fenster aufzumachen.
+      for (const f of fenster) {
+        if (f.url.includes(self.location.origin)) {
+          return f.focus().then(() => f.navigate(pfad))
+        }
+      }
+      return self.clients.openWindow(pfad)
+    }),
+  )
+})

public/symbol-flaeche.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Planer">
+  <!-- Maskierbare Fassung: Das Motiv sitzt in der sicheren Zone, damit ein
+       Betriebssystem daraus einen Kreis oder ein Quadrat schneiden kann. -->
+  <rect width="64" height="64" fill="#2563eb" />
+  <path d="M20 34l8 8 16-18" fill="none" stroke="#ffffff" stroke-width="6"
+        stroke-linecap="round" stroke-linejoin="round" />
+</svg>

public/symbol.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Planer">
+  <!-- Ein Blatt mit Haken: Liste plus Erledigtes. Bewusst ohne Farbverlauf,
+       damit es auch als kleines Symbol lesbar bleibt. -->
+  <rect x="10" y="6" width="44" height="52" rx="8" fill="#2563eb" />
+  <rect x="20" y="2" width="8" height="10" rx="4" fill="#1e40af" />
+  <rect x="36" y="2" width="8" height="10" rx="4" fill="#1e40af" />
+  <path d="M21 33l8 8 15-16" fill="none" stroke="#ffffff" stroke-width="6"
+        stroke-linecap="round" stroke-linejoin="round" />
+</svg>