chore(release): 0.7.0

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
docs: Fahrplan, Aenderungen und DEVLOG fuer M7
2026-09-13 02:29:42 +02:00 · 2026-09-13 01:34:16 +02:00 · 2026-09-13 01:01:32 +02:00 · 2026-09-12 18:52:35 +02:00 · 2026-09-12 11:42:47 +02:00 · 2026-09-12 11:22:48 +02:00
208 changed files with 19856 additions and 182 deletions
@@ -59,6 +59,67 @@ WEBAUTHN_RP_NAME=Planer
 # Muss exakt der Herkunft im Browser entsprechen, inklusive Port.
 WEBAUTHN_ORIGIN=http://localhost:3000

+# --- Kalenderanbieter ------------------------------------------------------
+# Graph gibt es in beiden Instanzen, Google nur daheim. Ein Anbieter erscheint
+# erst, wenn Kennung UND Geheimnis gesetzt sind.
+# Einrichtung siehe README, Abschnitt "Kalenderanbieter einrichten".
+# Rueckleit-URIs:
+#   <APP_URL>/api/kalender/rueckleitung/graph
+#   <APP_URL>/api/kalender/rueckleitung/google
+GRAPH_CLIENT_ID=
+GRAPH_CLIENT_SECRET=
+# Tenant-ID, oder "organizations" fuer jeden Arbeitsplatz-Tenant.
+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
@@ -8,3 +8,4 @@ test-results
 playwright-report
 coverage
 devlog/zeiten.csv
+public/sw.js
@@ -6,6 +6,202 @@ die Versionierung [Semantic Versioning](https://semver.org/lang/de/).

 ## [Unveröffentlicht]

+## [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
+
+- Kalenderkonten für Microsoft 365 (Graph) und Google verbinden, umbenennen,
+  von Hand abgleichen und trennen. Google gibt es nur in der Instanz
+  `daheim`; in `firma` liefert die Route 404.
+- Termine werden örtlich gespiegelt: 7 Tage zurück bis 90 Tage voraus.
+  Gelesen werden nur Beginn, Ende, Betreff, ganztägig und "zeigt an als" —
+  keine Teilnehmer, Beschreibungen, Anhänge oder Orte.
+- Die Startseite zeigt je Bereich, wie voll der heutige Tag ist: Termine aus
+  allen verbundenen Kalendern gegen die Tageskapazität.
+- Hintergrundjobs: alle 15 Minuten abgleichen, nachts alte Termine und
+  abgelaufene WebAuthn-Herausforderungen entfernen.
+- Handbuchseite zu den Kalenderkonten, Einrichtungsanleitung für Entra ID
+  und die Google Cloud Console in der README.
+
+### Sicherheit
+
+- Zugangs- und Aktualisierungstoken liegen verschlüsselt in der Datenbank
+  (AES-256-GCM, Schlüssel aus AUTH_SECRET abgeleitet). Wer eine Sicherung in
+  die Hände bekommt, kann damit ohne AUTH_SECRET nichts anfangen.
+- Der Zustandswert im OAuth-Ablauf ist signiert und trägt die
+  Benutzerkennung; ohne das ließe sich ein fremdes Kalenderkonto an ein
+  beliebiges Konto hängen. Er verfällt nach 30 Minuten.
+- Fehlermeldungen nennen nie den Antwortkörper des Token-Endpunkts — der
+  enthält das Client-Secret oft im Echo.
+- Protokolliert werden beim Abgleich nur Zahlen, nie Kontonamen oder
+  Termininhalte.
+
+## [0.2.0] – 2026-09-10
+
+### Hinzugefügt
+
+- Aufgaben mit Typ, Status, Priorität, Aufwand, Fälligkeit und Herkunft;
+  Projekte als Klammer darum.
+- Schnellerfassung mit einem einzigen Feld auf der Startseite und in der Inbox.
+- Inbox: alles ohne Bereich sammelt sich dort und wird später einsortiert.
+  Die Zahl im Menü zeigt, wie viel noch liegt.
+- Aufgabenliste mit Filtern nach Suche, Bereich, Status, Art und Projekt.
+  Die Filter stehen in der Adresse und lassen sich als Lesezeichen ablegen.
+- Ideen als eigene Ansicht, ohne Termin und ohne Aufwand; per Klick wird
+  daraus eine Aufgabe.
+- Projekte mit Arbeitspaketen, Meilensteinen und Fortschritt.
+- Die Startseite zeigt, was überfällig, heute oder morgen fällig ist.
+- Handbuchseiten zu Aufgaben, Ideen und Projekten.
+
+### Geändert
+
+- Die Startseite zählt nicht mehr nur Bereiche auf, sondern stellt voran,
+  was jetzt dran ist.
+
+### Sicherheit
+
+- Statuswechsel folgen festen Übergängen: Abgeschlossenes wird erst wieder
+  geöffnet. Ein abweichender Wert im Formular führt zu einer Meldung, nicht
+  zu einem stillen Zustandssprung.
+- Angegebene Bereiche und Projekte werden vor dem Speichern geprüft; ein
+  erfundener Verweis gibt eine Meldung statt eines Datenbankfehlers.
+
 ## [0.1.0] – 2026-09-10

 ### Hinzugefügt
@@ -7,10 +7,11 @@ 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 1 von 8. Die Grundlage steht: Anmeldung, Rollen,
-> Protokoll, Bereiche und der Betrieb. Aufgaben kommen mit M2, das Lesen der
-> Kalender mit M3, die Wochenplanung mit M4. Der [Fahrplan](ROADMAP.md) sagt,
-> was wann folgt.
+> **Stand:** Meilenstein 4 von 8. Die Kernidee steht: Aufgaben lassen sich
+> per Ziehen und Ablegen als Zeitblöcke in den Kalender schreiben, und
+> 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`
  zur ersten Anmeldung
@@ -22,6 +23,26 @@ wird.

 ### Heute

+- **Schnellerfassung** mit einem einzigen Feld; alles ohne Bereich sammelt
+  sich in der **Inbox** und wird später einsortiert
+- **Aufgaben** mit Typ, Status, Priorität, Aufwand und Fälligkeit, sortiert
+  nach Dringlichkeit und filterbar über die Adresszeile
+- **Ideen** getrennt von Aufgaben — ohne Termin, per Klick übernehmbar
+- **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))
 - 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
@@ -32,19 +53,25 @@ wird.

 ### Geplant

-Aufgaben und Projekte, Kalender lesen und schreiben, Wochenplanung per Ziehen
-und Ablegen, Benachrichtigungen, Integrationen, Schnellerfassung vom Handy und
-ein MCP-Server. Siehe [ROADMAP.md](ROADMAP.md).
+Ein MCP-Server. Siehe [ROADMAP.md](ROADMAP.md).

 ## Bildergalerie

-|               | Hell                                                                    | Dunkel                                                                      |
-| ------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------- |
-| 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)            |
-| Bereiche      | ![Bereiche, hell](docs/bilder/bereiche-hell-schreibtisch.png)           | ![Bereiche, dunkel](docs/bilder/bereiche-dunkel-schreibtisch.png)           |
-| Einstellungen | ![Einstellungen, hell](docs/bilder/einstellungen-hell-schreibtisch.png) | ![Einstellungen, dunkel](docs/bilder/einstellungen-dunkel-schreibtisch.png) |
-| Protokoll     | ![Protokoll, hell](docs/bilder/protokoll-hell-schreibtisch.png)         | ![Protokoll, dunkel](docs/bilder/protokoll-dunkel-schreibtisch.png)         |
+|               | Hell                                                                              | Dunkel                                                                                |
+| ------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| 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)                      |
+| Inbox         | ![Inbox, hell](docs/bilder/inbox-hell-schreibtisch.png)                           | ![Inbox, dunkel](docs/bilder/inbox-dunkel-schreibtisch.png)                           |
+| Woche         | ![Woche, hell](docs/bilder/woche-hell-schreibtisch.png)                           | ![Woche, dunkel](docs/bilder/woche-dunkel-schreibtisch.png)                           |
+| Aufgaben      | ![Aufgaben, hell](docs/bilder/aufgaben-hell-schreibtisch.png)                     | ![Aufgaben, dunkel](docs/bilder/aufgaben-dunkel-schreibtisch.png)                     |
+| Projekte      | ![Projekte, hell](docs/bilder/projekte-hell-schreibtisch.png)                     | ![Projekte, dunkel](docs/bilder/projekte-dunkel-schreibtisch.png)                     |
+| Ideen         | ![Ideen, hell](docs/bilder/ideen-hell-schreibtisch.png)                           | ![Ideen, dunkel](docs/bilder/ideen-dunkel-schreibtisch.png)                           |
+| Kalender      | ![Kalenderkonten, hell](docs/bilder/kalenderkonten-hell-schreibtisch.png)         | ![Kalenderkonten, dunkel](docs/bilder/kalenderkonten-dunkel-schreibtisch.png)         |
+| Bereiche      | ![Bereiche, hell](docs/bilder/bereiche-hell-schreibtisch.png)                     | ![Bereiche, dunkel](docs/bilder/bereiche-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.
@@ -107,6 +134,89 @@ Alle Werte stehen in `.env`. Vorlage: [`.env.example`](.env.example).
 OIDC ist aktiv, sobald Issuer, Client-ID und Secret gesetzt sind. Der
 Rückleit-URI beim Anbieter lautet `<APP_URL>/api/auth/callback/oidc`.

+### Kalenderanbieter
+
+| Variable               | Standard        | Bedeutung                                                     |
+| ---------------------- | --------------- | ------------------------------------------------------------- |
+| `GRAPH_CLIENT_ID`      | _(leer)_        | Anwendungs-ID der App-Registrierung in Entra ID               |
+| `GRAPH_CLIENT_SECRET`  | _(leer)_        | Geheimnis dieser Registrierung                                |
+| `GRAPH_TENANT_ID`      | `organizations` | Tenant-ID, oder `organizations` für jeden Arbeitsplatz-Tenant |
+| `GOOGLE_CLIENT_ID`     | _(leer)_        | OAuth-Client-ID aus der Google Cloud Console                  |
+| `GOOGLE_CLIENT_SECRET` | _(leer)_        | Geheimnis dieses Clients                                      |
+
+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                                                                                |
@@ -116,6 +226,59 @@ Rückleit-URI beim Anbieter lautet `<APP_URL>/api/auth/callback/oidc`.
 | `TZ`             | `Europe/Berlin` | Zeitzone für Anzeigen und Tagesgrenzen                                                   |
 | `DEMO_MODUS`     | `false`         | Nur für die Screenshot-Instanz. Im Betrieb niemals `true`                                |

+## Kalenderanbieter einrichten
+
+Beides ist einmalige Handarbeit beim Anbieter. Der Planer fragt Lese- **und**
+Schreibrechte an: ab M4 schreibt er Zeitblöcke zurück, und eine zweite
+Zustimmungsrunde für jedes Konto wäre lästiger als eine etwas breitere
+Berechtigung von Anfang an.
+
+### Microsoft 365 (Entra ID)
+
+1. <https://entra.microsoft.com> → **Identität → Anwendungen →
+   App-Registrierungen → Neue Registrierung**.
+2. Name frei wählen, etwa „Planer".
+3. Unterstützte Kontotypen: **Nur Konten in diesem Organisationsverzeichnis**
+   (dann `GRAPH_TENANT_ID` auf die Tenant-ID setzen) oder
+   **Konten in einem beliebigen Organisationsverzeichnis** (dann
+   `organizations` belassen).
+4. Umleitungs-URI, Plattform **Web**:
+   `<APP_URL>/api/kalender/rueckleitung/graph`
+5. Nach dem Anlegen: **Anwendungs-ID (Client)** nach `GRAPH_CLIENT_ID`,
+   **Verzeichnis-ID (Mandant)** nach `GRAPH_TENANT_ID`.
+6. **Zertifikate & Geheimnisse → Neuer geheimer Clientschlüssel**. Den Wert
+   sofort nach `GRAPH_CLIENT_SECRET` kopieren — er wird nur einmal angezeigt.
+7. **API-Berechtigungen → Berechtigung hinzufügen → Microsoft Graph →
+   Delegierte Berechtigungen**: `Calendars.ReadWrite`, `offline_access`,
+   `openid`, `email`.
+
+> Ist im Tenant die Zustimmung durch Endbenutzer abgeschaltet, muss ein
+> Administrator einmalig **Administratorzustimmung erteilen** klicken.
+
+### Google Kalender
+
+1. <https://console.cloud.google.com> → Projekt anlegen oder wählen.
+2. **APIs & Dienste → Bibliothek** → _Google Calendar API_ aktivieren.
+3. **OAuth-Zustimmungsbildschirm** einrichten. Für den Eigengebrauch genügt
+   _Extern_ mit Veröffentlichungsstatus _Test_ und der eigenen Adresse als
+   Testbenutzer.
+4. Bereiche (Scopes) hinzufügen:
+   `.../auth/calendar.events` und `.../auth/calendar.readonly`.
+5. **Anmeldedaten → Anmeldedaten erstellen → OAuth-Client-ID**,
+   Anwendungstyp **Webanwendung**.
+6. Autorisierter Weiterleitungs-URI:
+   `<APP_URL>/api/kalender/rueckleitung/google`
+7. Client-ID und Clientschlüssel nach `GOOGLE_CLIENT_ID` und
+   `GOOGLE_CLIENT_SECRET`.
+
+> Bleibt das Projekt im Status _Test_, laufen die Aktualisierungstoken nach
+> sieben Tagen ab und die Konten müssen neu verbunden werden. Für den
+> Dauerbetrieb den Zustimmungsbildschirm **veröffentlichen**.
+
+Nach dem Eintragen: `docker compose up -d` und im Planer unter **Kalender**
+verbinden. Die Anleitung für den Alltag steht im
+[Handbuch](docs/handbuch/kalenderkonten.md).
+
 ## Betrieb

 ### Starten und stoppen
@@ -3,21 +3,23 @@
 Acht Meilensteine. Jeder endet mit einer lauffähigen Version auf `main`,
 grünen Prüfungen, aktueller Dokumentation und einem Eintrag im DEVLOG.

-| Meilenstein                             | Ziel                         | Status    |
-| --------------------------------------- | ---------------------------- | --------- |
-| [M1](#m1--fundament)                    | Fundament                    | in Arbeit |
-| [M2](#m2--aufgaben-und-projekte)        | Aufgaben und Projekte        | geplant   |
-| [M3](#m3--kalender-lesen)               | Kalender lesen               | geplant   |
-| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | geplant   |
-| [M5](#m5--benachrichtigungen)           | Benachrichtigungen           | geplant   |
-| [M6](#m6--integrationen)                | Integrationen                | geplant   |
-| [M7](#m7--schnellerfassung-und-api)     | Schnellerfassung und API     | geplant   |
-| [M8](#m8--mcp)                          | MCP                          | geplant   |
+| Meilenstein                             | Ziel                         | Status   |
+| --------------------------------------- | ---------------------------- | -------- |
+| [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 | erledigt |
+| [M5](#m5--benachrichtigungen)           | Benachrichtigungen           | erledigt |
+| [M6](#m6--integrationen)                | Integrationen                | erledigt |
+| [M7](#m7--schnellerfassung-und-api)     | Schnellerfassung und API     | erledigt |
+| [M8](#m8--mcp)                          | MCP                          | geplant  |

 ---

 ## M1 – Fundament

+**Erledigt am 10.09.2026 mit Version 0.1.0.**
+
 **Ziel:** Ein angemeldeter, betreibbarer Rumpf. Noch keine Aufgaben, kein
 Kalender — aber alles, worauf die späteren Meilensteine aufsetzen.

@@ -43,58 +45,114 @@ wirklich braucht, statt heute geraten.

 ## M2 – Aufgaben und Projekte

+**Erledigt am 10.09.2026 mit Version 0.2.0.**
+
 **Ziel:** Alles erfassen und wiederfinden, noch ohne Kalender.

- [ ] `Aufgabe` mit Typ, Status, Priorität, Aufwand, Fälligkeit, Quelle
- [ ] Eindeutigkeit `[quelle, quelleRef]`, Integrationen upserten
- [ ] Inbox: schnell erfassen, später einsortieren
- [ ] Ideen getrennt von Aufgaben
- [ ] Projekte mit Arbeitspaketen und Meilensteinen
- [ ] Listen mit Filtern nach Bereich, Status und Fälligkeit
- [ ] Handbuchseiten und Bilder
+- [x] `Aufgabe` mit Typ, Status, Priorität, Aufwand, Fälligkeit, Quelle
+- [x] Eindeutigkeit `[quelle, quelleRef]`, Integrationen upserten
+- [x] Inbox: schnell erfassen, später einsortieren
+- [x] Ideen getrennt von Aufgaben
+- [x] Projekte mit Arbeitspaketen und Meilensteinen
+- [x] Listen mit Filtern nach Bereich, Status und Fälligkeit
+- [x] Handbuchseiten und Bilder
+
+**Bewusst offen gelassen:** Kein Wiederholungsrhythmus für Aufgaben und keine
+Verknüpfung von Aufgaben untereinander — beides steht unter „Ideen für
+später" und wartet darauf, ob es im Alltag wirklich fehlt.

 ## M3 – Kalender lesen

+**Erledigt am 10.09.2026 mit Version 0.3.0.**
+
 **Ziel:** Termine aus Microsoft 365 und Google sehen.

- [ ] `Kalenderkonto` mit Anbieter, Tokens und Delta-Verweis
- [ ] OAuth-Verbindung je Instanz: Graph immer, Google nur daheim
- [ ] Graph-Delta-Sync und Google-Sync über `fetch`, Antworten mit zod geprüft
- [ ] Ganztägige Termine zählen nicht zur Belegung
- [ ] Anonymisierte Beispielantworten in `test/fixtures/`
- [ ] Hintergrundjob mit node-cron
+- [x] `Kalenderkonto` mit Anbieter, Tokens und Delta-Verweis
+- [x] OAuth-Verbindung je Instanz: Graph immer, Google nur daheim
+- [x] Graph-Delta-Sync und Google-Sync über `fetch`, Antworten mit zod geprüft
+- [x] Ganztägige Termine zählen nicht zur Belegung
+- [x] Anonymisierte Beispielantworten in `test/fixtures/`
+- [x] Hintergrundjob mit node-cron

 ## 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
- [ ] Wochenansicht mit `@dnd-kit/core`
- [ ] Schreiben in den Kalender, Rückweg beim Verschieben
- [ ] Schleifenschutz über `hash = sha256(startISO|endeISO)`
- [ ] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
- [ ] Belegung gegen die Tageskapazität des Bereichs
+- [x] `Zeitblock` an genau einer Aufgabe und einem Kalenderkonto
+- [x] Wochenansicht mit `@dnd-kit/core`
+- [x] Schreiben in den Kalender, Rückweg beim Verschieben
+- [x] Schleifenschutz über `hash = sha256(startISO|endeISO)`
+- [x] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
+- [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`
- [ ] Tagesüberblick per E-Mail über nodemailer
- [ ] Erinnerungen an Fälligkeiten, Jobs über node-cron
- [ ] Je Benutzer einstellbar, mit Ruhezeiten
+**Erledigt am 11.09.2026 mit Version 0.5.0.**
+
+**Ziel:** Sagen, was ansteht — und dabei so selten stören, dass niemand auf
+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`)
- [ ] Telegram (nur `daheim`)
- [ ] Spiegel: `firma` sendet, `daheim` empfängt
- [ ] Jede Integration upsertet über `[quelle, quelleRef]`
+**Erledigt am 12.09.2026 mit Version 0.6.0.**
+
+**Ziel:** Aufgaben dort abholen, wo sie entstehen — ohne dass die Planung
+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
- [ ] Öffentliche API mit Token je Anwendung
- [ ] Rechte je Token, jede Nutzung im Protokoll
+**Erledigt am 12.09.2026 mit Version 0.7.0.**
+
+**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

@@ -5,10 +5,572 @@ die Übersicht aus `scripts/zeit.sh summe`.

 ## Zeit je Meilenstein

-| Meilenstein | Art    | Minuten | Stunden  |
-| ----------- | ------ | ------- | -------- |
-| M1          | claude | 161     | 2,68     |
-| **Gesamt**  |        | **161** | **2,68** |
+| Meilenstein | Art    | Minuten  | Stunden   |
+| ----------- | ------ | -------- | --------- |
+| M1          | claude | 161      | 2,68      |
+| M2          | claude | 44       | 0,73      |
+| M3          | claude | 41       | 0,68      |
+| M4          | claude | 167      | 2,78      |
+| M5          | claude | 420      | 7,00      |
+| M6          | claude | 733      | 12,22     |
+| M7          | claude | 886      | 14,77     |
+| **Gesamt**  |        | **2452** | **40,87** |
+
+---
+
+## 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
+
+---
+
+## 2026-09-10 – M3: Kalender lesen
+
+**Dauer:** 41 Minuten (17:48–18:29), Art `claude`.
+
+**Ziel der Sitzung:** Termine aus Microsoft 365 und Google lesen, damit der
+Planer weiß, wann überhaupt Platz ist.
+
+### Erledigt
+
+- `Kalenderkonto` und `Termin` samt Migration; Bereich bekommt sein
+  Standard-Kalenderkonto für M4
+- Tokenverschlüsselung mit AES-256-GCM
+- Antworten beider Anbieter mit zod geprüft und in eine gemeinsame Form
+  gebracht, geprüft gegen anonymisierte Beispielantworten
+- Belegungsrechnung: Kapazität gegen Termine, freie Fenster für M4
+- OAuth-Verbinden, Tokenerneuerung, seitenweiser Abgleich mit Rückfall auf
+  einen vollständigen Durchlauf
+- Seite für die Kalenderkonten, Belegung des Tages auf der Startseite
+- Hintergrundjobs für Abgleich und nächtliches Aufräumen
+- 68 neue Unit-Tests, 10 neue Integrationsprüfungen
+- Handbuchseite und Einrichtungsanleitung für Entra ID und Google
+
+### Entscheidungen mit Begründung
+
+**Tokens verschlüsselt, Schlüssel aus AUTH_SECRET abgeleitet.** Wer die
+Datenbank oder eine Sicherung bekommt, hätte sonst direkten Zugriff auf
+fremde Kalender — das wiegt schwerer als bei den OIDC-Tokens aus M1, die
+nur die Anmeldung betreffen. Eine eigene Pflichtvariable wäre eine weitere
+Stelle, an der die Einrichtung scheitert; die Ableitung über HKDF kostet
+nichts und hat die richtige Nebenwirkung: wer AUTH_SECRET wechselt, muss
+die Konten neu verbinden — dann sind ohnehin alle Sitzungen ungültig.
+
+**Bei fremder Zeitzone abbrechen statt raten.** Graph liefert Datum und
+Zeitzone getrennt, ohne Versatz im Text. Wir fragen ausdrücklich UTC an;
+kommt etwas anderes zurück, wäre jede Umrechnung geraten und würde Termine
+um Stunden verschieben. Ein Abbruch mit klarer Meldung ist besser als ein
+Kalender, der leise falsch liegt.
+
+**Unbekanntes showAs zählt als belegt.** Lieber eine Stunde zu viel
+blockiert als eine Doppelbuchung.
+
+**Schreibrechte schon jetzt anfragen.** M3 liest nur, aber M4 schreibt.
+Später erneut zuzustimmen ist genau der Schritt, an dem Einrichtung
+scheitert — einmal breiter fragen ist das kleinere Übel.
+
+**Ganztägige Termine zählen nicht zur Belegung.** Ein Urlaubstag oder
+Geburtstag blockiert sonst den ganzen Tag, obwohl er keine Arbeitszeit
+kostet.
+
+**Alle Kalender zählen gegen jeden Bereich.** Ein Termin blockiert die Zeit
+ohnehin, gleich zu welchem Lebensbereich er gehört.
+
+**Kein SDK für Graph und Google.** Es geht um drei Aufrufe je Anbieter, und
+die Antworten werden ohnehin mit zod geprüft. Ein SDK brächte vor allem
+Abhängigkeiten und blinde Flecken.
+
+### Probleme und Lösungen
+
+| Problem                                                                 | Lösung                                                                                                                                                |
+| ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Prisma lässt in einem zusammengesetzten Unique-Schlüssel kein null zu   | `kalenderId` ist nicht optional, sondern trägt den sprechenden Wert `"standard"` für den Standardkalender.                                            |
+| Googles `syncToken` verträgt sich nicht mit `timeMin`/`timeMax`         | Folgeabgleiche liefern auch Änderungen außerhalb des Fensters. Was daneben liegt, wird beim Spiegeln verworfen — sonst wüchse der Spiegel unbegrenzt. |
+| Der Verweis für die nächste Runde kann ablaufen (HTTP 410)              | Verweis verwerfen, Spiegel leeren, von vorn lesen. Der Ablauf ist so gebaut, dass ein vollständiger Durchlauf jederzeit möglich ist.                  |
+| Die Shell zerlegte in mehreren Anläufen Template-Literale und Backticks | Auf `node - <<'SKRIPT'` umgestellt; damit geht der Text unverändert durch.                                                                            |
+
+### Offene Punkte
+
+- **Nicht gegen die echten APIs getestet.** Ich habe keine Zugangsdaten für
+  Entra ID oder Google. Provider und Abgleich sind gegen anonymisierte
+  Beispielantworten geprüft; den ersten echten Verbindungsversuch muss
+  Florian machen. Die Anleitung dafür steht in der README.
+- Nur der Standardkalender je Konto. Mehrere Kalender desselben Kontos sind
+  im Datenmodell vorgesehen, es fehlt die Auswahl in der Oberfläche.
+- Der Abgleich läuft in einer Schleife über alle Konten. Bei vielen Konten
+  wäre das nacheinander zu langsam; bei der erwarteten Zahl ist es das
+  einfachere Verhalten.
+
+### Commits
+
+- 79e6c0d feat(kalender): Datenmodell für Kalenderkonten und Termine
+- 6fda2a5 feat(kalender): Antworten von Graph und Google lesen, Belegung rechnen
+- 9946e7c feat(kalender): OAuth und Abgleich für Graph und Google
+- 0c67b73 feat(kalender): Seite für die Kalenderkonten
+- 42c98c8 feat(kalender): Hintergrundjobs für Abgleich und Aufräumen
+- d8d3227 feat(kalender): Belegung des Tages auf der Startseite
+- df50627 test: Verschlüsselung und Kalendermodelle absichern
+- a8b2ff0 docs: Handbuchseite und Einrichtung der Kalenderanbieter
+
+---
+
+## 2026-09-10 – M2: Aufgaben und Projekte
+
+**Dauer:** 44 Minuten (15:57–16:41), Art `claude`.
+
+**Ziel der Sitzung:** Erfassen und Wiederfinden — Aufgaben, Inbox, Ideen und
+Projekte. Noch ohne Kalender.
+
+### Erledigt
+
+- Datenmodell `Aufgabe` und `Projekt` samt Migration
+- Schnellerfassung, Inbox mit Einsortieren, Aufgabenliste mit Filtern
+- Ideen als eigene Ansicht, mit Übernahme in eine Aufgabe
+- Projekte mit Arbeitspaketen, Meilensteinen und Fortschritt
+- Startseite zeigt jetzt, was überfällig oder demnächst fällig ist
+- 53 neue Unit-Tests, 11 neue Integrationsprüfungen, 4 neue E2E-Tests
+- Handbuchseiten zu Aufgaben, Ideen und Projekten; Bilder neu aufgenommen
+
+### Entscheidungen mit Begründung
+
+**Die Inbox ist kein eigener Zustand.** Eine Aufgabe liegt genau dann in der
+Inbox, wenn sie keinen Bereich hat. Ein zusätzliches Feld „einsortiert"
+hätte mit der Zuordnung auseinanderlaufen können; so ist der Zustand nicht
+darstellbar.
+
+**Projekt als eigenes Modell, nicht als Aufgabentyp.** Ein Projekt hat
+selbst weder Aufwand noch Fälligkeit — beides ergibt sich aus dem Inhalt.
+`ARBEITSPAKET` und `MEILENSTEIN` bleiben Typen der Aufgaben _innerhalb_
+eines Projekts.
+
+**Verworfene Aufgaben zählen gar nicht in den Fortschritt.** Weder als
+erledigt noch als offen. Sonst sähe ein Projekt fertig aus, weil die Hälfte
+gestrichen wurde — eine Zahl, die lügt, ist schlechter als keine.
+
+**Sortiert wird in der Anwendung, nicht in SQL.** Die Reihenfolge ist
+mehrstufig (offen vor abgeschlossen, dann Termin, dann Priorität, dann Titel
+mit deutscher Sortierung). Als geprüfte reine Funktion steht sie an einer
+Stelle; eine zweite Fassung in SQL wäre eine Fehlerquelle. Bei den erwarteten
+Mengen ist das unkritisch — sollte es einmal eng werden, ist der Ort für die
+Änderung klar.
+
+**Filter stehen in der Adresse.** Eine gefilterte Liste lässt sich als
+Lesezeichen ablegen, und der Zurück-Knopf tut, was er soll.
+
+**Statuswechsel folgen festen Übergängen.** Aus `ERLEDIGT` und `VERWORFEN`
+geht es nur zurück nach `OFFEN`. Wer per Formular etwas anderes einreicht,
+bekommt eine Meldung — nicht einen stillen Zustandssprung.
+
+**Fälligkeit in Kalendertagen, nicht in Stunden.** Was heute um 23:00 fällig
+ist, ist heute fällig. Alles andere fühlt sich beim Benutzen falsch an.
+
+**Natives `<select>` statt einer eigenen Auswahlkomponente.** Es bedient
+sich auf dem Handy mit dem Systemdialog, ist ohne Zusatzcode
+tastaturbedienbar und braucht kein JavaScript zum Absenden.
+
+### Probleme und Lösungen
+
+| Problem                                                                 | Lösung                                                                                                                                                                                |
+| ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ESLint beanstandete `String(antwort.meldung)`                           | Ich hatte die Rückmeldung als `Record<string, unknown>` typisiert, statt den vorhandenen `Rueckmeldung`-Typ zu nehmen. Mit dem richtigen Typ entfällt die Umwandlung ganz.            |
+| Zwei Stellen rechneten die Tagesgrenze mit einem `toLocaleString`-Trick | `src/lib/zeit.ts` konnte das längst sauber. Beide Stellen nutzen jetzt `tagesBeginn()` beziehungsweise `alsTagesschluessel()`; die Tests belegen gleiche Ergebnisse bei weniger Code. |
+| Typfehler nach der Migration                                            | Der Prisma-Client muss nach jeder Schemaänderung neu erzeugt werden. `npm run pruefen` tut das inzwischen selbst, wenn er fehlt — hier war er nur veraltet.                           |
+
+### Eigene Fehler, die ich korrigiert habe
+
+- Im Demo-Seed stand versehentlich ein kyrillisches Wort als Titel eines
+  Meilensteins. Ersetzt durch „Seite ist online".
+- Ein Test erwartete, dass 481 Minuten Aufwand erlaubt sind; die Grenze
+  liegt bei 480. Der Test war falsch, nicht der Code — jetzt prüft er die
+  Grenze selbst und den ersten Wert darüber.
+
+### Offene Punkte
+
+- Kein Wiederholungsrhythmus für Aufgaben und keine Verknüpfung von Aufgaben
+  untereinander. Beides steht bewusst unter „Ideen für später" und wartet
+  darauf, ob es im Alltag wirklich fehlt.
+- Die Aufgabenliste lädt bis zu 500 Einträge auf einmal. Für den erwarteten
+  Bestand reicht das; eine Blätterfunktion kommt, wenn es eng wird.
+
+### Commits
+
+- 63c3c15 feat(aufgaben): Datenmodell und Regeln für Aufgaben und Projekte
+- b3ca1c9 feat(aufgaben): Server Actions und Abfrageschicht
+- a4a889f feat(aufgaben): Inbox, Aufgabenliste, Ideen und Projekte
+- 7c8fe10 test: Erfassungsweg und Eindeutigkeit der Quellen absichern
+- 144457b fix(aufgaben): Ideen aus Aufgabenliste und Inbox heraushalten
+- 4d0f83f chore: Demo-Daten für die neuen Seiten erweitern
+- d01c49b docs: Handbuchseiten zu Aufgaben, Ideen und Projekten

 ---

@@ -1,2 +1,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
@@ -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'
@@ -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.
@@ -133,14 +133,26 @@ E-Mail-Adresse und **Mit Passkey anmelden**.
 > Hinterlege am besten zwei Passkeys auf verschiedenen Geräten. Sonst sperrst
 > du dich aus, wenn ein Gerät verlorengeht.

-## 8. Aufräumen
+## 8. Die erste Aufgabe erfassen
+
+Auf der Startseite steht oben ein Feld **Was ist zu tun?**. Titel eintippen,
+Enter.
+
+**Erwartet:** Eine kurze Bestätigung, und der Zähler neben **Inbox** im Menü
+springt auf 1. Dort kannst du die Aufgabe einem Bereich zuordnen.
+
+Mehr dazu: [Aufgaben erfassen und wiederfinden](handbuch/aufgaben.md).
+
+## 9. Aufräumen

 Wenn `ADMIN_PASSWORT` nur zur Einrichtung gedient hat, kannst du es jetzt
 zusammen mit `ADMIN_EMAIL` aus `.env` entfernen. Das Konto bleibt bestehen.

 ## Wie es weitergeht

- [Handbuch](handbuch/) – Anleitung für den Alltag
+- [Handbuch](handbuch/) – Anleitung für den Alltag, insbesondere
+  [Aufgaben](handbuch/aufgaben.md), [Ideen](handbuch/ideen.md) und
+  [Projekte](handbuch/projekte.md)
 - [README](../README.md) – alle Umgebungsvariablen, Betrieb, Sicherung
 - [ROADMAP](../ROADMAP.md) – was in den nächsten Meilensteinen kommt

@@ -9,28 +9,40 @@ Anleitung für den Alltag mit dem Planer. Eine Seite je Thema.
 2. **[Bereiche einrichten](bereiche.md)** – Farbe, Arbeitsfenster und
   Tageskapazität festlegen

+## Im Alltag
+
+3. **[Aufgaben erfassen und wiederfinden](aufgaben.md)** – Schnellerfassung,
+   Inbox leeren, Filter, Status und Fälligkeit
+4. **[Schnellerfassung vom Handy](erfassen.md)** – als App ablegen, auch
+   ohne Netz erfassen
+5. **[Ideen](ideen.md)** – festhalten, was noch keine Aufgabe ist
+6. **[Projekte](projekte.md)** – mehrere Aufgaben unter einem Ziel, mit
+   Fortschritt
+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

-3. **[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 |
-| ------------------------------- | ----------- |
-| Aufgaben erfassen, Inbox, Ideen | M2          |
-| Projekte und Arbeitspakete      | M2          |
-| Kalenderkonten verbinden        | M3          |
-| Wochenplanung und Zeitblöcke    | M4          |
-| Benachrichtigungen              | M5          |
-| Integrationen                   | M6          |
-| Schnellerfassung vom Handy, API | M7          |
-| MCP                             | M8          |
+| Thema | Meilenstein |
+| ----- | ----------- |
+| MCP   | M8          |

 Der [Fahrplan](../../ROADMAP.md) sagt, was in welchem Meilenstein steckt.

 ---

+Für fremde Anwendungen und Skripte: [Schnittstelle](../API.md).
 Zur Einrichtung einer neuen Instanz: [Schnellstart](../SCHNELLSTART.md).
 Für Betrieb, Sicherung und alle Umgebungsvariablen: [README](../../README.md).
@@ -0,0 +1,135 @@
+# Aufgaben erfassen und wiederfinden
+
+Der Planer trennt zwei Dinge, die sonst gern durcheinandergeraten:
+**etwas aufschreiben** und **entscheiden, wohin es gehört**. Das erste soll
+zwei Sekunden dauern, das zweite macht man gesammelt, wenn man Ruhe hat.
+
+## Schnell erfassen
+
+Auf der Startseite und in der Inbox steht ein einzelnes Feld. Titel eintippen,
+Enter — fertig.
+
+![Die Inbox](../bilder/inbox-hell-schreibtisch.png)
+
+Der Fokus bleibt danach im Feld, du kannst also mehrere Sachen hintereinander
+eingeben, ohne zur Maus zu greifen.
+
+> **Warum nur ein Feld?** Wer beim Erfassen erst Bereich, Termin und Aufwand
+> ausfüllen muss, erfasst irgendwann nichts mehr, sondern merkt es sich
+> „schnell" — und vergisst es. Alles Weitere kommt beim Einsortieren.
+
+## Die Inbox leeren
+
+Alles ohne Bereich landet in der Inbox. Die Zahl neben dem Menüpunkt sagt, wie
+viel dort liegt.
+
+Zum Einsortieren genügt das Auswahlfeld unter der Aufgabe: Bereich wählen, und
+sie verschwindet aus der Inbox.
+
+> **Die Inbox ist kein eigener Zustand.** Eine Aufgabe ist genau dann in der
+> Inbox, wenn sie keinen Bereich hat. Einsortieren heißt schlicht: einen
+> Bereich setzen. Deshalb kann sie auch nicht „doppelt" irgendwo sein.
+
+Wenn beim Einsortieren mehr zu ergänzen ist als der Bereich, klick auf das
+Stift-Symbol — dann öffnet sich das vollständige Formular direkt in der Liste.
+
+## Die Aufgabenliste
+
+![Die Aufgabenliste](../bilder/aufgaben-hell-schreibtisch.png)
+
+Standardmäßig zeigt sie nur, was noch Arbeit bedeutet — Erledigtes und
+Verworfenes fällt heraus. Über den Filter _Status_ holst du es zurück.
+
+### Die Reihenfolge
+
+Sortiert wird nach Dringlichkeit, in dieser Reihenfolge:
+
+1. Offenes vor Abgeschlossenem
+2. früherer Termin vor späterem
+3. Terminiertes vor Unterminiertem
+4. bei gleichem Termin: höhere Priorität zuerst
+5. zuletzt alphabetisch
+
+Ohne Termin heißt also nicht unwichtig — solche Aufgaben stehen nur hinter den
+terminierten.
+
+### Filter
+
+| Filter      | Was er tut                                              |
+| ----------- | ------------------------------------------------------- |
+| **Suche**   | Durchsucht Titel und Notiz. Enter drücken               |
+| **Bereich** | Ein Bereich, oder _Nur Inbox_ für alles ohne Bereich    |
+| **Status**  | Standard ist _Nur offene_. _Alle_ zeigt auch Erledigtes |
+| **Art**     | Aufgabe, Arbeitspaket, Meilenstein, Idee oder Spiegel   |
+| **Projekt** | Nur Aufgaben eines Projekts                             |
+
+Die Filter stehen in der Adresszeile. Eine gefilterte Liste lässt sich also als
+Lesezeichen ablegen, und der Zurück-Knopf des Browsers tut, was er soll.
+
+## Die Felder einer Aufgabe
+
+| Feld          | Bedeutung                                                                            |
+| ------------- | ------------------------------------------------------------------------------------ |
+| **Titel**     | Zwei bis 200 Zeichen. Am besten mit einem Verb: „Angebot schreiben", nicht „Angebot" |
+| **Notiz**     | Was dazugehört, aber nicht in den Titel passt                                        |
+| **Art**       | Aufgabe, Idee, Arbeitspaket oder Meilenstein                                         |
+| **Status**    | Offen, Geplant, Wartet, Erledigt, Verworfen                                          |
+| **Priorität** | 1 Sofort bis 5 Irgendwann. 3 ist der Normalfall                                      |
+| **Aufwand**   | Geschätzte Minuten, höchstens 480                                                    |
+| **Fällig am** | Der Tag, an dem es spätestens fertig sein muss                                       |
+| **Bereich**   | Leer heißt Inbox                                                                     |
+| **Projekt**   | Optional                                                                             |
+
+> **Warum höchstens acht Stunden Aufwand?** Weil ab M4 aus einer Aufgabe ein
+> Zeitblock im Kalender wird. Was nicht an einem Tag am Stück zu schaffen ist,
+> gehört in mehrere Aufgaben — sonst lässt es sich nicht planen.
+
+## Der Status
+
+| Status        | Wann                                                  |
+| ------------- | ----------------------------------------------------- |
+| **Offen**     | Steht an, ist noch nicht eingeplant                   |
+| **Geplant**   | Hat ab M4 einen Zeitblock im Kalender                 |
+| **Wartet**    | Liegt bei jemand anderem. Du kannst gerade nichts tun |
+| **Erledigt**  | Fertig                                                |
+| **Verworfen** | Wird nicht gemacht — aber die Notiz bleibt erhalten   |
+
+Das Häkchen links in jeder Zeile hakt direkt ab. Bei einer erledigten Aufgabe
+wird daraus ein Pfeil, der sie wieder öffnet.
+
+> **Aus Erledigt und Verworfen geht es nur zurück nach Offen.** Nicht direkt
+> nach Geplant oder Wartet. Was wieder aufgenommen wird, fängt am Anfang an —
+> sonst entstehen Zustände, die niemand mehr nachvollziehen kann.
+
+## Fälligkeit
+
+Der Planer rechnet in **Kalendertagen in Europe/Berlin**, nicht in
+24-Stunden-Schritten. Was heute um 23:00 fällig ist, ist „heute fällig" — nicht
+„in 0,5 Tagen".
+
+| Kennzeichen | Bedeutung                |
+| ----------- | ------------------------ |
+| rot         | überfällig               |
+| gelb        | heute oder morgen        |
+| grau        | später, oder ohne Termin |
+
+Erledigtes wird nie als überfällig markiert, auch wenn der Termin lange
+zurückliegt.
+
+## Löschen
+
+Der Papierkorb fragt einmal nach: Beim ersten Klick wird der Knopf rot und
+fragt „Wirklich?", erst der zweite löscht. Klickst du daneben, ist die Frage
+wieder weg.
+
+Meist ist **Verworfen** die bessere Wahl — dann bleibt nachvollziehbar, dass es
+die Aufgabe gab und warum sie nicht gemacht wurde.
+
+## Typische Fehler
+
+| Meldung                                             | Was zu tun ist                                         |
+| --------------------------------------------------- | ------------------------------------------------------ |
+| „Mindestens zwei Zeichen."                          | Der Titel ist zu kurz                                  |
+| „Mehr als acht Stunden gehört in mehrere Aufgaben." | Aufteilen                                              |
+| „Dieser Statuswechsel ist nicht vorgesehen."        | Erst wieder öffnen, dann weiter                        |
+| „Diesen Bereich gibt es nicht."                     | Der Bereich wurde inzwischen gelöscht. Seite neu laden |
@@ -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).
@@ -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).
@@ -0,0 +1,48 @@
+# Ideen
+
+Nicht alles, was einem einfällt, ist eine Aufgabe. Manches ist ein „das wäre
+mal schön" ohne Termin, ohne Aufwand und ohne Verpflichtung.
+
+Solche Sachen gehören auf die Ideenseite — dort stören sie die Aufgabenliste
+nicht und gehen trotzdem nicht verloren.
+
+![Die Ideenseite](../bilder/ideen-hell-schreibtisch.png)
+
+## Eine Idee notieren
+
+Titel eintippen, Enter. Genau wie bei Aufgaben, nur landet es auf der
+Ideenseite statt in der Inbox.
+
+> Bewerten kannst du später. Der Sinn ist, sie festzuhalten, bevor sie weg ist.
+
+## Aus einer Idee eine Aufgabe machen
+
+Wenn aus der Idee etwas werden soll: **Zur Aufgabe machen**. Sie verschwindet
+damit von der Ideenseite und taucht in der Inbox auf — Bereich, Termin und
+Aufwand ergänzt du dann wie bei jeder anderen Aufgabe.
+
+Der Titel und die Notiz bleiben erhalten, es entsteht kein zweiter Eintrag.
+
+## Warum Ideen getrennt liegen
+
+Ideen haben bewusst **keinen Termin**. Würden sie in der Aufgabenliste stehen,
+träfe eines von beidem zu:
+
+- Sie stünden ganz unten und wären damit unsichtbar, oder
+- sie bekämen einen erfundenen Termin und würden irgendwann rot.
+
+Beides führt dazu, dass man die Liste nicht mehr ernst nimmt. Getrennt bleibt
+die Aufgabenliste eine Liste von Verpflichtungen — und die Ideenseite eine
+Sammlung von Möglichkeiten.
+
+## Eine Idee wieder loswerden
+
+Der Papierkorb löscht endgültig. Wer sie lieber behalten möchte, ohne sie
+weiter zu sehen, setzt sie über das Stift-Symbol auf **Verworfen** — dann
+bleibt sie nachlesbar, verschwindet aber aus der Liste.
+
+## Auf der Startseite
+
+Sind Ideen da, zeigt die Startseite unten einen Hinweis mit ihrer Anzahl.
+Das ist Absicht: ein leiser Anstoß, gelegentlich hineinzusehen — aber nichts,
+was sich zwischen die Arbeit des Tages drängt.
@@ -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).
@@ -0,0 +1,116 @@
+# Kalenderkonten verbinden
+
+Der Planer liest deine Termine, um zu wissen, **wann überhaupt Platz ist**.
+Ab M4 schreibt er Zeitblöcke in denselben Kalender zurück.
+
+![Die Seite Kalenderkonten](../bilder/kalenderkonten-hell-schreibtisch.png)
+
+## Was der Planer liest — und was nicht
+
+| Liest er                          | Nutzt er wofür                                   |
+| --------------------------------- | ------------------------------------------------ |
+| Beginn und Ende                   | Belegung gegen die Tageskapazität                |
+| Betreff                           | Anzeige in der Wochenansicht                     |
+| Ganztägig ja/nein                 | Ganztägige Termine zählen **nicht** zur Belegung |
+| „Zeigt an als" (frei, gebucht, …) | Als frei markierte Termine zählen nicht          |
+
+**Nicht gelesen** werden Teilnehmer, Beschreibungstexte, Anhänge und Orte.
+Betreffs stehen in der Datenbank, damit du sie in der Ansicht siehst — sie
+landen aber **niemals in Protokollen**.
+
+Gelesen wird ein Fenster von **7 Tagen zurück bis 90 Tage voraus**. Was aus
+diesem Fenster herauswandert, wird nachts wieder entfernt.
+
+## Einen Kalender verbinden
+
+1. Im Menü auf **Kalender**.
+2. Auf **Microsoft 365 verbinden** beziehungsweise **Google verbinden**.
+3. Beim Anbieter anmelden und der Berechtigung zustimmen.
+4. Du landest wieder hier, und der erste Abgleich läuft sofort.
+
+> **Warum fragt der Planer auch nach Schreibrechten?** Weil er ab M4
+> Zeitblöcke in den Kalender schreibt. Würde er jetzt nur Leserechte
+> anfordern, müsstest du später jedem Konto erneut zustimmen — und genau
+> daran scheitert Einrichtung erfahrungsgemäß.
+
+### Welche Anbieter es gibt
+
+Das hängt an der Instanz und ist nicht verhandelbar:
+
+|               | Firma    | Daheim |
+| ------------- | -------- | ------ |
+| Microsoft 365 | ja       | ja     |
+| Google        | **nein** | ja     |
+
+In der Firmeninstanz gibt es die Google-Seite nicht — der Aufruf endet dort
+mit „Diese Seite gibt es nicht". Das ist Absicht, kein Fehler.
+
+## Der Abgleich
+
+Alle 15 Minuten läuft der Abgleich von selbst. Mit **Jetzt abgleichen**
+stößt du ihn von Hand an.
+
+Beide Anbieter liefern nur die **Änderungen** seit dem letzten Mal, nicht
+jedes Mal alle Termine. Läuft dieser Merker ab — das passiert nach längerer
+Pause —, liest der Planer den ganzen Zeitraum neu ein. Davon merkst du außer
+einem etwas längeren Abgleich nichts.
+
+## Die Belegung
+
+Auf der Startseite zeigt jeder Bereich, wie voll der heutige Tag schon ist:
+Termine aus **allen** verbundenen Kalendern gegen die Tageskapazität dieses
+Bereichs.
+
+> **Warum zählen alle Kalender gegen jeden Bereich?** Weil ein Termin die
+> Zeit ohnehin blockiert, ganz gleich, zu welchem Lebensbereich er gehört.
+> Wer um 14 Uhr beim Zahnarzt sitzt, kann zur selben Zeit nichts für die
+> Firma tun.
+
+Gezählt wird nur, was **ins Arbeitsfenster** des Bereichs fällt. Ein Termin
+um 22 Uhr verkleinert die Kapazität eines Bereichs nicht, dessen Fenster um
+17 Uhr endet.
+
+Überlappende Termine werden zusammengelegt — eine Doppelbuchung zählt nur
+einmal.
+
+## Ein Konto umbenennen
+
+Die Bezeichnung ist frei wählbar. „Firma Outlook" oder „Gewerbe" liest sich
+besser als die Mailadresse, gerade wenn du mehrere Konten desselben
+Anbieters hast.
+
+## Ein Konto trennen
+
+Der rote Knopf, mit Rückfrage. Die gespiegelten Termine verschwinden dabei —
+**im Kalender selbst bleibt alles unangetastet**. Der Planer hat bis M4
+ohnehin nur gelesen.
+
+Zusätzlich solltest du die Berechtigung beim Anbieter selbst zurückziehen:
+
+- Microsoft: <https://myapps.microsoft.com> → _Zugriff verwalten_
+- Google: <https://myaccount.google.com/permissions>
+
+## Wenn es klemmt
+
+| Was du siehst                                               | Was dahintersteckt                                                                                                                         |
+| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| „Der Anbieter hat kein Aktualisierungstoken herausgegeben." | Meist bei Google, wenn du schon einmal zugestimmt hattest. Berechtigung im Google-Konto entziehen und neu verbinden.                       |
+| „Die Anfrage war ungültig oder zu alt."                     | Zwischen Klick und Zustimmung lagen mehr als 30 Minuten. Einfach neu beginnen.                                                             |
+| „Kein Aktualisierungstoken hinterlegt."                     | Das Konto muss neu verbunden werden. Das passiert auch, wenn `AUTH_SECRET` gewechselt wurde.                                               |
+| „Der Anbieter antwortete mit 401."                          | Die Berechtigung wurde beim Anbieter entzogen. Neu verbinden.                                                                              |
+| „unerwartete Zeitzone …, erwartet wurde UTC"                | Ein Konfigurationsfehler auf Serverseite. Bitte melden — der Planer bricht hier bewusst ab, statt Termine um Stunden zu verschieben.       |
+| Die Belegung bleibt leer                                    | Kein Kalender verbunden, oder der erste Abgleich lief noch nicht. Die Karte zeigt die Belegung erst, wenn wirklich ein Kalender dranhängt. |
+
+## Sicherheit
+
+Die Zugangstoken liegen **verschlüsselt** in der Datenbank (AES-256-GCM).
+Wer eine Sicherung in die Hände bekommt, kann damit nichts anfangen, solange
+er nicht auch `AUTH_SECRET` hat.
+
+Wird `AUTH_SECRET` gewechselt, müssen alle Kalenderkonten neu verbunden
+werden. Das ist gewollt: mit dem alten Geheimnis sind auch alle Sitzungen
+ungültig.
+
+Für die Einrichtung auf Serverseite — was in Entra ID und in der Google
+Cloud Console anzulegen ist — siehe
+[README, Abschnitt Kalenderanbieter](../../README.md#kalenderanbieter-einrichten).
@@ -0,0 +1,82 @@
+# Projekte
+
+Ein **Projekt** ist eine Klammer um mehrere Aufgaben, die zusammen ein Ziel
+erreichen: „Website neu aufsetzen", „Werkstatt umräumen", „Zertifizierung".
+
+![Die Projektübersicht](../bilder/projekte-hell-schreibtisch.png)
+
+Ein Projekt hat selbst **keinen Aufwand und keine Fälligkeit**. Beides ergibt
+sich aus dem, was drinsteckt — sonst hättest du zwei Zahlen, die auseinander
+laufen können.
+
+## Ein Projekt anlegen
+
+**Neues Projekt** oben rechts.
+
+| Feld             | Bedeutung                                                     |
+| ---------------- | ------------------------------------------------------------- |
+| **Name**         | Zwei bis 80 Zeichen, eindeutig                                |
+| **Beschreibung** | Worum es geht — und woran du merkst, dass es fertig ist       |
+| **Status**       | Aktiv, Pausiert, Abgeschlossen, Verworfen                     |
+| **Bereich**      | Optional. Neue Aufgaben im Projekt bekommen ihn vorgeschlagen |
+| **Zieltermin**   | Rein informativ; er macht keine Aufgabe überfällig            |
+
+> Der zweite Satz der Beschreibung ist der wichtigere. „Fertig ist es, wenn die
+> neue Seite online ist und das Kontaktformular ankommt" verhindert, dass ein
+> Projekt ewig weiterläuft.
+
+## Aufgaben zuordnen
+
+Zwei Wege:
+
+1. Auf der Projektseite **Aufgabe hinzufügen** — Projekt und Bereich sind dann
+   schon vorbelegt, die Art steht auf _Arbeitspaket_.
+2. In einer bestehenden Aufgabe das Feld **Projekt** setzen.
+
+### Arbeitspaket und Meilenstein
+
+Beides sind Arten von Aufgaben _innerhalb_ eines Projekts:
+
+- **Arbeitspaket** — ein Stück Arbeit mit Aufwand.
+- **Meilenstein** — ein Punkt, an dem etwas erreicht ist. Meist ohne Aufwand,
+  dafür mit Termin.
+
+## Der Fortschritt
+
+Der Balken zeigt, wie viele der zugeordneten Aufgaben erledigt sind.
+
+> **Verworfene Aufgaben zählen gar nicht mit.** Weder als erledigt noch als
+> offen. Sonst sähe ein Projekt fertig aus, weil die Hälfte gestrichen wurde —
+> und das wäre eine Zahl, die lügt.
+
+Ein Beispiel: drei Aufgaben, eine erledigt, eine offen, eine verworfen. Der
+Fortschritt ist **1 von 2 erledigt (50 %)**, nicht 33 %.
+
+Daneben steht der noch offene geschätzte Aufwand. Aufgaben ohne Schätzung
+zählen darin als null — die Zahl ist also eine Untergrenze.
+
+## Ein Projekt abschließen
+
+Status auf **Abgeschlossen** setzen. Es verschwindet damit aus der Auswahl bei
+neuen Aufgaben, bleibt aber in der Übersicht sichtbar.
+
+**Pausiert** ist für Projekte, die gerade ruhen, aber weitergehen sollen.
+
+## Ein Projekt löschen
+
+Der rote Knopf auf der Projektseite, mit Rückfrage.
+
+> **Die enthaltenen Aufgaben bleiben erhalten** und verlieren nur ihre
+> Zuordnung. Mit dem Projekt auch die Arbeit zu löschen wäre selten das, was
+> jemand will — und nie rückgängig zu machen.
+
+Willst du wirklich alles loswerden, lösche zuerst die Aufgaben über die
+Aufgabenliste (Filter _Projekt_), dann das Projekt.
+
+## Typische Fehler
+
+| Meldung                                          | Was zu tun ist                                                                  |
+| ------------------------------------------------ | ------------------------------------------------------------------------------- |
+| „Diesen Namen gibt es schon."                    | Projektnamen sind eindeutig. Vielleicht gibt es das Projekt schon abgeschlossen |
+| „Dieses Projekt gibt es nicht."                  | Es wurde inzwischen gelöscht. Seite neu laden                                   |
+| Der Fortschritt springt beim Verwerfen nach oben | Das ist richtig so: Verworfenes fällt aus der Rechnung                          |
@@ -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.
@@ -50,7 +50,12 @@ test.describe('Anmeldung', () => {
    await page.getByRole('button', { name: 'Mit Passwort anmelden' }).click()

    await expect(page.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
-    await expect(page.getByRole('link', { name: 'Bereiche' })).toBeVisible()
+    // 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()
    await expect(page).toHaveURL(/\/anmelden/)
@@ -63,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()
  })
@@ -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()
+  })
+})
@@ -0,0 +1,181 @@
+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'
+
+/**
+ * Der Weg, der in M2 wirklich zählt: erfassen, einsortieren, abhaken.
+ *
+ * Alle Testdaten tragen ein gemeinsames Präfix und werden am Ende entfernt,
+ * damit die Entwicklungsdatenbank hinterher aussieht wie vorher.
+ */
+
+const PRAEFIX = `E2E-${Date.now()}`
+
+const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
+
+test.describe('Aufgaben', () => {
+  test.skip(
+    !EMAIL || !PASSWORT || !VERBINDUNG,
+    'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
+  )
+
+  test.afterAll(async () => {
+    await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
+    await db.projekt.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
+    await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'aufgabe.' } } })
+    await db.$disconnect()
+  })
+
+  test('erfasst schnell, sortiert ein und hakt ab', async ({ page }) => {
+    const titel = `${PRAEFIX} Angebot schreiben`
+    await anmelden(page)
+
+    // --- Erfassen: ein Feld genügt --------------------------------------
+    await page.goto('/inbox')
+    await page.getByLabel('Neue Aufgabe').fill(titel)
+    await page.getByRole('button', { name: 'Erfassen' }).click()
+
+    const zeile = page.locator('li').filter({ hasText: titel })
+    await expect(zeile).toBeVisible()
+    // Ohne Bereich liegt sie in der Inbox – genau das ist der Unterschied.
+    await expect(zeile.getByText('Inbox')).toBeVisible()
+
+    // --- Einsortieren ----------------------------------------------------
+    const bereich = await db.bereich.findFirst({
+      where: { aktiv: true },
+      orderBy: { reihenfolge: 'asc' },
+      select: { id: true, name: true },
+    })
+    expect(bereich).not.toBeNull()
+
+    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)
+
+    // --- Abhaken ---------------------------------------------------------
+    await page.goto('/aufgaben')
+    const inListe = page.locator('li').filter({ hasText: titel })
+    await expect(inListe).toBeVisible()
+    await inListe.getByRole('button', { name: 'Als erledigt abhaken' }).click()
+
+    // Auf die Bestätigung warten, bevor es weitergeht: der Klick stößt eine
+    // Server Action an, und ohne diesen Haltepunkt navigiert der Test
+    // gelegentlich schneller, als gespeichert wird.
+    await expect(page.getByText('ist jetzt erledigt')).toBeVisible()
+
+    // Erledigtes fällt aus der Standardansicht heraus.
+    await page.goto('/aufgaben')
+    await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
+
+    // Mit Filter "Alle" ist sie wieder da.
+    await page.goto('/aufgaben?status=ERLEDIGT')
+    await expect(page.locator('li').filter({ hasText: titel })).toBeVisible()
+
+    const gespeichert = await db.aufgabe.findFirst({ where: { titel } })
+    expect(gespeichert?.status).toBe('ERLEDIGT')
+    expect(gespeichert?.erledigtAm).not.toBeNull()
+  })
+
+  test('macht aus einer Idee eine Aufgabe', async ({ page }) => {
+    const titel = `${PRAEFIX} Blog aufsetzen`
+    await anmelden(page)
+
+    await page.goto('/ideen')
+    await page.getByLabel('Neue Idee').fill(titel)
+    await page.getByRole('button', { name: 'Erfassen' }).click()
+
+    const zeile = page.locator('li').filter({ hasText: titel })
+    await expect(zeile).toBeVisible()
+
+    await zeile.getByRole('button', { name: 'Zur Aufgabe machen' }).click()
+    await expect(page.getByText('ist jetzt eine Aufgabe')).toBeVisible()
+
+    const danach = await db.aufgabe.findFirst({ where: { titel } })
+    expect(danach?.typ).toBe('AUFGABE')
+
+    // Aus der Ideenliste ist sie damit verschwunden.
+    await page.goto('/ideen')
+    await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
+  })
+
+  test('hält Ideen aus der Aufgabenliste heraus', async ({ page }) => {
+    const idee = `${PRAEFIX} Nur eine Idee`
+    const aufgabe = `${PRAEFIX} Eine echte Aufgabe`
+    await db.aufgabe.createMany({
+      data: [
+        { titel: idee, typ: 'IDEE' },
+        { titel: aufgabe, typ: 'AUFGABE' },
+      ],
+    })
+
+    await anmelden(page)
+
+    // In der Aufgabenliste hat die Idee nichts zu suchen.
+    await page.goto('/aufgaben')
+    await expect(page.locator('li').filter({ hasText: aufgabe })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: idee })).toHaveCount(0)
+
+    // Auch nicht in der Inbox, obwohl beide keinen Bereich haben.
+    await page.goto('/inbox')
+    await expect(page.locator('li').filter({ hasText: aufgabe })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: idee })).toHaveCount(0)
+
+    // Wer ausdrücklich danach filtert, sieht sie sehr wohl.
+    await page.goto('/aufgaben?typ=IDEE')
+    await expect(page.locator('li').filter({ hasText: idee })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: aufgabe })).toHaveCount(0)
+  })
+
+  test('filtert nach Bereich und über die Adresszeile', async ({ page }) => {
+    await anmelden(page)
+    const bereich = await db.bereich.findFirst({
+      where: { aktiv: true },
+      select: { id: true, name: true },
+    })
+
+    const drin = `${PRAEFIX} Gehört dazu`
+    const draussen = `${PRAEFIX} Gehört nicht dazu`
+    await db.aufgabe.createMany({
+      data: [
+        { titel: drin, bereichId: bereich!.id },
+        { titel: draussen, bereichId: null },
+      ],
+    })
+
+    await page.goto(`/aufgaben?bereich=${bereich!.id}`)
+    await expect(page.locator('li').filter({ hasText: drin })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: draussen })).toHaveCount(0)
+
+    // Nur Inbox zeigt genau die andere.
+    await page.goto('/aufgaben?bereich=inbox')
+    await expect(page.locator('li').filter({ hasText: draussen })).toBeVisible()
+    await expect(page.locator('li').filter({ hasText: drin })).toHaveCount(0)
+  })
+
+  test('zeigt den Fortschritt eines Projekts', async ({ page }) => {
+    const projektName = `${PRAEFIX} Website neu`
+    const projekt = await db.projekt.create({ data: { name: projektName } })
+    await db.aufgabe.createMany({
+      data: [
+        { titel: `${PRAEFIX} Entwurf`, projektId: projekt.id, status: 'ERLEDIGT' },
+        { titel: `${PRAEFIX} Umsetzung`, projektId: projekt.id, status: 'OFFEN' },
+        // Verworfenes zählt bewusst gar nicht mit.
+        { titel: `${PRAEFIX} Verworfen`, projektId: projekt.id, status: 'VERWORFEN' },
+      ],
+    })
+
+    await anmelden(page)
+    await page.goto(`/projekte/${projekt.id}`)
+
+    await expect(page.getByRole('heading', { name: projektName })).toBeVisible()
+    await expect(page.getByText('1 von 2 erledigt (50 %)')).toBeVisible()
+  })
+})
@@ -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()
+  })
+})
@@ -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 })
+}
@@ -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()
@@ -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)
+  })
+})
@@ -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$/)
+  })
+})
@@ -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,
@@ -1,15 +1,17 @@
 {
  "name": "planer",
-  "version": "0.1.0",
+  "version": "0.7.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "planer",
-      "version": "0.1.0",
+      "version": "0.7.0",
      "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",
        "@prisma/adapter-pg": "7.10.0",
        "@prisma/client": "7.10.0",
        "@radix-ui/react-avatar": "1.2.6",
@@ -36,6 +38,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": {
@@ -47,6 +50,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",
@@ -593,6 +597,45 @@
      "integrity": "sha512-lwYN/vDPeNRULcepoE/LO2Pgx+7/RV+S9ARfbc9lr2DtGkOD7pAiruHvbR1RX3Qyf6ja47EWJDMsNK5vK08DJg==",
      "license": "MIT"
    },
+    "node_modules/@dnd-kit/accessibility": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
+      "integrity": "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/core": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/core/-/core-6.3.1.tgz",
+      "integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/accessibility": "^3.1.1",
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+        "react-dom": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/utilities": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
+      "integrity": "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
    "node_modules/@electric-sql/pglite": {
      "version": "0.4.3",
      "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.4.3.tgz",
@@ -4504,6 +4547,16 @@
        "@types/react": "^19.3.0"
      }
    },
+    "node_modules/@types/web-push": {
+      "version": "3.6.4",
+      "resolved": "https://registry.npmjs.org/@types/web-push/-/web-push-3.6.4.tgz",
+      "integrity": "sha512-GnJmSr40H3RAnj0s34FNTcJi1hmWFV5KXugE0mYWnYhgTAHLJ/dJKAwDmvPJYMke0RplY2XE9LnM4hqSqKIjhQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
    "node_modules/@typescript-eslint/eslint-plugin": {
      "version": "8.70.0",
      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.70.0.tgz",
@@ -5405,6 +5458,15 @@
        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
      }
    },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
    "node_modules/ajv": {
      "version": "6.15.0",
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
@@ -5637,6 +5699,18 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/asn1.js": {
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
+      "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
+      "license": "MIT",
+      "dependencies": {
+        "bn.js": "^4.0.0",
+        "inherits": "^2.0.1",
+        "minimalistic-assert": "^1.0.0",
+        "safer-buffer": "^2.1.0"
+      }
+    },
    "node_modules/asn1js": {
      "version": "3.0.10",
      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
@@ -5791,6 +5865,12 @@
        "require-from-string": "^2.0.2"
      }
    },
+    "node_modules/bn.js": {
+      "version": "4.12.5",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.5.tgz",
+      "integrity": "sha512-3aRg6/JxfffFD+OlOjOFR3Vo79l39ooBTFucxx+MT3dhCtzn3EmiUPQo+6/OZuI2jbXi3YKgmiTFBgChQMwIRQ==",
+      "license": "MIT"
+    },
    "node_modules/brace-expansion": {
      "version": "5.0.9",
      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
@@ -5851,6 +5931,12 @@
        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
      }
    },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
    "node_modules/c12": {
      "version": "3.3.4",
      "resolved": "https://registry.npmjs.org/c12/-/c12-3.3.4.tgz",
@@ -6372,7 +6458,6 @@
      "version": "4.4.3",
      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ms": "^2.1.3"
@@ -6556,6 +6641,15 @@
        "node": ">= 0.4"
      }
    },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
    "node_modules/effect": {
      "version": "3.20.0",
      "resolved": "https://registry.npmjs.org/effect/-/effect-3.20.0.tgz",
@@ -8044,6 +8138,28 @@
        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
      }
    },
+    "node_modules/http_ece": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/http_ece/-/http_ece-1.2.0.tgz",
+      "integrity": "sha512-JrF8SSLVmcvc5NducxgyOrKXe3EsyHMgBFgSaIUGmArKe+rwr0uphRkRXvwiom3I+fpIfoItveHrfudL8/rxuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
    "node_modules/iconv-lite": {
      "version": "0.7.3",
      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz",
@@ -8098,6 +8214,12 @@
        "node": ">=0.8.19"
      }
    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
    "node_modules/internal-slot": {
      "version": "1.1.0",
      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
@@ -8763,6 +8885,27 @@
        "node": ">=4.0"
      }
    },
+    "node_modules/jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
+      "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^2.0.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
    "node_modules/keyv": {
      "version": "4.5.4",
      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -9239,6 +9382,12 @@
        "node": ">=8.6"
      }
    },
+    "node_modules/minimalistic-assert": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz",
+      "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==",
+      "license": "ISC"
+    },
    "node_modules/minimatch": {
      "version": "10.2.6",
      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
@@ -9259,7 +9408,6 @@
      "version": "1.2.8",
      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-      "dev": true,
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
@@ -9269,7 +9417,6 @@
      "version": "2.1.3",
      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-      "dev": true,
      "license": "MIT"
    },
    "node_modules/mysql2": {
@@ -10690,6 +10837,26 @@
        "url": "https://github.com/sponsors/ljharb"
      }
    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
    "node_modules/safe-push-apply": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
@@ -10752,7 +10919,6 @@
      "version": "2.1.2",
      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
-      "devOptional": true,
      "license": "MIT"
    },
    "node_modules/saxes": {
@@ -12357,6 +12523,25 @@
        "node": ">=18"
      }
    },
+    "node_modules/web-push": {
+      "version": "3.6.7",
+      "resolved": "https://registry.npmjs.org/web-push/-/web-push-3.6.7.tgz",
+      "integrity": "sha512-OpiIUe8cuGjrj3mMBFWY+e4MMIkW3SVT+7vEIjvD9kejGUypv8GPDf84JdPWskK8zMRIJ6xYGm+Kxr8YkPyA0A==",
+      "license": "MPL-2.0",
+      "dependencies": {
+        "asn1.js": "^5.3.0",
+        "http_ece": "1.2.0",
+        "https-proxy-agent": "^7.0.0",
+        "jws": "^4.0.0",
+        "minimist": "^1.2.5"
+      },
+      "bin": {
+        "web-push": "src/cli.js"
+      },
+      "engines": {
+        "node": ">= 16"
+      }
+    },
    "node_modules/webidl-conversions": {
      "version": "8.0.1",
      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
@@ -1,6 +1,6 @@
 {
  "name": "planer",
-  "version": "0.1.0",
+  "version": "0.7.0",
  "private": true,
  "description": "Aufgaben, Ideen, Projekte und Zeitblöcke mit Anbindung an Microsoft 365 und Google Kalender",
  "type": "module",
@@ -40,6 +40,8 @@
  "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",
    "@prisma/adapter-pg": "7.10.0",
    "@prisma/client": "7.10.0",
    "@radix-ui/react-avatar": "1.2.6",
@@ -66,6 +68,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 +80,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",
@@ -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,
    },
  },
 })
@@ -105,6 +105,118 @@ const PROTOKOLL = [
  },
 ]

+/**
+ * Erfundene Aufgaben. Die Fälligkeit steht als Versatz in Tagen zum festen
+ * Demo-Zeitpunkt, damit die Bilder immer dieselbe Mischung aus überfällig,
+ * heute und später zeigen.
+ */
+const AUFGABEN = [
+  // Überfällig
+  {
+    titel: 'Angebot Heizungstausch nachfassen',
+    bereich: 'Gewerbe',
+    versatz: -3,
+    prioritaet: 2,
+    aufwand: 30,
+  },
+  {
+    titel: 'Rechnung 2026-114 korrigieren',
+    bereich: 'Gewerbe',
+    versatz: -1,
+    prioritaet: 1,
+    aufwand: 20,
+  },
+  // Heute und morgen
+  {
+    titel: 'Wochenbericht an die Geschäftsführung',
+    bereich: 'Firma',
+    versatz: 0,
+    prioritaet: 2,
+    aufwand: 45,
+  },
+  {
+    titel: 'Rückruf Frau Sonnenberg',
+    bereich: 'Firma',
+    versatz: 0,
+    prioritaet: 1,
+    aufwand: 15,
+  },
+  {
+    titel: 'Zahnarzttermin bestätigen',
+    bereich: 'Privat',
+    versatz: 1,
+    prioritaet: 3,
+    aufwand: 10,
+  },
+  // Später
+  {
+    titel: 'Backup-Strategie für den Server überdenken',
+    bereich: 'Homelab',
+    versatz: 9,
+    prioritaet: 4,
+    aufwand: 120,
+  },
+  {
+    titel: 'Reifen wechseln lassen',
+    bereich: 'Privat',
+    versatz: 14,
+    prioritaet: 3,
+    aufwand: 60,
+  },
+  // Ohne Termin
+  {
+    titel: 'Ablage im Keller sortieren',
+    bereich: 'Privat',
+    versatz: null,
+    prioritaet: 5,
+    aufwand: 180,
+  },
+  // Erledigt
+  {
+    titel: 'Steuerunterlagen zusammenstellen',
+    bereich: 'Gewerbe',
+    versatz: -5,
+    prioritaet: 3,
+    aufwand: 90,
+    status: 'ERLEDIGT' as const,
+  },
+]
+
+/** Liegt noch in der Inbox – ohne Bereich. */
+const INBOX = [
+  { titel: 'Sicherungskasten beschriften' },
+  { titel: 'Angebot Netzwerkschrank einholen' },
+]
+
+const IDEEN = [
+  { titel: 'Newsletter für Bestandskunden' },
+  { titel: 'Werkstatt-Podcast aufnehmen' },
+  { titel: 'Regale im Lager neu beschriften' },
+]
+
+const PROJEKT_AUFGABEN = [
+  {
+    titel: 'Anforderungen sammeln',
+    typ: 'ARBEITSPAKET' as const,
+    status: 'ERLEDIGT' as const,
+  },
+  {
+    titel: 'Entwurf abstimmen',
+    typ: 'ARBEITSPAKET' as const,
+    status: 'ERLEDIGT' as const,
+  },
+  { titel: 'Texte schreiben', typ: 'ARBEITSPAKET' as const, status: 'OFFEN' as const },
+  { titel: 'Fotos beauftragen', typ: 'ARBEITSPAKET' as const, status: 'WARTET' as const },
+  { titel: 'Seite ist online', typ: 'MEILENSTEIN' as const, status: 'OFFEN' as const },
+]
+
+/** Fester Bezugspunkt, passend zu src/server/zeitgeber.ts. */
+const DEMO_JETZT = new Date('2026-03-17T08:20:00.000Z')
+
+function tageVersetzt(tage: number): Date {
+  return new Date(DEMO_JETZT.getTime() + tage * 24 * 60 * 60 * 1000)
+}
+
 async function main(): Promise<void> {
  console.log('Demo-Daten einspielen.')

@@ -158,6 +270,263 @@ async function main(): Promise<void> {
    },
  })

+  // --- Aufgaben, Ideen und ein Projekt -------------------------------------
+  await db.aufgabe.deleteMany({})
+  await db.projekt.deleteMany({})
+
+  const bereichsKennung = new Map(
+    (await db.bereich.findMany({ select: { id: true, name: true } })).map((b) => [
+      b.name,
+      b.id,
+    ]),
+  )
+
+  for (const eintrag of AUFGABEN) {
+    await db.aufgabe.create({
+      data: {
+        titel: eintrag.titel,
+        bereichId: bereichsKennung.get(eintrag.bereich) ?? null,
+        prioritaet: eintrag.prioritaet,
+        aufwandMinuten: eintrag.aufwand,
+        faelligAm: eintrag.versatz === null ? null : tageVersetzt(eintrag.versatz),
+        status: eintrag.status ?? 'OFFEN',
+        erledigtAm: eintrag.status === 'ERLEDIGT' ? tageVersetzt(-4) : null,
+      },
+    })
+  }
+
+  for (const eintrag of INBOX) {
+    await db.aufgabe.create({ data: { titel: eintrag.titel } })
+  }
+
+  for (const eintrag of IDEEN) {
+    await db.aufgabe.create({ data: { titel: eintrag.titel, typ: 'IDEE' } })
+  }
+
+  const projekt = await db.projekt.create({
+    data: {
+      name: 'Website neu aufsetzen',
+      beschreibung:
+        'Der alte Auftritt ist von 2019 und auf dem Handy kaum lesbar. Fertig ist es, wenn die neue Seite online ist und das Kontaktformular ankommt.',
+      bereichId: bereichsKennung.get('Gewerbe') ?? null,
+      zielAm: tageVersetzt(45),
+    },
+  })
+
+  for (const eintrag of PROJEKT_AUFGABEN) {
+    await db.aufgabe.create({
+      data: {
+        titel: eintrag.titel,
+        typ: eintrag.typ,
+        status: eintrag.status,
+        projektId: projekt.id,
+        bereichId: bereichsKennung.get('Gewerbe') ?? null,
+        aufwandMinuten: eintrag.typ === 'MEILENSTEIN' ? null : 120,
+        erledigtAm: eintrag.status === 'ERLEDIGT' ? tageVersetzt(-7) : null,
+      },
+    })
+  }
+
+  // --- Kalenderkonto und erfundene Termine ---------------------------------
+  // Die Tokens sind absichtlich Unsinn: die Screenshot-Instanz spricht mit
+  // keinem Anbieter, sie soll die Seite nur nicht leer zeigen.
+  await db.kalenderkonto.deleteMany({})
+  const kalenderkonto = await db.kalenderkonto.create({
+    data: {
+      benutzerId: benutzer.id,
+      anbieter: 'GRAPH',
+      anzeigename: 'Firma Outlook',
+      extKontoId: 'martina.beispiel@firma.invalid',
+      letzterAbgleich: new Date(DEMO_JETZT.getTime() - 6 * 60_000),
+    },
+  })
+
+  const TERMINE = [
+    { betreff: 'Wochenbesprechung', vonStunde: 8, bisStunde: 9 },
+    { betreff: 'Kundengespräch Sonnenberg', vonStunde: 10, bisStunde: 11 },
+    { betreff: 'Mittagspause', vonStunde: 11, bisStunde: 12, frei: true },
+    { betreff: 'Abnahme Baustelle', vonStunde: 13, bisStunde: 15 },
+  ]
+
+  for (const eintrag of TERMINE) {
+    await db.termin.create({
+      data: {
+        kalenderkontoId: kalenderkonto.id,
+        extId: `demo-${eintrag.betreff.toLowerCase().replace(/[^a-z]+/g, '-')}`,
+        betreff: eintrag.betreff,
+        beginn: new Date(Date.UTC(2026, 2, 17, eintrag.vonStunde - 1, 0)),
+        ende: new Date(Date.UTC(2026, 2, 17, eintrag.bisStunde - 1, 0)),
+        zeigtAls: eintrag.frei ? 'FREI' : 'GEBUCHT',
+      },
+    })
+  }
+
+  await db.termin.create({
+    data: {
+      kalenderkontoId: kalenderkonto.id,
+      extId: 'demo-brueckentag',
+      betreff: 'Brückentag',
+      beginn: new Date(Date.UTC(2026, 2, 20, 0, 0)),
+      ende: new Date(Date.UTC(2026, 2, 21, 0, 0)),
+      ganztaegig: true,
+      zeigtAls: 'ABWESEND',
+    },
+  })
+
+  // --- 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: {
+      titel: 'Störung Klimagerät Serverraum prüfen',
+      bereichId: bereichsKennung.get('Firma') ?? null,
+      prioritaet: 2,
+      aufwandMinuten: 60,
+      faelligAm: tageVersetzt(2),
+      quelle: 'ZAMMAD',
+      quelleRef: 'demo-38421',
+      quelleUrl: 'https://zammad.example.invalid/ticket/38421',
+    },
+  })
+
+  // --- 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}`)
 }

@@ -0,0 +1,80 @@
+-- CreateEnum
+CREATE TYPE "AufgabenTyp" AS ENUM ('AUFGABE', 'IDEE', 'ARBEITSPAKET', 'MEILENSTEIN', 'SPIEGEL');
+
+-- CreateEnum
+CREATE TYPE "AufgabenStatus" AS ENUM ('OFFEN', 'GEPLANT', 'WARTET', 'ERLEDIGT', 'VERWORFEN');
+
+-- CreateEnum
+CREATE TYPE "Quelle" AS ENUM ('MANUELL', 'ZAMMAD', 'WARTUNGSPLANER', 'TELEGRAM', 'SPIEGEL', 'MAIL', 'API', 'MCP');
+
+-- CreateEnum
+CREATE TYPE "ProjektStatus" AS ENUM ('AKTIV', 'PAUSIERT', 'ABGESCHLOSSEN', 'VERWORFEN');
+
+-- CreateTable
+CREATE TABLE "projekt" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "beschreibung" TEXT,
+    "status" "ProjektStatus" NOT NULL DEFAULT 'AKTIV',
+    "bereichId" TEXT,
+    "zielAm" TIMESTAMP(3),
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "projekt_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "aufgabe" (
+    "id" TEXT NOT NULL,
+    "titel" TEXT NOT NULL,
+    "notiz" TEXT,
+    "typ" "AufgabenTyp" NOT NULL DEFAULT 'AUFGABE',
+    "status" "AufgabenStatus" NOT NULL DEFAULT 'OFFEN',
+    "prioritaet" INTEGER NOT NULL DEFAULT 3,
+    "aufwandMinuten" INTEGER,
+    "faelligAm" TIMESTAMP(3),
+    "erledigtAm" TIMESTAMP(3),
+    "bereichId" TEXT,
+    "projektId" TEXT,
+    "quelle" "Quelle" NOT NULL DEFAULT 'MANUELL',
+    "quelleUrl" TEXT,
+    "quelleRef" TEXT,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "aufgabe_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "projekt_status_idx" ON "projekt"("status");
+
+-- CreateIndex
+CREATE INDEX "projekt_bereichId_idx" ON "projekt"("bereichId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "projekt_name_key" ON "projekt"("name");
+
+-- CreateIndex
+CREATE INDEX "aufgabe_status_faelligAm_idx" ON "aufgabe"("status", "faelligAm");
+
+-- CreateIndex
+CREATE INDEX "aufgabe_bereichId_status_idx" ON "aufgabe"("bereichId", "status");
+
+-- CreateIndex
+CREATE INDEX "aufgabe_projektId_idx" ON "aufgabe"("projektId");
+
+-- CreateIndex
+CREATE INDEX "aufgabe_typ_status_idx" ON "aufgabe"("typ", "status");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "aufgabe_quelle_quelleRef_key" ON "aufgabe"("quelle", "quelleRef");
+
+-- AddForeignKey
+ALTER TABLE "projekt" ADD CONSTRAINT "projekt_bereichId_fkey" FOREIGN KEY ("bereichId") REFERENCES "bereich"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "aufgabe" ADD CONSTRAINT "aufgabe_bereichId_fkey" FOREIGN KEY ("bereichId") REFERENCES "bereich"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "aufgabe" ADD CONSTRAINT "aufgabe_projektId_fkey" FOREIGN KEY ("projektId") REFERENCES "projekt"("id") ON DELETE SET NULL ON UPDATE CASCADE;
@@ -0,0 +1,70 @@
+-- CreateEnum
+CREATE TYPE "KalenderAnbieter" AS ENUM ('GRAPH', 'GOOGLE');
+
+-- CreateEnum
+CREATE TYPE "ZeigtAls" AS ENUM ('FREI', 'GEBUCHT', 'MIT_VORBEHALT', 'ABWESEND', 'WOANDERS', 'UNBEKANNT');
+
+-- AlterTable
+ALTER TABLE "bereich" ADD COLUMN     "standardKalenderkontoId" TEXT;
+
+-- CreateTable
+CREATE TABLE "kalenderkonto" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "anbieter" "KalenderAnbieter" NOT NULL,
+    "anzeigename" TEXT NOT NULL,
+    "extKontoId" TEXT NOT NULL,
+    "kalenderId" TEXT,
+    "zugriffstoken" TEXT,
+    "aktualisierungstoken" TEXT,
+    "tokenGueltigBis" TIMESTAMP(3),
+    "bereiche" TEXT,
+    "deltaVerweis" TEXT,
+    "letzterAbgleich" TIMESTAMP(3),
+    "letzterFehler" TEXT,
+    "aktiv" BOOLEAN NOT NULL DEFAULT true,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "kalenderkonto_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "termin" (
+    "id" TEXT NOT NULL,
+    "kalenderkontoId" TEXT NOT NULL,
+    "extId" TEXT NOT NULL,
+    "etag" TEXT,
+    "betreff" TEXT,
+    "beginn" TIMESTAMP(3) NOT NULL,
+    "ende" TIMESTAMP(3) NOT NULL,
+    "ganztaegig" BOOLEAN NOT NULL DEFAULT false,
+    "zeigtAls" "ZeigtAls" NOT NULL DEFAULT 'GEBUCHT',
+    "aktualisiertAm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "termin_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "kalenderkonto_benutzerId_aktiv_idx" ON "kalenderkonto"("benutzerId", "aktiv");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "kalenderkonto_benutzerId_anbieter_extKontoId_kalenderId_key" ON "kalenderkonto"("benutzerId", "anbieter", "extKontoId", "kalenderId");
+
+-- CreateIndex
+CREATE INDEX "termin_kalenderkontoId_beginn_idx" ON "termin"("kalenderkontoId", "beginn");
+
+-- CreateIndex
+CREATE INDEX "termin_beginn_ende_idx" ON "termin"("beginn", "ende");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "termin_kalenderkontoId_extId_key" ON "termin"("kalenderkontoId", "extId");
+
+-- AddForeignKey
+ALTER TABLE "bereich" ADD CONSTRAINT "bereich_standardKalenderkontoId_fkey" FOREIGN KEY ("standardKalenderkontoId") REFERENCES "kalenderkonto"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "kalenderkonto" ADD CONSTRAINT "kalenderkonto_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "termin" ADD CONSTRAINT "termin_kalenderkontoId_fkey" FOREIGN KEY ("kalenderkontoId") REFERENCES "kalenderkonto"("id") ON DELETE CASCADE ON UPDATE CASCADE;
@@ -0,0 +1,9 @@
+/*
+  Warnings:
+
+  - Made the column `kalenderId` on table `kalenderkonto` required. This step will fail if there are existing NULL values in that column.
+
+*/
+-- AlterTable
+ALTER TABLE "kalenderkonto" ALTER COLUMN "kalenderId" SET NOT NULL,
+ALTER COLUMN "kalenderId" SET DEFAULT 'standard';
@@ -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;
@@ -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;
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "kalenderkonto" ADD COLUMN     "fehlversuche" INTEGER NOT NULL DEFAULT 0;
@@ -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;
@@ -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");
--- a/Show More
+++ b/Show More