Merge: Release v1.10.1

Zwei Aenderungen seit 1.10.0, beide bereits auf main: das Kennzeichen fuer
ein verknuepftes Git-Issue auf der Aufgabenkarte (#12) und die Token-Rechte,
Aufruf fuer Aufruf belegt (#10). Dazu die Korrektur am Hinweis unter dem
Token-Feld, der die Rechte fuer Actions nicht nannte - ohne die sieht bei
GitHub niemand einen CI-Zustand.

Verlauf und Versionsnummer wandern zusammen, sonst laufen sie auseinander;
changelog.test.ts haelt das fest. Die package-lock.json stand noch auf 1.2.0
und beschrieb damit ein Paket, das es so nie gab - mitgezogen.

Refs #10
Refs #12

.env.example

@@ -23,11 +23,13 @@ APP_URL="http://localhost:3000"
 
 # Port innerhalb des Containers bzw. im Standalone-Betrieb
 PORT="3000"
-# Host-Port-Mapping fuer den App-Container (--profile full)
-APP_PORT="3000"
+# Host-Port-Mapping fuer den App-Container (--profile full). Nur auf dem
+# Loopback – nach draussen geht es ueber einen Reverse Proxy. Soll die
+# Instanz im LAN erreichbar sein, hier "3000" eintragen.
+APP_PORT="127.0.0.1:3000"
 
 # ── Datenbank ────────────────────────────────────────────────
-# Standalone-Betrieb: App laeuft lokal, Postgres via "docker compose up -d db"
+# Standalone-Betrieb: App laeuft lokal, Postgres via "npm run docker:db"
 # oder als nativ installierter Dienst.
 DATABASE_URL="postgresql://nebula:nebula@localhost:5432/nebula?schema=public"
 
@@ -38,10 +40,24 @@ DATABASE_URL="postgresql://nebula:nebula@localhost:5432/nebula?schema=public"
 POSTGRES_USER="nebula"
 POSTGRES_PASSWORD="nebula"
 POSTGRES_DB="nebula"
-# Host-Port, unter dem die Datenbank erreichbar ist
-POSTGRES_PORT="5432"
+# Host-Port der Datenbank. Wirkt NUR zusammen mit docker-compose.dev.yml
+# (npm run docker:db) – die Basisdatei veroeffentlicht keinen DB-Port, weil
+# die Anwendung im Container "db:5432" anspricht und nichts davon nach
+# aussen muss. Auf einem Server bleibt dieser Wert also folgenlos.
+POSTGRES_PORT="127.0.0.1:5432"
 # Host-Port fuer Adminer (--profile tools)
-ADMINER_PORT="8080"
+ADMINER_PORT="127.0.0.1:8080"
+
+# ── Betrieb ohne veroeffentlichte Ports ──────────────────────
+# Liegen mehrere Stacks auf demselben Docker-Host und regelt ein gemeinsamer
+# Reverse Proxy den Zugang, veroeffentlicht Nebula gar keinen Port. Dann diese
+# beiden Zeilen aktivieren – danach genuegt ueberall "docker compose up -d":
+# COMPOSE_FILE="docker-compose.yml:docker-compose.server.yml"
+# COMPOSE_PROFILES="full"
+#
+# Name des geteilten Netzes und der Alias, unter dem der Proxy Nebula findet.
+# PROXY_NETWORK="proxy"
+# PROXY_ALIAS="nebula"
 
 # ── Sicherheit ───────────────────────────────────────────────
 # Schluessel zur Verschluesselung der Git-Access-Tokens (AES-256-GCM).
@@ -53,9 +69,14 @@ ADMINER_PORT="8080"
 # und Passkeys sind davon nicht betroffen.
 APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
 
-# Lebensdauer einer Anmeldung in Tagen.
+# Absolute Lebensdauer einer Anmeldung in Tagen – ab dem Anmelden gerechnet
+# und nicht verlaengerbar.
 SESSION_TTL_DAYS="30"
 
+# Leerlauffrist in Stunden: so lange darf eine Sitzung unbenutzt bleiben.
+# Wird bei jeder Nutzung neu angestossen. 0 schaltet die Pruefung ab.
+SESSION_IDLE_HOURS="8"
+
 # ── Benachrichtigungen ───────────────────────────────────────
 # ntfy und Webhook brauchen nichts weiter – die Ziele werden in der
 # Anwendung unter "Mein Konto" eingerichtet.

CLAUDE.md

@@ -9,7 +9,8 @@ Betrieb: [README.md](README.md) · Server: [DEPLOYMENT.md](DEPLOYMENT.md)
 ## Womit man arbeitet
 
 ```bash
-docker compose up -d db        # Postgres, muss laufen
+npm run docker:db              # Postgres, muss laufen (mit dem dev-Overlay,
+                               # sonst hat die DB keinen Host-Port)
 npm run dev                    # Entwicklung
 npm test                       # Unit-Tests (Vitest, ohne DB)
 npx tsc --noEmit               # Typprüfung
@@ -63,6 +64,31 @@ SSRF-Schutz (`lib/security/ssrf.ts`).
 - **Datumsangaben** über `lib/utils` formatieren (feste Zeitzone), sonst
   weichen Server-Render und Hydration voneinander ab. Relative Zeiten
   bekommen `suppressHydrationWarning`.
+- **Die feste Zeitzone gilt auch beim *Rechnen*, nicht nur beim Formatieren.**
+  Im Container läuft die Anwendung nach UTC; „welcher Kalendertag" und
+  „welche Woche" kippen dort abends um einen Tag. `lib/tasks` (`dueBucket`)
+  und `lib/review` (`wocheUm`) rechnen deshalb über Berliner Kalendertage.
+  Und eine Woche ist **nicht** „7 × 24 Stunden" — bei einer Zeitumstellung
+  hat sie 167 oder 169.
+- **`min-width: auto` bei Flex- und Grid-Kindern.** Hat hier zweimal
+  zugeschlagen: ein Kind weigert sich, unter die Inhaltsbreite seines
+  breitesten Kindes zu schrumpfen, und drückt stattdessen die Nachbarn aus
+  dem Bild. Einmal war es ein Sortierfeld mit `min-width`, das „Neues
+  Projekt" hinausschob; einmal die Heatmap, die die ganze Projektseite
+  doppelt so breit machte. Heilmittel ist beide Male `min-w-0` am Kind —
+  ohne das greift auch ein `overflow-x-auto` darin nicht.
+- **`body { overflow-x: hidden }` versteckt genau diese Fehler.** Es steht in
+  `globals.css` als Notnagel; was es abschneidet, ist auf dem Telefon
+  schlicht nicht mehr erreichbar. Ursachen gehören in die Komponente.
+- **Dialoge müssen der Bildschirmtastatur ausweichen.** Sie verkleinert nur
+  das *sichtbare* Fenster, nicht das Layoutfenster — `position: fixed` und
+  `100vh` beziehen sich weiter auf das volle. `components/ui/Modal.tsx` hängt
+  dafür an `window.visualViewport`; wer ein eigenes Overlay baut, braucht
+  dasselbe.
+- **Blättern über Cursor, nicht über `skip`.** Der Aktivitätsverlauf schreibt
+  mehrere Zeilen im selben Augenblick; ein Offset über so eine Grenze hinweg
+  überspringt oder verdoppelt lautlos. Muster in `lib/timeline.ts`:
+  `(createdAt, id)` als Cursor, Sortierung identisch zur Bedingung.
 
 ## Migrationen
 
@@ -82,9 +108,24 @@ vergleicht mit der *laufenden* Datenbank. Ist eine eben erzeugte Migration
 dort noch nicht eingespielt, steht ihr Inhalt in der nächsten gleich noch
 einmal.
 
-**Die erzeugte SQL vor dem Anwenden lesen.** Der Volltextindex
-`Note_fulltext_idx` ist ein Ausdrucksindex, den Prisma nicht kennt (er wird
-bislang in Ruhe gelassen, aber das ist nicht garantiert).
+**Das Zielverzeichnis vorher *nicht* anlegen.** Ein leerer Ordner unter
+`prisma/migrations/` lässt `--from-migrations` mit `P3015` abbrechen
+(„Could not find the migration file"). Erst die SQL woandershin erzeugen,
+dann Ordner anlegen und hineinkopieren.
+
+**Die erzeugte SQL vor dem Anwenden lesen.** Die Volltextindizes
+`Note_fulltext_idx` und `Task_fulltext_idx` sind Ausdrucksindizes, die Prisma
+nicht kennt (sie werden bislang in Ruhe gelassen, aber das ist nicht
+garantiert).
+
+**Ein Ausdrucksindex greift nur bei Zeichengleichheit.** Weicht der Ausdruck
+in der Abfrage auch nur in einem `coalesce` vom Index ab, rechnet Postgres
+`to_tsvector` je Zeile neu — ohne Fehlermeldung. Nachsehen statt annehmen:
+
+```bash
+docker exec nebula-db psql -U nebula -d <db> -c "SET enable_seqscan = off;
+EXPLAIN (COSTS OFF) SELECT …"    # muss einen Bitmap Index Scan zeigen
+```
 
 **Datenmigrationen von Hand schreiben.** `migrate diff` kennt nur den
 Zielzustand: Spalten, die woandershin wandern, würde es ersatzlos löschen.
@@ -102,6 +143,18 @@ Bei Änderungen an der Oberfläche **hinsehen**. Chrome ist installiert, ein
 Skript mit `playwright-core` und `channel: "chrome"` genügt für Screenshots.
 Mehrere Anzeigefehler dieses Projekts sind ausschließlich so aufgefallen.
 
+**Seitlichen Überlauf misst man.** `document.documentElement.scrollWidth`
+gegen `clientWidth` auf 375 px — das findet in Sekunden, was beim Ansehen
+durchrutscht. Ein Skript, das dabei nur die *obersten* Verursacher meldet
+(Eltern, die selbst schon überlaufen, herausfiltern), ist deutlich brauchbarer
+als eine Liste aller betroffenen Knoten.
+
+**Die Testdaten müssen die Bausteine enthalten, um die es geht.** Eine
+Messung gegen ein Projekt ohne Repository, ohne Snapshot und ohne README
+bescheinigte hier einmal „alles in Ordnung", während die echte Projektseite
+doppelt so breit war wie der Bildschirm. Erst mit vollständigen Daten
+nachgestellt trat der Fehler zutage.
+
 **Barrierefreiheit misst man, statt sie zu behaupten.** `axe-core` liegt als
 Entwicklungsabhängigkeit bereit; ein Skript hängt es per `addScriptTag` in
 die laufende Seite und ruft `axe.run` mit den WCAG-Tags auf. Jeder

DEPLOYMENT.md

@@ -13,6 +13,7 @@ Für Installation zum Ausprobieren und die Entwicklungsvarianten siehe
 | | |
 | --- | --- |
 | Server | Linux mit Docker Engine ≥ 24 und Compose v2 |
+| Sonst | `git`, `curl`, eine POSIX-Shell — **kein Node, kein npm** |
 | Arbeitsspeicher | 1 GB reichen; beim Bauen kurzzeitig ~2 GB |
 | Plattenplatz | ~2 GB für Abbilder, dazu die Datenbank |
 | Domain | Eine (Unter-)Domain, die auf den Server zeigt |
@@ -46,17 +47,22 @@ cd /opt/nebula
 ## 3 · Konfigurieren
 
 ```bash
-node scripts/setup.mjs        # legt .env an und würfelt ein APP_SECRET
+./scripts/setup.sh        # legt .env an, würfelt ein APP_SECRET, setzt Rechte 600
 ```
 
-Ohne Node auf dem Server: `cp .env.example .env` und das Geheimnis von Hand
-setzen —
+Das Skript ist reines POSIX-Shell und braucht **kein Node** — auf einem
+reinen Docker-Host ist keins installiert. Es nimmt `openssl`, falls
+vorhanden, sonst `/dev/urandom`.
+
+Ganz von Hand geht auch:
 
 ```bash
-openssl rand -base64 48
+cp .env.example .env
+chmod 600 .env
+openssl rand -base64 32        # den Wert als APP_SECRET eintragen
 ```
 
-Dann die `.env` öffnen und mindestens diese vier Werte anpassen:
+Dann die `.env` öffnen und mindestens diese drei Werte anpassen:
 
 ```env
 # Die Adresse, unter der du Nebula im Browser aufrufst.
@@ -68,11 +74,11 @@ APP_SECRET="…dein-langer-zufallswert…"
 
 # Das Datenbankpasswort. Die Voreinstellung „nebula" ist für Entwicklung.
 POSTGRES_PASSWORD="…noch-ein-langer-zufallswert…"
-
-# Nur lokal lauschen — nach außen geht es über den Reverse Proxy (Schritt 6).
-APP_PORT=127.0.0.1:3000
 ```
 
+Die Ports müssen nicht angefasst werden: `APP_PORT` steht schon auf
+`127.0.0.1:3000`, und die Datenbank veröffentlicht gar nichts.
+
 > **`APP_SECRET` später zu ändern** macht gespeicherte Git-Tokens unlesbar.
 > Sie müssen dann neu hinterlegt werden. Konten, Passwörter und Passkeys
 > bleiben unberührt.
@@ -80,19 +86,60 @@ APP_PORT=127.0.0.1:3000
 > **`APP_URL` später zu ändern** macht bestehende **Passkeys ungültig**, weil
 > sie an die rpID gebunden sind. Passwörter funktionieren weiter.
 
-### Datenbankport schließen
+### Welche Ports überhaupt hinausgehen
 
-`docker-compose.yml` bildet Postgres standardmäßig auf `5432` ab, damit man
-in der Entwicklung von außen drankommt. Auf einem Server hat die Datenbank
-nichts im Internet zu suchen:
+Nach einer regulären Installation ist es **genau einer**:
 
-```env
-POSTGRES_PORT=127.0.0.1:5432
+| Container | Host-Port | Wann |
+| --- | --- | --- |
+| `nebula-app` | `APP_PORT`, Vorgabe `127.0.0.1:3000` | `--profile full` |
+| `nebula-db` | — | **nie** |
+| `nebula-adminer` | `ADMINER_PORT`, Vorgabe `127.0.0.1:8080` | nur `--profile tools` |
+
+**Die Datenbank veröffentlicht nichts.** Im Vollbetrieb spricht die Anwendung
+Postgres über das interne Docker-Netz als `db:5432` an — die `DATABASE_URL`
+setzt Compose selbst. Auch `scripts/backup.sh` und `restore.sh` gehen über
+`docker exec`, nicht über den Host. Ein Host-Port wäre nur eine zusätzliche
+Angriffsfläche und würde mit anderen Postgres-Containern auf demselben Host
+um den Port streiten.
+
+Wer die Datenbank beim Entwickeln doch vom Host aus braucht — `npm run dev`
+läuft ja außerhalb des Containers — nimmt `docker-compose.dev.yml` dazu
+(`npm run docker:db`). Auf einem Server hat diese Datei nichts zu suchen.
+
+Auch der Port der Anwendung liegt auf `127.0.0.1`: nach draußen geht es über
+den Reverse Proxy aus Schritt 6.
+
+### Variante: gar keinen Port veröffentlichen
+
+Liegen mehrere Stacks auf demselben Docker-Host und regelt ein gemeinsamer
+Reverse Proxy den Zugang, braucht Nebula überhaupt keinen Host-Port. Dafür
+gibt es **`docker-compose.server.yml`**: es nimmt die letzte verbliebene
+Freigabe zurück und hängt die Anwendung in ein geteiltes Netz.
+
+```bash
+docker network create proxy      # falls der Proxy-Stack es nicht schon anlegt
 ```
 
-Noch besser: die `ports:`-Zeile des `db`-Dienstes ganz entfernen. Die
-Anwendung erreicht die Datenbank über das interne Docker-Netz, nicht über
-den Host.
+```env
+# .env
+COMPOSE_FILE="docker-compose.yml:docker-compose.server.yml"
+COMPOSE_PROFILES="full"
+PROXY_NETWORK="proxy"            # so heißt das Netz
+PROXY_ALIAS="nebula"             # so findet der Proxy die Anwendung
+```
+
+Compose liest beides aus der `.env`. Danach genügt überall — auch in
+`scripts/update.sh` — ein schlichtes `docker compose up -d`. Im Proxy zeigt
+das Ziel dann nicht mehr auf `127.0.0.1:3000`, sondern auf **`nebula:3000`**;
+Schritt 6 zeigt beide Schreibweisen.
+
+> Ohne die Datei würde ein Override die Portlisten **zusammenhängen** statt
+> sie zu ersetzen — Compose führt `ports` anfügend zusammen. Das `!reset`
+> darin ist genau dafür da und braucht Compose 2.24 oder neuer.
+>
+> Das Trennzeichen in `COMPOSE_FILE` ist unter Linux der Doppelpunkt, unter
+> Windows das Semikolon.
 
 ## 4 · Starten
 
@@ -108,6 +155,13 @@ docker compose --profile full logs -f app     # mitlesen, Strg+C beendet nur das
 curl -s localhost:3000/api/health             # {"status":"ok","database":"up",…}
 ```
 
+Ohne veröffentlichten Port geht die Frage an den Container statt an den Host
+— das Abbild bringt einen `HEALTHCHECK` mit:
+
+```bash
+docker inspect --format '{{.State.Health.Status}}' nebula-app   # healthy
+```
+
 ## 5 · Ersten Zugang anlegen
 
 Ruf `https://nebula.deine-domain.de/setup` auf (nach Schritt 6) oder
@@ -145,6 +199,16 @@ sudo systemctl reload caddy
 Das genügt. Caddy setzt `X-Forwarded-*` von selbst, holt das Zertifikat bei
 Let's Encrypt und leitet `http` auf `https` um.
 
+Läuft der Proxy selbst als Container im geteilten Netz (die Variante ohne
+veröffentlichte Ports), lautet das Ziel stattdessen `nebula:3000` —
+Docker löst den Alias auf:
+
+```caddyfile
+nebula.deine-domain.de {
+    reverse_proxy nebula:3000
+}
+```
+
 <details>
 <summary>Dasselbe mit nginx</summary>
 
@@ -182,8 +246,13 @@ sudo ufw allow 80,443/tcp
 sudo ufw enable
 ```
 
-Port 3000 und 5432 bleiben **zu**. Beide sind nach Schritt 3 ohnehin nur an
-`127.0.0.1` gebunden; die Firewall ist der zweite Riegel.
+Port 3000 bleibt **zu**, 5432 wird ohnehin nie veröffentlicht. Die Firewall
+ist hier der zweite Riegel, nicht der erste.
+
+> Docker schreibt seine Portfreigaben direkt in `iptables` und geht dabei an
+> `ufw` **vorbei**. Eine Freigabe auf `0.0.0.0` steht also im Netz, auch wenn
+> `ufw` sie zu melden scheint. Genau deshalb wird hier an `127.0.0.1`
+> gebunden, statt sich auf die Firewall zu verlassen.
 
 ## 8 · Sicherungen automatisieren
 
@@ -214,6 +283,23 @@ Zurückspielen:
 
 ## Updates
 
+Es sind zwei getrennte Orte, und das ist der Punkt, an dem es leicht
+durcheinandergeht:
+
+| | Was dort liegt |
+| --- | --- |
+| **Das Git-Repository** | Der Quellcode. Dorthin wird entwickelt. |
+| **Diese Instanz** | Die laufende Anwendung, die du im Browser benutzt. |
+
+Ein Commit im Git ändert am laufenden Nebula **nichts**. Der Server holt sich
+von allein nichts ab; er betreibt weiter die Fassung, die dort zuletzt gebaut
+wurde. Ein Update ist der Schritt dazwischen: holen, bauen, umschalten.
+
+**Woran du siehst, was gerade läuft:** die Versionsnummer unten in der
+Fußzeile. Ein Klick darauf öffnet den Änderungsverlauf. Steht dort eine
+ältere Nummer als im Git, fehlen dir die neueren Funktionen — sie sind
+geschrieben, aber noch nicht auf diesem Server.
+
 Dafür gibt es `scripts/update.sh`. Es macht alles in der richtigen
 Reihenfolge und bricht ab, sobald ein Schritt scheitert:
 
@@ -227,18 +313,19 @@ Was es tut:
 | Schritt | |
 | --- | --- |
 | **1 Prüfen** | docker, compose, `.env` da? Ist `APP_SECRET` gesetzt und nicht mehr der Entwicklungswert? |
+| | *(alles ohne Node — das Skript liest die Version selbst aus der `package.json`)* |
 | **2 Holen** | `git pull --ff-only`; zeigt die neuen Commits und fragt nach |
 | **3 Sichern** | `pg_dump` **vor** jeder Schemaänderung |
 | **4 Bauen** | Erst bauen, dann umschalten — ein gescheiterter Bau lässt die alte Fassung laufen |
 | **5 Starten** | Container neu; die Migrationen laufen im Entrypoint |
-| **6 Prüfen** | Bis zu 60 Sekunden auf `/api/health` warten |
+| **6 Prüfen** | Bis zu zwei Minuten warten, bis der Container sich gesund meldet |
 
 Scheitert die Gesundheitsprüfung, zeigt das Skript die letzten Logzeilen und
 nennt den Weg zurück.
 
 ```bash
 ./scripts/update.sh --yes            # ohne Rückfrage, für Cron
-./scripts/update.sh --ref v1.4.0     # auf eine bestimmte Fassung
+./scripts/update.sh --ref v1.9.0     # auf eine bestimmte Fassung
 ./scripts/update.sh --no-pull        # nur neu bauen, ohne git pull
 ```
 
@@ -284,6 +371,23 @@ docker system df
 docker image prune -f          # alte Abbilder nach mehreren Updates
 ```
 
+### Webhooks
+
+Der Abgleich holt den Stand in seinem Takt. Wer ihn **sofort** haben will —
+ein Push ist durch, ein Issue wurde geschlossen —, trägt im Git-System einen
+Webhook ein. Nebula erzeugt URL und Geheimnis am Repository (Funksymbol im
+Git-Bereich der Projektseite), eingetragen wird der Haken von Hand.
+
+Voraussetzung ist, dass **dein Git-System diese Instanz erreicht**. Hinter
+dem Reverse Proxy ist das gegeben; in einem abgeschotteten Netz nicht. Der
+Endpunkt liegt unter `/api/webhooks/<repositoryId>` und ist der einzige ohne
+Anmeldung — ausgewiesen wird sich über eine Signatur, die gegen das
+hinterlegte Geheimnis geprüft wird.
+
+**Ohne Webhook geht nichts verloren.** Der Abgleich prüft den Zustand
+verknüpfter Issues ohnehin mit und hakt erledigte Aufgaben nach. Der Webhook
+macht es nur sofort statt beim nächsten Durchlauf.
+
 ### Automatischer Abgleich
 
 Standardmäßig **aus**. Einzuschalten unter *Admin-Einstellungen →
@@ -313,6 +417,13 @@ Damit du weißt, worum du dich **nicht** kümmern musst:
   Zugriffe; Kontosperre nach acht Fehlversuchen.
 - **Git-Tokens** liegen AES-256-GCM-verschlüsselt in der Datenbank und
   verlassen den Server nie — auch nicht im Export.
+- **Sitzungen** laufen nach 8 Stunden ohne Nutzung ab und spätestens nach
+  30 Tagen (`SESSION_IDLE_HOURS`, `SESSION_TTL_DAYS`). In der Datenbank liegt
+  nur der Hash des Tokens; das Cookie ist `HttpOnly`, `SameSite=Strict` und
+  bei HTTPS zusätzlich mit dem Präfix `__Host-`.
+- **Passwörter** werden mit scrypt nach der Empfehlung des OWASP Password
+  Storage Cheat Sheet gehasht (N = 2^17). Rechnet mit rund einer halben
+  Sekunde je Anmeldung — das ist gewollt.
 - Der **Bildoptimierer** von Next ist abgeschaltet: Nebula benutzt ihn nicht,
   und `/_next/image` wäre sonst eine Angriffsfläche ohne Gegenwert.
 

FEATURES.md

@@ -22,8 +22,19 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
 
 ### 0.2 Anmeldung
 
-- **Benutzername und Passwort.** Mindestens 10 Zeichen, offensichtliche Passwörter werden
-  abgelehnt. Hashing mit scrypt.
+- **Benutzername und Passwort.** Mindestens 10 Zeichen. Abgelehnt werden naheliegende
+  Passwörter, reine Ziffernfolgen, zu wenig verschiedene Zeichen (`abababab`),
+  durchlaufende Folgen (`abcdefgh`) und alles, was den eigenen Benutzernamen enthält.
+  **Keine Zusammensetzungsregeln** — ASVS 2.1.9 rät ausdrücklich davon ab, weil sie zu
+  `Passwort1!` führen statt zu Entropie.
+- **Hashing mit scrypt**, `N = 2^17, r = 8, p = 1` nach dem OWASP Password Storage Cheat
+  Sheet (rund 0,5 s und 128 MiB je Prüfung). Die Parameter stehen im Hash, ältere bleiben
+  also lesbar — und werden bei der nächsten Anmeldung still auf den aktuellen Stand
+  gehoben. Das ist der einzige Moment, in dem das Klartextpasswort vorliegt.
+- **Gleiche Antwort für alles Fehlgeschlagene.** Ob ein Konto existiert, gesperrt,
+  deaktiviert oder reines Passkey-Konto ist, sagt die Anmeldung erst, wenn das Passwort
+  stimmt. Davor gibt es genau einen Text und eine vergleichbare Antwortzeit
+  (`fakeVerifyDelay`), damit sich Benutzernamen nicht durchprobieren lassen.
 - **Passkey (WebAuthn).** Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel. Die
   Anmeldung läuft über auffindbare Credentials, ein Benutzername ist also nicht nötig.
   Mehrere Passkeys pro Konto, benennbar und einzeln entfernbar.
@@ -109,19 +120,42 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
 
 ## 2. Dashboard
 
+### Schnellerfassung
+
+Ein Blitzsymbol in der Kopfleiste, auf jeder Seite erreichbar. Ein Feld, Enter, fertig —
+als **Idee** entsteht ein Projekt im Status `IDEA`, als **Aufgabe** eine Aufgabe im
+gewählten Projekt (`TODO`). Alles Weitere setzen die Vorgaben des Schemas.
+
+Der Dialog **bleibt nach dem Anlegen offen** und leert nur das Feld. Wer eine Idee
+notiert, hat meistens gleich die nächste; ihn jedes Mal neu zu öffnen wäre genau die
+Hürde, die hier wegsoll. Angelegtes wird darunter mit Link bestätigt. Das zuletzt
+gewählte Projekt wird gemerkt.
+
+Der Einstieg sitzt in der Kopfleiste und nicht als schwebender Knopf unten rechts —
+dort wäre er auf schmalen Anzeigen mit der Auswahlleiste kollidiert.
+
+### Überblick
+
 - **Kennzahlen** oben: Anzahl Projekte mit Ø-Fortschritt, offene Ideen, aktive
-  Entwicklungen, fertige Projekte, verknüpfte Repositories.
+  Entwicklungen, fertige Projekte, verknüpfte Repositories. Auf dem Telefon zweispaltig,
+  damit die Projekte nicht erst nach dem zweiten Wischen beginnen.
 - **Volltextsuche** über Name, Kurzbeschreibung, Beschreibung, Tags und Repo-Pfad.
 - **Statusfilter** als Chips mit Trefferzähler, mehrere gleichzeitig kombinierbar.
 - **Sortierung** nach zuletzt geändert, Anlagedatum, Name, Fortschritt oder Priorität —
   Favoriten bleiben stets oben.
-- **Drei Ansichten**: freies Raster, nach Status gruppierte Abschnitte oder **Kanban**.
-- **Volltextsuche über Notizen.** Die Suche im Board arbeitet auf den geladenen Projekten
-  (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen liegen dort nicht vor — sie
-  mitzuladen würde die Seite aufblähen. Stattdessen sucht Postgres serverseitig mit
-  seiner deutschen Textsuche, entprellt ab zwei Zeichen. Treffer erscheinen als eigene
-  Liste mit hervorgehobener Fundstelle, die betroffenen Projekte werden zusätzlich
-  eingeblendet. Deutsche Stammformen greifen: „Webhook" findet auch „Webhooks".
+- **Vier Ansichten**: freies Raster, **kompakte Liste**, nach Status gruppierte Abschnitte
+  oder **Kanban**.
+- **Volltextsuche über Notizen und Aufgaben.** Die Suche im Board arbeitet auf den
+  geladenen Projekten (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen und Aufgaben
+  liegen dort nicht vor — sie mitzuladen würde die Seite aufblähen. Stattdessen sucht
+  Postgres serverseitig mit seiner deutschen Textsuche, entprellt ab zwei Zeichen.
+  Treffer erscheinen als zwei eigene Listen mit hervorgehobener Fundstelle, die
+  betroffenen Projekte werden zusätzlich eingeblendet. Deutsche Stammformen greifen:
+  „Webhook" findet auch „Webhooks", „Rechnung" auch „Rechnungen".
+
+  Beide Seiten haben je einen **Ausdrucksindex** (`Note_fulltext_idx`,
+  `Task_fulltext_idx`). Der Ausdruck darin muss Zeichen für Zeichen dem in der Abfrage
+  entsprechen, sonst greift er nicht und Postgres rechnet `to_tsvector` je Zeile neu.
 - **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
 - **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.
 
@@ -165,6 +199,23 @@ Karte dauerhaft eines steht. Sobald etwas ausgewählt ist, fährt unten eine Lei
 Was der Filter ausblendet, fällt aus der Auswahl. Sonst träfe eine Massenänderung Projekte,
 die man gar nicht mehr vor Augen hat. Fremde IDs fallen serverseitig still unter den Tisch.
 
+### Liste
+
+Eine Zeile je Projekt, alle gleich aufgebaut: Statusfarbe als Streifen, Name,
+Fortschrittsbalken mit Prozentwert, danach Aufgaben, Notizen, Branch und Alter des
+letzten Commits. Der Statuswechsler sitzt rechts, die ganze Zeile ist ein Link.
+
+Gedacht ist die Ansicht für zwei Fälle:
+
+- **Auf dem Telefon.** Eine Karte braucht rund 260 px Höhe und steht dort zwangsläufig
+  allein in der Zeile — fünf Projekte füllen zwei Bildschirme, bevor man überhaupt
+  etwas vergleichen kann. Eine Zeile kommt mit einem Viertel davon aus.
+- **Beim Vergleichen.** Weil alle Zeilen gleich gebaut sind, liegen Name, Fortschritt
+  und Status untereinander. Genau das verliert das Raster, sobald es einspaltig wird.
+
+Was nicht mehr in die Zeile passt, fällt der Reihe nach weg, statt sie zu sprengen:
+Notizen ab `sm`, Branch ab `md`, der letzte Commit und die Priorität ab `lg`.
+
 ### Kanban
 
 Spalten je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und
@@ -204,6 +255,10 @@ Blockiert · Erledigt**.
   Fälligkeitsdatum und Labels.
 - **Fälligkeiten** färben sich mit: überfällig rot, heute gelb, in den nächsten Tagen
   gedämpft.
+- **Hängt ein Git-Issue daran**, trägt die Karte dessen Nummer — vorn in der Fußzeile,
+  vor Beschreibung, Wiederholung, Frist und Labels, damit sich eine Spalte danach
+  überfliegen lässt. Bewusst kein Link: der Weg zum Issue führt über den Dialog (4.6),
+  weil ein `<a>` innerhalb der anklickbaren Karte ungültiges Markup wäre.
 - Erledigtes wird durchgestrichen; der Zeitpunkt wird festgehalten und beim Zurückziehen
   wieder gelöscht.
 
@@ -255,6 +310,94 @@ statt verschoben.
 
 ---
 
+## 2b. Aufgaben über alle Projekte
+
+Die Seite `/tasks` sammelt jede Aufgabe aus jedem Projekt an einer Stelle. Erreichbar
+über die Kopfleiste und die Schnellsuche.
+
+**Geordnet wird nach Fälligkeit, nicht nach Spalte.** Projektübergreifend lautet die
+Frage „was ist überfällig", nicht „was steht wo im Brett". Die Fächer:
+
+| Fach | Inhalt |
+| --- | --- |
+| **Überfällig** | Termin liegt vor heute |
+| **Heute** | Termin ist der heutige Kalendertag |
+| **Diese Woche** | in den nächsten sieben Tagen |
+| **Später** | alles danach |
+| **Ohne Termin** | kein Fälligkeitsdatum gesetzt |
+
+Gerechnet wird auf **Kalendertage in fester Zeitzone** (Europe/Berlin), nicht auf
+Stunden und nicht nach Serverzeit. Eine heute um 9 Uhr fällige Aufgabe ist um 17 Uhr
+nicht überfällig, sondern immer noch „heute" — sonst wanderte die halbe Liste im Lauf
+des Tages nach oben. Und im Container läuft die Anwendung nach UTC; ohne feste Zeitzone
+kippte die Einteilung abends um einen Tag. Das Fach bestimmt der **Server**, damit
+Server-Render und Hydration nicht auseinanderlaufen.
+
+- **Filter** nach Status (mit Zähler) und Projekt; Erledigtes ist ausgeblendet und
+  einzeln zuschaltbar.
+- **Abhaken direkt aus der Liste.** Der Endpunkt erledigt dabei den Rest: Zeitpunkt,
+  abgeleiteter Projektfortschritt und — bei wiederkehrenden Aufgaben — die nächste
+  Fassung.
+- Jede Zeile nennt ihr **Projekt** und verlinkt es; ohne das ist eine übergreifende
+  Liste nicht zu lesen. Stammt die Aufgabe aus einem Git-Issue, führt ein Symbol dorthin.
+
+**Bewusst nicht sortierbar per Ziehen.** Die Position einer Aufgabe gilt innerhalb ihrer
+Spalte in ihrem Projekt; hier wäre sie ohne Bedeutung. Eine Reihenfolge anzubieten, die
+nirgends ankommt, wäre ein Versprechen, das die Seite nicht halten kann.
+
+Die Aufgabe kennt keinen Besitzer — die Trennung läuft über das Projekt
+(`project: { ownerId }` als einzige und erste Bedingung).
+
+---
+
+## 2c. Rückblick und Verlauf
+
+Zwei Sichten auf denselben Aktivitätsverlauf, über alle Projekte hinweg. Beide teilen
+sich Zeilendarstellung und Tagesgruppierung (`components/ActivityRow`) — zwei Kopien
+wären beim nächsten Feinschliff auseinandergelaufen.
+
+Der Verlauf kennt keinen Besitzer; die Trennung läuft über das Projekt
+(`project: { ownerId }` als erste Bedingung).
+
+### Wochenrückblick
+
+`/rueckblick` beantwortet „was ist diese Woche passiert". Oben Kennzahlen — Vorgänge,
+berührte Projekte, erledigte und neue Aufgaben —, darunter die Vorgänge nach
+Kalendertagen gebündelt, neuester Tag zuerst. Über `?woche=-n` geht es bis zu 25 Wochen
+zurück; weiter lohnt nicht, weil der Verlauf ohnehin nur 200 Einträge je Projekt hält.
+
+**Gerechnet wird auf Kalendertage in fester Zeitzone** (Europe/Berlin), nicht auf
+„sieben mal 24 Stunden": liegt eine Zeitumstellung in der Woche, hat sie 167 oder 169
+Stunden. Und im Container läuft die Anwendung nach UTC — ein Eintrag von Sonntagabend
+fiele sonst in die falsche Woche. Das Fach bestimmt der **Server**, damit Server-Render
+und Hydration nicht auseinanderlaufen.
+
+**„Aufgaben erledigt" wird am `meta`-Feld abgelesen** (`to: "DONE"`), nicht am
+Anzeigetext. Der Text ist zum Lesen da und ändert sich mit der Formulierung; eine
+Zählung daran würde beim nächsten umformulierten Einzeiler unbemerkt kippen. Einträge
+ohne `meta` zählen nicht mit — lieber untertreiben als raten.
+
+### Globale Zeitleiste
+
+`/verlauf` zeigt denselben Verlauf **fortlaufend**: ohne Wochengrenze, ohne Fazit, mit
+„Ältere laden". Die erste Seite kommt serverseitig mit, alles Weitere über
+`/api/activity`.
+
+**Geblättert wird per Cursor** über `(createdAt, id)`, nicht per `skip`. Der Verlauf
+schreibt mehrere Einträge im selben Augenblick — beim Übernehmen von Issues entstehen
+zehn Zeilen mit identischem Zeitstempel. Ein Offset über eine solche Grenze hinweg
+überspringt Zeilen oder zeigt sie zweimal, und zwar lautlos. Der zweite Zweig der
+Bedingung (gleicher Zeitpunkt, kleinere ID) fängt genau das ab.
+
+Nachgerechnet gegen 144 Einträge mit absichtlichen Blöcken gleicher Zeitstempel: 15
+Seiten, 144 Zeilen, keine Dublette, streng absteigend.
+
+Beide Seiten sind über die Schnellsuche erreichbar, der Rückblick zusätzlich über einen
+Verweis vom Dashboard. Bewusst **kein** weiterer Punkt in der Kopfleiste — die ist auf
+dem Telefon schon eng.
+
+---
+
 ## 3. Notizen
 
 - **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
@@ -346,6 +489,40 @@ Firmen-Gitea nebeneinander.
   Kurzbeschreibung.
 - **Löschen** trennt nur die Verknüpfung; die Projekte selbst bleiben erhalten.
 
+#### Nötige Token-Rechte
+
+Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: `POST …/issues`
+beim Anlegen und `PATCH`/`PUT …/issues/{nr}` beim Schließen oder Wiederöffnen (4.6). Wer
+darauf verzichtet, kommt mit einem rein lesenden Token aus.
+
+| System | Nur Abgleich | Zusätzlich für die Issue-Anbindung |
+| --- | --- | --- |
+| GitHub | *Metadata*, *Contents*, *Issues*, *Pull requests*, *Actions* — je lesend | *Issues: Read and write* |
+| GitLab | `read_api` | `api` |
+| Gitea / Forgejo | `read:repository`, `read:issue`, `read:user` | `write:issue` |
+
+Welcher Aufruf welches Recht verlangt, steht Zeile für Zeile in der
+[README](README.md#welche-rechte-der-token-braucht) — dort ist jeder ausgehende Aufruf
+der drei Clients aufgeführt.
+
+**GitLab kennt keinen schmalen Schreib-Scope.** `api` erlaubt alles, was das Konto darf,
+Code eingeschlossen. Wem das zu weit geht, bleibt bei `read_api`: der Abgleich läuft
+vollständig, geschlossene Issues werden weiterhin erkannt — nur schreibt Nebula dann
+nicht zurück.
+
+**Nicht verlangt** werden Schreibrechte auf Code, Adminrechte und Rechte zum Anlegen von
+Webhooks. Der Haken wird von Hand im Git-System eingetragen (4.7); das erspart dem Token
+genau die Administrationsrechte, die er sonst bräuchte.
+
+**Kommentare schreibt Nebula nie** — weder beim Anlegen noch beim Schließen. In den
+Rumpf des angelegten Issues wandert die Aufgabenbeschreibung plus eine Zeile Rückverweis
+auf das Projekt; danach bleibt der Text unangetastet. Was sonst an Kommentaren und
+Labels an einem Issue hängt, kommt aus der Weboberfläche oder von einem anderen Werkzeug.
+
+Ein fehlendes Recht endet in einem `403` mit „Token hat nicht die noetigen Scopes",
+sichtbar am Repository auf der Projektseite. Klein anfangen und gezielt nachlegen ist
+deshalb ohne Risiko.
+
 ### 4.3 Was beim Sync geholt wird
 
 | Bereich | Details |
@@ -428,6 +605,103 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 - **Zeitlimit** pro Aufruf über `GIT_API_TIMEOUT_MS` einstellbar; die Teilabfragen laufen
   parallel, eine fehlschlagende Liste bricht den restlichen Sync nicht ab.
 
+### 4.6 Aufgabe ↔ Git-Issue
+
+Die Verbindung geht in beide Richtungen — mit einer bewussten Grenze.
+
+**Nebula → Git.** Ein Knopf im Aufgabendialog legt zur Aufgabe ein Issue im
+verknüpften Repository an. Nummer und Adresse landen an der Aufgabe (`sourceIssue`,
+`sourceUrl`, `sourceRepositoryId` — dieselben Felder, die die Übernahme aus Issues seit
+v0.9.0 füllt, samt Eindeutigkeit je Repository gegen Dubletten). In den Rumpf kommt ein
+Rückverweis auf das Projekt.
+
+Ausdrücklich **per Knopf und nie nebenbei**: was in ein fremdes System geschrieben wird,
+soll jemand gewollt haben. Danach wandert der Zustand allerdings mit — erledigt schließt
+das Issue, ein Zurückziehen öffnet es wieder. Schlägt der Aufruf fehl, zieht die Aufgabe
+trotzdem um; ein nicht erreichbares Git-System darf das Abhaken nicht verhindern.
+
+**Git → Nebula** auf zwei Wegen, die sich ergänzen:
+
+- **Webhook** — sofort, sobald das Issue geschlossen wird. Setzt voraus, dass die Instanz
+  von außen erreichbar ist und der Haken eingetragen wurde (siehe 4.7).
+- **Beim Abgleich** — verzögert, aber verlässlich. Der Abgleich fragt den Zustand
+  verknüpfter Issues nach und hakt ab, was in Git geschlossen ist. Damit funktioniert der
+  Rückweg auch ohne Webhook, ohne öffentliche Erreichbarkeit und selbst dann, wenn ein
+  Haken einmal ausfällt.
+
+  Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen führt,
+  werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht — die Liste der offenen
+  Issues ist gedeckelt, aus dem Fehlen einer Nummer folgt also nichts. Pro Durchgang
+  fragt der Abgleich höchstens 25 Issues nach.
+
+  **Der Abgleich hakt nur ab, er nimmt nie zurück.** Er sieht Zustände, keine Ereignisse:
+  ein offenes Issue kann auch bedeuten, dass das Schließen von Nebula aus fehlgeschlagen
+  ist. Ein symmetrischer Abgleich würde dann eine bewusst erledigte Aufgabe wieder
+  aufmachen. Das Zurücknehmen bleibt dem Webhook vorbehalten, der ein echtes „reopened“
+  sieht.
+
+  Ein gelöschtes Issue ist kein erledigtes — die Aufgabe bleibt stehen.
+
+In beiden Fällen bewirkt ein geschlossenes Issue dasselbe wie ein Haken in der
+Oberfläche: bei einer wiederkehrenden Aufgabe entsteht die nächste Fassung, und der
+Vorgang landet im Projektverlauf (ohne Benutzer — das hat nicht jemand in Nebula getan,
+sondern das Git-System gemeldet).
+
+**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
+`Offen · In Arbeit · Blockiert · Erledigt`, ein Issue nur offen oder geschlossen. Nach
+außen geht deshalb nur die Grenze um „erledigt“; ein Rundlauf verliert *In Arbeit* und
+*Blockiert*. Labels wie `nebula:doing` wären die Alternative, würden aber den
+Issue-Tracker mit Zuständen füllen, die dort niemand pflegt. Die feine Abstufung bleibt
+in Nebula.
+
+Eine echte beidseitige Synchronisation mit Konfliktauflösung gibt es **nicht** — das ist
+der klassische Ort für stillen Datenverlust.
+
+**Kein Widerspruch zu „keine eigenen Git-Operationen“:** Issues laufen über die HTTP-API
+der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`, SSRF-Schutz
+inklusive). Kein Klon, kein Arbeitsverzeichnis. Schreibende Aufrufe folgen dabei
+**keinen Umleitungen** — ein 307 auf eine interne Adresse nähme den Rumpf und den Token
+im Header mit.
+
+### 4.7 Webhooks
+
+Ein Push aktualisiert den Stand sofort, statt bis zum nächsten Durchlauf des Zeitgebers
+zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Der Zeitplan bleibt als
+Rückfalllösung bestehen.
+
+Einzurichten am Repository (Funksymbol im Git-Bereich): Nebula erzeugt URL und
+Geheimnis, eingetragen wird der Haken im Git-System von Hand. Über die API anzulegen
+wäre machbar, verlangte aber Administrationsrechte am Repository — deutlich mehr, als
+Nebula sonst braucht.
+
+Das Geheimnis ist **genau einmal** zu sehen; danach liegt es verschlüsselt in der
+Datenbank, wie die Zugangstoken, und verlässt den Server nicht mehr.
+
+| System | Ausweis | Kopfzeile |
+| --- | --- | --- |
+| GitHub | HMAC-SHA256 über den Rumpf | `X-Hub-Signature-256: sha256=…` |
+| Gitea | dieselbe Rechnung, ohne Präfix | `X-Gitea-Signature` (ältere: `X-Hub-Signature-256`) |
+| GitLab | das Geheimnis im Klartext | `X-Gitlab-Token` |
+
+GitLabs Verfahren ist schwächer: es beweist nur, dass der Absender das Geheimnis kennt,
+nicht dass der Rumpf unverändert ist. Mehr gibt die Plattform nicht her; verglichen wird
+trotzdem zeitkonstant.
+
+Geprüft wird gegen den **rohen** Rumpf — durch `JSON.parse` und `JSON.stringify` gedreht
+käme eine andere Zeichenfolge heraus und die Signatur passte nie.
+
+Was der Endpunkt bewusst **nicht** tut: den Rumpf als Quelle für Inhalte benutzen. Titel,
+Beschreibung und Zustand kommen weiter aus Nebula beziehungsweise beim nächsten Abgleich
+aus der API. Wer das Geheimnis kennt, kann also höchstens eine Aufgabe auf- oder zumachen
+und einen Abgleich auslösen — keine beliebigen Daten einschleusen.
+
+Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler brächte das
+Git-System zum Wiederholen und irgendwann zum Abschalten des Hakens.
+
+Der Endpunkt ist der einzige ohne Anmeldung, der schreibt. Deshalb: Ratenbegrenzung je
+Repository (60/Minute), Deckel auf die Rumpfgröße, und ein unbekanntes Repository
+antwortet wie ein nicht eingerichtetes — mit 404, damit die ID nicht bestätigt wird.
+
 ---
 
 ## 4a. Export, Import und Sicherung
@@ -613,6 +887,16 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
   `GIT_BLOCK_PRIVATE` und `GIT_ALLOWED_HOSTS`.
 - **Rate-Limiting** für Anmeldung (je IP und je Konto), ausgehende Git-Aufrufe und
   WebAuthn-Optionen.
+- **Sitzungen**: Zufallstoken mit 256 Bit, in der Datenbank nur als SHA-256-Hash — wer die
+  Datenbank liest, kann keine Sitzung übernehmen. Geprüft wird bei jeder Anfrage, Abmelden
+  und Sperren wirken also sofort. Zwei Fristen nach ASVS 3.3.2: **absolut** 30 Tage ab
+  Anmeldung (`SESSION_TTL_DAYS`) und **im Leerlauf** 8 Stunden (`SESSION_IDLE_HOURS`).
+  Ein Passwortwechsel entwertet alle Sitzungen und stellt für das eigene Gerät eine neue
+  aus.
+- **Cookies**: `HttpOnly`, `SameSite=Strict`, `Secure` sobald die App über HTTPS läuft, und
+  dann zusätzlich mit dem Präfix `__Host-`. Der Präfix lässt den Browser selbst erzwingen,
+  dass kein `Domain` gesetzt ist — eine andere Subdomain kann den Cookie damit nicht
+  überschreiben und keine Sitzung unterschieben.
 - Access Tokens verschlüsselt mit **AES-256-GCM**, Schlüssel per **scrypt** aus
   `APP_SECRET` abgeleitet, Chiffrat versioniert (`v1.<iv>.<tag>.<data>`).
 - Tokens werden nie an den Browser gesendet — alle API-Antworten nutzen eine Feldauswahl

README.md

@@ -22,6 +22,12 @@ Jedes Projekt bekommt einen **Status** (von der rohen Idee bis „Fertig"), beli
 Branches, Tags, Commits, Releases und offene Issues/PRs — egal ob **GitHub**, **GitLab**
 oder eine selbst gehostete **Gitea**-Instanz.
 
+Neben dem Projektbrett gibt es **Aufgaben über alle Projekte hinweg** (nach Fälligkeit
+geordnet), einen **Wochenrückblick** und eine **fortlaufende Zeitleiste** aus dem
+Aktivitätsverlauf. Aufgaben lassen sich als **Git-Issue** anlegen; wird das Issue
+geschlossen, hakt Nebula die Aufgabe ab — sofort per **Webhook** oder verzögert beim
+nächsten Abgleich.
+
 Die Anmeldung läuft über **Benutzername und Passwort oder Passkey** (WebAuthn). Nebula
 kennt zwei Betriebsarten: **Einzelbetrieb** für ein Konto oder **Mehrbenutzerbetrieb**, in
 dem jede Person ihren eigenen, streng getrennten Bereich hat. Umschalten geht jederzeit in
@@ -52,7 +58,7 @@ node scripts/setup.mjs      # legt .env an und erzeugt ein zufälliges APP_SECRE
 Die App läuft nativ auf dem Rechner, nur PostgreSQL kommt aus dem Container:
 
 ```bash
-docker compose up -d db      # Postgres 17 auf localhost:5432
+npm run docker:db            # Postgres 17 auf 127.0.0.1:5432
 npm install
 npm run db:migrate           # Schema anlegen
 npm run db:seed              # optional: drei Beispielprojekte
@@ -118,12 +124,13 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `APP_URL` | Öffentliche Adresse — bestimmt die WebAuthn-RP-ID | `http://localhost:3000` |
 | `DATABASE_URL` | PostgreSQL-Verbindung (Prisma) | `postgresql://nebula:nebula@localhost:5432/nebula` |
 | `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
-| `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_TTL_DAYS` | Absolute Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_IDLE_HOURS` | Nach so vielen Stunden ohne Nutzung läuft die Sitzung ab (`0` = aus) | `8` |
 | `PORT` | Port der Anwendung | `3000` |
-| `APP_PORT` | Host-Port-Mapping des App-Containers | `3000` |
+| `APP_PORT` | Host-Port-Mapping des App-Containers | `127.0.0.1:3000` |
 | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |
-| `POSTGRES_PORT` | Host-Port der Datenbank | `5432` |
-| `ADMINER_PORT` | Host-Port von Adminer (`--profile tools`) | `8080` |
+| `POSTGRES_PORT` | Host-Port der Datenbank — wirkt nur mit `docker-compose.dev.yml`, sonst hat die DB keinen | `127.0.0.1:5432` |
+| `ADMINER_PORT` | Host-Port von Adminer (`--profile tools`) | `127.0.0.1:8080` |
 | `GIT_API_TIMEOUT_MS` | Timeout für Git-API-Aufrufe | `15000` |
 | `GIT_ALLOW_LOOPBACK` | Git-Instanz auf demselben Rechner erlauben | `false` |
 | `GIT_BLOCK_PRIVATE` | Zugriff ins private LAN sperren | `false` |
@@ -166,14 +173,8 @@ Nebula auffindbare Credentials nutzt.
 
 ## Git-Verbindung einrichten
 
-1. Im Git-System einen **Personal Access Token** mit Leserechten erzeugen:
-
-   | System | Scopes |
-   | --- | --- |
-   | GitHub | Fine-grained Token: *Contents: Read*, *Metadata: Read*, *Issues: Read*, *Pull requests: Read* |
-   | GitLab | `read_api` (alternativ `read_repository`) |
-   | Gitea / Forgejo | `repository:read`, `issue:read`, `user:read` |
-
+1. Im Git-System einen **Personal Access Token** erzeugen — mit den Rechten aus dem
+   Abschnitt [Welche Rechte der Token braucht](#welche-rechte-der-token-braucht).
 2. In Nebula unter **Git-Verbindungen → Verbindung hinzufügen** eintragen:
    System wählen, Basis-URL (z. B. `https://git.meine-firma.de`, ohne `/api`) und Token.
 3. Mit **Testen** prüfen — Nebula meldet den erkannten Benutzer zurück.
@@ -185,6 +186,132 @@ Nebula auffindbare Credentials nutzt.
 Der Snapshot bleibt in der Datenbank, das Dashboard funktioniert also auch offline.
 Ohne Token gehen nur öffentliche Repositories, mit strengem Rate-Limit.
 
+### Welche Rechte der Token braucht
+
+Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: wenn du eine
+Aufgabe als Issue anlegst, und wenn eine Aufgabe auf `DONE` wandert und Nebula das
+verknüpfte Issue schließt. Alles andere sind `GET`-Aufrufe. Deshalb lohnt es, zwei Fälle
+zu unterscheiden:
+
+**Fall A — nur Abgleich.** Branches, Tags, Commits, Releases, CI-Zustand, README,
+Heatmap, offene Issues und PRs anzeigen. Rein lesend.
+
+**Fall B — zusätzlich die Issue-Anbindung.** Eine Aufgabe als Issue anlegen; wird das
+Issue geschlossen, hakt Nebula die Aufgabe ab und schließt sie umgekehrt mit.
+
+| System | Fall A (nur lesen) | Fall B zusätzlich |
+| --- | --- | --- |
+| **GitHub** | Fine-grained Token: *Metadata: Read*, *Contents: Read*, *Issues: Read*, *Pull requests: Read*, *Actions: Read* | *Issues: **Read and write*** |
+| **GitLab** | `read_api` | `api` — **es gibt nichts dazwischen** |
+| **Gitea / Forgejo** | `read:repository`, `read:issue`, `read:user` | `write:issue` |
+
+#### Jeder Aufruf einzeln
+
+Die folgenden Tabellen sind vollständig: mehr als das ruft Nebula nicht nach draußen.
+Sie sind aus `src/lib/git/github.ts`, `gitlab.ts` und `gitea.ts` erhoben — wer prüfen
+will, ob hier etwas fehlt, greppt dort nach `getJson`, `getJsonSafe` und `sendJson`.
+
+**GitHub** — `https://api.github.com`, Header `Authorization: Bearer …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /rate_limit` | Verbindungstest | keins |
+| `GET /user` | Kontoname beim Testen zurückmelden | keins |
+| `GET /user/repos` | Auswahlliste hinter **Repos laden** | Metadata: Read |
+| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | Metadata: Read |
+| `GET …/languages` | Sprachverteilung | Metadata: Read |
+| `GET …/tags` | Tags | Metadata: Read |
+| `GET …/stats/commit_activity` | Commit-Heatmap über ein Jahr | Metadata: Read |
+| `GET …/branches` | Branch-Liste | Contents: Read |
+| `GET …/commits` | die letzten 100 Commits | Contents: Read |
+| `GET …/releases` | Releases | Contents: Read |
+| `GET …/readme` | README-Vorschau | Contents: Read |
+| `GET …/pulls?state=open` | offene Pull Requests | Pull requests: Read |
+| `GET …/issues?state=open` | offene Issues | Issues: Read |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | Issues: Read |
+| `GET …/actions/runs` | CI-Zustand des Default-Branch | Actions: Read |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | Issues: Read and write |
+| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | Issues: Read and write |
+
+Dass `/tags` und `/stats/commit_activity` unter *Metadata* fallen und nicht unter
+*Contents*, ist nicht zu erraten — es steht so in
+[GitHubs Berechtigungsübersicht](https://docs.github.com/en/rest/authentication/permissions-required-for-fine-grained-personal-access-tokens).
+
+**GitLab** — `{Basis-URL}/api/v4`, Header `PRIVATE-TOKEN: …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /projects?per_page=1` | Verbindungstest | `read_api` |
+| `GET /user` | Kontoname beim Testen zurückmelden | `read_user` (in `read_api` enthalten) |
+| `GET /projects?membership=true` | Auswahlliste hinter **Repos laden** | `read_api` |
+| `GET /projects/{id}?statistics=true` | Stammdaten, Default-Branch, Sichtbarkeit | `read_api` |
+| `GET …/repository/branches` · `/tags` · `/commits` | Snapshot und Heatmap | `read_api` |
+| `GET …/repository/tree` · `/repository/files/{datei}` | README (zwei Aufrufe, GitLab hat keinen README-Endpunkt) | `read_api` |
+| `GET …/releases` · `/languages` | Releases, Sprachverteilung | `read_api` |
+| `GET …/merge_requests?state=opened` | offene Merge Requests | `read_api` |
+| `GET …/issues?state=opened` | offene Issues | `read_api` |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read_api` |
+| `GET …/pipelines` | CI-Zustand des Default-Branch | `read_api` |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | `api` |
+| `PUT …/issues/{nr}` (`state_event`) | **Issue schließen oder wieder öffnen** | `api` |
+
+**Gitea / Forgejo** — `{Basis-URL}/api/v1`, Header `Authorization: token …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /version` | Verbindungstest | keins — der Aufruf darf fehlschlagen, Nebula wertet ihn nur ergänzend aus |
+| `GET /user` | Kontoname beim Testen zurückmelden | `read:user` |
+| `GET /user/repos` bzw. `GET /repos/search` | Auswahlliste hinter **Repos laden** | `read:repository` |
+| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | `read:repository` |
+| `GET …/branches` · `/tags` · `/commits` · `/releases` · `/languages` | Snapshot und Heatmap | `read:repository` |
+| `GET …/contents` · `/contents/{datei}` | README (zwei Aufrufe, wie bei GitLab) | `read:repository` |
+| `GET …/commits/{branch}/status` | CI-Zustand des Default-Branch | `read:repository` |
+| `GET …/pulls?state=open` | offene Pull Requests | `read:repository` — Gitea zählt PRs zum Repository-Scope, nicht zu den Issues |
+| `GET …/issues?state=open&type=issues` | offene Issues | `read:issue` |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read:issue` |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | `write:issue` |
+| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | `write:issue` |
+
+`write:issue` schließt `read:issue` mit ein — Gitea versteht `write:` als „lesen und
+schreiben". Beide anzuhaken schadet nicht, nötig ist es nicht.
+
+#### Was Nebula nicht tut
+
+- **Keine Kommentare.** Nebula schreibt nie einen Issue-Kommentar, weder beim Anlegen
+  noch beim Schließen. Was im Rumpf des angelegten Issues steht, ist die
+  Aufgabenbeschreibung plus eine Zeile Rückverweis — danach fasst Nebula den Text
+  nicht mehr an.
+- **Kein Code.** Nichts wird committet, gepusht, gemergt oder getaggt. Nebula ist eine
+  Übersicht, keine Entwicklungsumgebung.
+- **Keine Webhooks anlegen.** Den Haken trägst du selbst im Git-System ein — genau
+  deshalb verlangt Nebula dafür keine Administrationsrechte.
+- **Keine Labels, keine Meilensteine, keine Zuweisungen.**
+- **Keine Adminrechte**, keine Organisations- oder Benutzerverwaltung.
+
+Kommentare und Labels, die an einem Issue hängen, stammen also entweder aus der
+Weboberfläche deines Git-Systems oder von einem anderen Werkzeug mit eigenem Token —
+nicht von Nebula.
+
+#### Der GitLab-Sonderfall
+
+GitLab kennt keinen schmalen Schreib-Scope für Issues. Laut
+[Access token scopes](https://docs.gitlab.com/security/tokens/access_token_scopes/)
+gibt es nur `api` — „complete read and write access to the API" — und darunter direkt
+`read_api`. Wer bei GitLab Aufgaben als Issue anlegen will, vergibt damit ein Token, das
+auch Code ändern darf.
+
+Wenn dir das zu weit geht: bleib bei `read_api` und verzichte auf die Issue-Anbindung.
+Der Abgleich läuft vollständig, und geschlossene Issues werden weiterhin erkannt und
+haken ihre Aufgabe ab — nur der Rückweg von Nebula ins Issue fällt weg. Ein eigenes
+Dienstkonto, das nur Zugriff auf die betroffenen Projekte hat, ist der andere Ausweg.
+
+#### Im Zweifel klein anfangen
+
+Ein fehlendes Recht führt zu einem `403` mit dem Hinweis „Token hat nicht die noetigen
+Scopes"; die Meldung steht am Repository auf der Projektseite. Fang mit Fall A an und
+leg gezielt nach, wenn du die Issue-Anbindung wirklich benutzt — statt vorsorglich
+alles zu vergeben.
+
 ### Automatisch statt auf Knopfdruck
 
 Unter **Admin-Einstellungen → Automatischer Abgleich** lässt sich der Sync in den
@@ -274,15 +401,25 @@ nebula/
 └── src/
     ├── app/
     │   ├── page.tsx            Dashboard (Board, Filter, Kennzahlen)
-    │   ├── projects/[id]/      Projektdetail: Beschreibung, Notizen, Git
+    │   ├── projects/[id]/      Projektdetail: Beschreibung, Notizen, Aufgaben, Git
+    │   ├── tasks/              Aufgaben über alle Projekte, nach Fälligkeit
+    │   ├── rueckblick/         Wochenrückblick
+    │   ├── verlauf/            Fortlaufende Zeitleiste
     │   ├── connections/        Verwaltung der Git-Verbindungen
-    │   └── api/                REST-Endpunkte (Projekte, Notizen, Verbindungen, Sync)
+    │   ├── account/ admin/     Eigenes Konto · Adminbereich
+    │   └── api/                REST-Endpunkte (siehe Abschnitt „API")
     ├── components/             UI-Komponenten (Board, Karten, Panels, Dialoge)
     ├── lib/
+    │   ├── auth/               Sitzungen, Passwörter, TOTP, WebAuthn, Zugriffsschutz
     │   ├── crypto.ts           AES-256-GCM für Access Tokens
     │   ├── db.ts               Prisma-Client
     │   ├── git/                Provider-Adapter: github.ts · gitlab.ts · gitea.ts
-    │   ├── sync.ts             Repo-Snapshot holen und speichern
+    │   ├── sync/               Repo-Snapshot holen, speichern, Zeitgeber
+    │   ├── tasks/              Aufgabenlogik, Brücke zu Git-Issues
+    │   ├── webhooks/           Signaturprüfung eingehender Webhooks
+    │   ├── review.ts           Wochengrenzen und Kennzahlen
+    │   ├── timeline.ts         Cursor-Blättern für den Verlauf
+    │   ├── security/           SSRF-Schutz, Ratenbegrenzung, Body-Prüfung
     │   └── validation.ts       Zod-Schemas für alle Eingaben
     └── types/                  gemeinsame Typen für Server und Client
 ```
@@ -307,7 +444,7 @@ nebula/
 | `npm test` | Unit-Tests (Vitest, ohne Datenbank) |
 | `npm run test:e2e` | Ende-zu-Ende-Tests (Playwright, baut vorher) |
 | `npm run test:all` | Beides nacheinander |
-| `npm run docker:db` | Nur die Datenbank starten |
+| `npm run docker:db` | Nur die Datenbank starten, mit Host-Port für `npm run dev` |
 | `npm run docker:up` / `docker:down` | Kompletten Stack starten / stoppen |
 | `npm run docker:tools` | Adminer auf `http://localhost:8080` |
 
@@ -346,7 +483,8 @@ ausschließlich Daten des angemeldeten Kontos.
 | `PATCH` `DELETE` | `/api/templates/:id` | Vorlage ändern / löschen |
 | `POST` | `/api/templates/from-project` | Aus einem Projekt eine Vorlage machen |
 | `GET` | `/api/admin/backup` | Vollständige Sicherung als JSON (Admin) |
-| `GET` | `/api/search?q=` | Volltextsuche über die eigenen Notizen |
+| `GET` | `/api/search?q=` | Volltextsuche über eigene Notizen **und Aufgaben** |
+| `GET` | `/api/activity` | Verlauf über alle Projekte, per Cursor (`?vor=&id=&limit=`) |
 | `GET` `POST` | `/api/notifications` | Benachrichtigungsziele |
 | `PATCH` `DELETE` | `/api/notifications/:id` | Ziel ändern / entfernen |
 | `POST` | `/api/notifications/:id/test` | Testnachricht senden |
@@ -358,10 +496,13 @@ ausschließlich Daten des angemeldeten Kontos.
 | `GET` `POST` | `/api/projects/:id/repositories` | Repositories des Projekts |
 | `PATCH` `DELETE` | `/api/repositories/:id` | Repository ändern / vom Projekt lösen |
 | `POST` | `/api/repositories/:id/sync` | Ein einzelnes Repository abgleichen |
+| `POST` `DELETE` | `/api/repositories/:id/webhook` | Webhook einrichten / zurücknehmen |
+| `POST` | `/api/webhooks/:repositoryId` | **Eingehend** von GitHub/GitLab/Gitea, per Signatur geprüft |
 | `GET` `POST` | `/api/projects/:id/tasks` | Aufgaben des Projekts |
 | `PATCH` | `/api/projects/:id/tasks/reorder` | Neue Reihenfolge nach dem Ziehen |
 | `POST` | `/api/projects/:id/tasks/from-issues` | Offene Issues als Aufgaben übernehmen |
 | `PATCH` `DELETE` | `/api/tasks/:id` | Aufgabe ändern / löschen |
+| `POST` | `/api/tasks/:id/issue` | Aufgabe als Issue im verknüpften Repository anlegen |
 | `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
 | `PATCH` `DELETE` | `/api/notes/:id` | Notiz ändern / löschen |
 | `GET` `POST` | `/api/connections` | Git-Verbindungen |
@@ -416,7 +557,7 @@ Grenzen, die du kennen solltest:
 
 | Symptom | Ursache / Lösung |
 | --- | --- |
-| `Can't reach database server` | Läuft `docker compose up -d db`? Stimmt `DATABASE_URL`? |
+| `Can't reach database server` | Läuft `npm run docker:db`? Ein blosses `docker compose up -d db` startet die DB **ohne Host-Port** — dann ist sie von `npm run dev` aus nicht erreichbar. Stimmt `DATABASE_URL`? |
 | `The table ... does not exist` | Migrationen fehlen: `npm run db:migrate` |
 | Sync meldet `401` | Token abgelaufen oder falsche Scopes — unter Git-Verbindungen neu setzen |
 | Sync meldet `404` | Owner/Repo prüfen; bei GitLab gehört die volle Gruppenkette in „Owner" |
@@ -433,17 +574,21 @@ Grenzen, die du kennen solltest:
 
 ## Getestet mit
 
-Stand 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
-Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz).
+Am 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
+Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz). Seitdem
+laufen die Ende-zu-Ende-Tests bei jeder Änderung mit; live nach draußen geht davon nur
+ein Test gegen die GitHub-API.
+
+Werkzeugstand vom 18.08.2026:
 
 | | Version |
 | --- | --- |
-| Node.js | 26.5.0 |
+| Node.js | 24.19.0 |
 | npm | 11.17.0 |
 | Next.js | 15.5.21 |
 | Prisma | 6.19.3 |
-| PostgreSQL | 17 (Alpine) |
-| Docker / Compose | 29.6.2 / v5.3.1 |
+| PostgreSQL | 17.11 (Alpine) |
+| Docker | 29.7.2 |
 
 ---
 

ROADMAP.md

@@ -7,18 +7,21 @@ Stück für Stück abarbeiten. Reihenfolge ist ein Vorschlag, keine Festlegung.
 
 Was bereits steht, listet [FEATURES.md](FEATURES.md).
 
+**Stand:** v1.10.1. Alle Issues aus dem Dashboard sind abgearbeitet.
+
 ---
 
 ## 1 · Als Nächstes empfohlen
 
-### 1.1 Webhooks statt Polling `M`
+### 1.1 Persönliche API-Token `M`
 
-Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
-zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
-Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
-erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
+Der letzte offene Teil aus v1.6.0 („unterwegs erfassen"). Derzeit geht die
+API nur mit Sitzungscookie. Ein Token je Konto würde `curl`-Aufrufe und
+Handy-Shortcuts erlauben — eine Idee aus dem Terminal anlegen, ohne den
+Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den Sitzungen.
 
----
+Bewusst noch nicht angefasst, weil sicherheitsrelevant: Geltungsbereich,
+Widerruf und Ablauf wollen entschieden sein, nicht nebenbei gebaut.
 
 ### 1.2 Läuft es noch? `M`
 
@@ -27,12 +30,23 @@ Nebula wüsste dann, ob ein Projekt nicht nur existiert, sondern auch läuft.
 Nutzt Zeitgeber und Benachrichtigungen, die es schon gibt. Der SSRF-Schutz
 greift dabei wie bei den Git-Aufrufen.
 
-### 1.3 Persönliche API-Token `M`
+### 1.3 Aufgaben ↔ Issues: der Rest `S`
 
-Derzeit geht die API nur mit Sitzungscookie. Ein Token je Konto würde
-`curl`-Aufrufe und Handy-Shortcuts erlauben — Idee aus dem Terminal anlegen,
-ohne den Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den
-Sitzungen.
+Beide Richtungen stehen — „als Issue anlegen" seit v1.7.0, der Rückweg über
+Webhook (v1.7.0) und zusätzlich über den Abgleich (v1.9.0). Offen ist
+Kleinkram:
+
+- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
+  Projekt aus Frontend und Backend fehlt die Wahl.
+- **Webhook beim Verknüpfen anbieten.** Er ist getrennt einzurichten, und
+  wer das nicht tut, merkt nur an der Verzögerung, dass etwas fehlt. Ein
+  Hinweis an der richtigen Stelle würde reichen.
+
+Was **nicht** kommt, bleibt wie besprochen: eine echte beidseitige
+Synchronisation mit Konfliktauflösung. Die Zustände passen ohnehin nicht
+aufeinander — ein Issue kennt nur offen und geschlossen, `DOING` und
+`BLOCKED` gehen im Rundlauf verloren. Das ist hingenommen, statt den
+Issue-Tracker mit Labels zu füllen, die dort niemand pflegt.
 
 ---
 
@@ -50,15 +64,60 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 
 ---
 
-## 3 · Kleinigkeiten
+## 3 · Aufgefallen beim Bauen
+
+Beobachtungen aus der Arbeit an v1.6.0 bis v1.10.1 — festgehalten, damit sie
+nicht verloren gehen. Nichts davon ist dringend.
+
+### 3.1 Anwendungsname bricht in der Kopfleiste ab `S`
+
+Zwischen 320 und 375 px wird aus „Nebula" ein „Neb…". Gemessen über fünf
+Breiten und zwei Seiten: betrifft alle Seiten gleichermaßen. Seit die
+Aufgaben als dritter Punkt danebenstehen, ist es enger geworden.
+
+### 3.2 Indizes für die projektübergreifenden Seiten `S`
+
+Weder `Task` noch `Activity` haben einen Besitzer — die Trennung läuft über
+`project: { ownerId }`. Die vorhandenen Indizes
+(`[projectId, status, position]` bzw. `[projectId, createdAt]`) greifen für
+Abfragen über alle Projekte deshalb nicht.
+
+Betroffen sind inzwischen vier Seiten: Aufgabenübersicht, Wochenrückblick,
+Zeitleiste und die Volltextsuche. Bei einigen hundert Datensätzen fällt das
+nicht auf. Wird eine der Seiten träge, sind Indizes auf `Task.dueDate` und
+`Activity.createdAt` der erste Griff — und dann eine Migration wert.
+
+### 3.3 Projektfilter auf der Zeitleiste `S`
+
+Über alle Projekte wird die Liste schnell lang. Der Wochenrückblick hat
+Wochengrenzen als natürliche Bremse, die Zeitleiste nicht. Bewusst
+weggelassen, weil das Issue nur „derselbe Verlauf, projektübergreifend"
+verlangte.
+
+### 3.4 Abgleich gegen geleakte Passwörter `M`
+
+ASVS 2.1.7 verlangt es; umgesetzt ist bisher nur eine lokale Sperrliste plus
+Mustererkennung (Wiederholungen, Zeichenfolgen, Benutzername im Passwort).
+Have-I-Been-Pwned scheidet aus — Nebula ruft grundsätzlich nichts von außen,
+und ein Passwort-Präfix nach draußen zu geben widerspräche dem erst recht.
+Eine lokale Top-10000-Liste als Datei wäre der Kompromiss.
+
+### 3.5 v0.2.0 und v0.3.0 ohne Release `S`
+
+Beide stehen im Änderungsverlauf, existierten aber nie in der
+`package.json` — dort springt die Historie von 0.1.0 auf 0.4.0. Nachgetragen
+wurden sie in dem Commit, der den Verlauf einführte, und der liegt *nach*
+0.4.0. Es gibt also keinen ehrlichen Commit, an dem ein Tag hängen könnte.
+Die übrigen 18 Fassungen haben seit dem 18.08.2026 ein Release in Gitea.
+
+---
+
+## 4 · Kleinigkeiten
 
 | Idee | Aufwand | Nutzen |
 | --- | --- | --- |
-| Wochenrückblick | `S` | „Was ist diese Woche passiert" über alle Projekte, aus dem Aktivitätsverlauf |
-| Globale Zeitleiste | `S` | Derselbe Verlauf, aber projektübergreifend als eigene Seite |
-| Suche über Aufgaben | `S` | Die Volltextsuche deckt bisher nur Notizen ab |
 | Suchtreffer in Notizen hervorheben | `S` | In der Notiz selbst, nicht nur in der Trefferliste |
-| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt |
+| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt — fällt weitgehend mit 1.3 ab |
 | Tastaturkürzel-Übersicht mit `?` | `S` | Es gibt inzwischen genug davon |
 | Hell/Dunkel umschaltbar | `M` | Aktuell nur dunkel |
 | Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
@@ -66,7 +125,7 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 
 ---
 
-## 4 · Bewusst nicht
+## 5 · Bewusst nicht
 
 Damit klar ist, was **nicht** kommt und warum:
 
@@ -79,7 +138,10 @@ Damit klar ist, was **nicht** kommt und warum:
 - **Anhänge an Notizen.** Bräuchte Dateispeicher und damit eine zweite Sorge
   bei jeder Sicherung. Ein Link ins Git tut es auch.
 - **Eigene Git-Operationen** (klonen, committen, pushen). Nebula ist eine
-  Übersicht, keine Entwicklungsumgebung.
+  Übersicht, keine Entwicklungsumgebung. Issues über die HTTP-API der
+  Provider sind davon nicht berührt — die gibt es seit v1.7.0.
+- **Beidseitige Synchronisation von Aufgaben und Issues** mit
+  Konfliktauflösung — siehe 1.3.
 - **Zeiterfassung, Rechnungen, Kundenverwaltung.** Andere Baustelle.
 - **Cloud-Synchronisation.** Die Daten bleiben in deiner Datenbank; das ist
   der Punkt.
@@ -111,6 +173,12 @@ Damit klar ist, was **nicht** kommt und warum:
 | **v1.3.0** Wiederkehrende Aufgaben, Barrierefreiheit nach WCAG 2.1 AA | ✓ |
 | **v1.4.0** README-Vorschau auf der Projektseite | ✓ |
 | **v1.5.0** Sicherheitsdurchsicht, Server-Anleitung und Update-Skript | ✓ |
+| **v1.6.0** Mobile Ansicht, Listenansicht, Schnellerfassung, Aufgaben über alle Projekte | ✓ |
+| **v1.7.0** Aufgabe als Git-Issue anlegen, Webhooks für Push und Issues | ✓ |
+| **v1.8.0** Anmeldung und Sitzungen nach OWASP: scrypt-Aufwand, Aufzählbarkeit, Leerlauffrist, Cookie-Härtung | ✓ |
+| **v1.9.0** Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab | ✓ |
+| **v1.10.0** Wochenrückblick, globale Zeitleiste, Suche über Aufgaben | ✓ |
+| **v1.10.1** Issue-Kennzeichen auf der Aufgabenkarte, Token-Rechte Aufruf für Aufruf belegt | ✓ |
 
 Zur Entscheidung beim Export: Git-Tokens gehen **nicht** mit. Die Verbindung wird nur
 beschrieben, das Token ist nach dem Import neu zu hinterlegen. Snapshots bleiben

docker-compose.dev.yml

@@ -0,0 +1,23 @@
+# ─────────────────────────────────────────────────────────────
+#  Overlay fuer die Entwicklung: macht die Datenbank auf dem Host erreichbar.
+#
+#  Gebraucht wird das nur, wenn die Anwendung ausserhalb des Containers
+#  laeuft – "npm run dev" verbindet sich dann ueber localhost:5432. Im
+#  Vollbetrieb spricht die Anwendung "db:5432" im Docker-Netz an und braucht
+#  diese Datei nicht.
+#
+#  Aufruf:
+#    docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db
+#    npm run dev
+#
+#  Kuerzer: npm run docker:db
+#
+#  Gebunden wird auf 127.0.0.1, nicht auf 0.0.0.0. Docker traegt Freigaben
+#  direkt in iptables ein und umgeht dabei ufw – eine offene Bindung stuende
+#  also auch bei aktiver Firewall im Netz.
+# ─────────────────────────────────────────────────────────────
+
+services:
+  db:
+    ports:
+      - "${POSTGRES_PORT:-127.0.0.1:5432}:5432"

docker-compose.server.yml

@@ -0,0 +1,46 @@
+# ─────────────────────────────────────────────────────────────
+#  Overlay fuer den Serverbetrieb: kein einziger Port geht zum Host.
+#
+#  Gedacht fuer einen Docker-Host, auf dem mehrere Stacks liegen und ein
+#  gemeinsamer Reverse Proxy die einzige Tuer nach draussen ist. Die
+#  Datenbank veroeffentlicht ohnehin nichts; diese Datei nimmt zusaetzlich
+#  die Freigabe der Anwendung zurueck und haengt sie in ein geteiltes Netz,
+#  ueber das der Proxy sie erreicht.
+#
+#  Aufruf:
+#    docker compose -f docker-compose.yml -f docker-compose.server.yml \
+#      --profile full up -d --build
+#
+#  Bequemer ist, das dauerhaft in die .env zu schreiben:
+#    COMPOSE_FILE=docker-compose.yml:docker-compose.server.yml
+#    COMPOSE_PROFILES=full
+#  Danach genuegt ueberall "docker compose up -d" – auch in update.sh.
+#  (Trennzeichen: Doppelpunkt unter Linux, Semikolon unter Windows.)
+#
+#  Das Netz muss es vorher geben (der Proxy-Stack legt es ueblicherweise an):
+#    docker network create proxy
+#
+#  Im Proxy zeigt das Ziel dann auf  http://nebula:3000  bzw.  nebula-app:3000.
+# ─────────────────────────────────────────────────────────────
+
+services:
+  app:
+    # !reset loescht die Portfreigabe aus der Basisdatei. Ohne dieses Tag
+    # wuerden die Listen zusammengefuegt statt ersetzt – Compose behandelt
+    # "ports" beim Zusammenfuehren als anzuhaengende Liste. Braucht
+    # Compose 2.24 oder neuer.
+    ports: !reset []
+    networks:
+      # Das stackeigene Netz: darueber spricht die Anwendung mit der Datenbank.
+      default:
+      # Das geteilte Netz zum Reverse Proxy. Der Alias ist der Name, unter dem
+      # der Proxy Nebula anspricht – kurz und eindeutig, denn "app" hiessen in
+      # einem geteilten Netz schnell mehrere Container.
+      proxy:
+        aliases:
+          - ${PROXY_ALIAS:-nebula}
+
+networks:
+  proxy:
+    external: true
+    name: ${PROXY_NETWORK:-proxy}

docker-compose.yml

@@ -1,14 +1,20 @@
 name: nebula
 
 # ─────────────────────────────────────────────────────────────
-#  Zwei Betriebsarten aus einer Datei:
+#  Diese Datei veroeffentlicht nur einen einzigen Port, und den auf dem
+#  Loopback: den der Anwendung. Die Datenbank bleibt im Docker-Netz.
 #
-#  1) Standalone-Entwicklung – nur die Datenbank im Container:
-#       docker compose up -d db
+#  1) Alles im Container (Server wie Entwicklung):
+#       docker compose --profile full up -d --build
+#
+#  2) Standalone-Entwicklung – Datenbank im Container, App auf dem Host.
+#     Dafuer muss Postgres auf dem Host erreichbar sein, also mit dem
+#     Entwicklungs-Overlay (oder kurz: npm run docker:db):
+#       docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db
 #       npm run dev
 #
-#  2) Alles im Container:
-#       docker compose --profile full up -d --build
+#  3) Server ohne jede Portfreigabe, hinter einem Reverse Proxy im
+#     gemeinsamen Docker-Netz:      siehe docker-compose.server.yml
 #
 #  Optionales DB-Webinterface:
 #       docker compose --profile tools up -d adminer   → http://localhost:8080
@@ -25,8 +31,10 @@ services:
       POSTGRES_DB: ${POSTGRES_DB:-nebula}
       # Deterministische Sortierung unabhaengig vom Host-Locale
       POSTGRES_INITDB_ARGS: "--encoding=UTF8"
-    ports:
-      - "${POSTGRES_PORT:-5432}:5432"
+    # Absichtlich keine Portfreigabe: die Anwendung erreicht die Datenbank im
+    # Container ueber "db:5432", und backup.sh geht ueber "docker exec". Nach
+    # aussen muss hier nichts. Wer die Datenbank vom Host aus braucht – fuer
+    # "npm run dev" oder psql – nimmt docker-compose.dev.yml dazu.
     volumes:
       - nebula-db-data:/var/lib/postgresql/data
     healthcheck:
@@ -73,7 +81,11 @@ services:
       PORT: 3000
       HOSTNAME: 0.0.0.0
     ports:
-      - "${APP_PORT:-3000}:3000"
+      # Nur auf dem Loopback: nach draussen kommt man ueber den Reverse Proxy.
+      # Docker schreibt seine Freigaben an ufw vorbei direkt in iptables – eine
+      # Bindung auf 0.0.0.0 stuende also im Netz, auch bei aktiver Firewall.
+      # Ganz ohne Host-Port: docker-compose.server.yml.
+      - "${APP_PORT:-127.0.0.1:3000}:3000"
 
   adminer:
     profiles: ["tools"]
@@ -87,7 +99,7 @@ services:
       ADMINER_DEFAULT_SERVER: db
       ADMINER_DESIGN: dracula
     ports:
-      - "${ADMINER_PORT:-8080}:8080"
+      - "${ADMINER_PORT:-127.0.0.1:8080}:8080"
 
 volumes:
   nebula-db-data:

e2e/api.spec.ts

@@ -1,4 +1,13 @@
 import { expect, test, type APIRequestContext } from "@playwright/test";
+import { PrismaClient } from "@prisma/client";
+
+/**
+ * Dieselbe Datenbank wie global-setup.ts. Gebraucht fuer den einen Fall, in
+ * dem ein Zustand herzustellen ist, den die API bewusst nicht anbietet.
+ */
+const DATABASE_URL =
+  process.env.E2E_DATABASE_URL ??
+  "postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
 
 /**
  * Tests ueber HTTP gegen die laufende Anwendung – also durch Middleware,
@@ -279,6 +288,228 @@ test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
   expect(zumSchluss.repositories[0].repoName).toBe("swr");
 });
 
+test("Die Anmeldung verraet nicht, welche Konten es gibt", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Ein Konto anlegen und stilllegen.
+  const angelegt = await request.post("/api/admin/users", {
+    data: {
+      username: "stillgelegt",
+      password: "ein-ausreichend-langes-passwort",
+      role: "USER",
+    },
+  });
+  expect(angelegt.status()).toBe(201);
+  const id = (await angelegt.json()).user.id;
+  expect((await request.patch(`/api/admin/users/${id}`, { data: { isActive: false } })).ok())
+    .toBeTruthy();
+
+  const anonym = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+
+  // Falsches Passwort auf dem stillgelegten Konto ...
+  const stillgelegt = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "falsches-passwort-hier" },
+  });
+  // ... und auf einem Konto, das es gar nicht gibt.
+  const erfunden = await anonym.post("/api/auth/login", {
+    data: { username: "gibtesnicht", password: "falsches-passwort-hier" },
+  });
+
+  // Beides muss ununterscheidbar sein – sonst laesst sich durchprobieren,
+  // welche Benutzernamen vergeben sind. Frueher kam hier 403 gegen 401.
+  expect(stillgelegt.status()).toBe(erfunden.status());
+  expect(stillgelegt.status()).toBe(401);
+  expect(await stillgelegt.json()).toEqual(await erfunden.json());
+
+  // Mit dem richtigen Passwort darf die Anwendung dann Klartext reden.
+  const mitPasswort = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "ein-ausreichend-langes-passwort" },
+  });
+  expect(mitPasswort.status()).toBe(403);
+  expect((await mitPasswort.json()).error).toMatch(/deaktiviert/);
+
+  await anonym.dispose();
+  await request.delete(`/api/admin/users/${id}`);
+});
+
+test("Abgleich hakt Aufgaben ab, deren Issue geschlossen wurde", async ({ request }) => {
+  await login(request, ADMIN);
+
+  // Ein oeffentliches Repository mit sicher geschlossenen Issues. Der
+  // Abgleich laeuft anonym gegen die GitHub-API – kein Token noetig.
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Rueckweg", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  const angelegt = await request.post(`/api/projects/${projekt.id}/tasks`, {
+    data: { title: "Haengt an einem geschlossenen Issue" },
+  });
+  const taskId = (await angelegt.json()).task.id;
+
+  /**
+   * Die Verknuepfung direkt in der Datenbank setzen.
+   *
+   * Ueber die API gibt es dafuer keinen Weg, und das ist richtig so: "als
+   * Issue anlegen" wuerde ein neues Issue in einem fremden Repository
+   * erzeugen. Ein Endpunkt nur fuer Tests waere eine Hintertuer im
+   * Produktionscode – dafuer greift der Test lieber selbst zur Datenbank.
+   *
+   * Issue 1 von vercel/swr ist seit Jahren geschlossen.
+   */
+  const prisma = new PrismaClient({
+    datasources: { db: { url: DATABASE_URL } },
+  });
+  try {
+    await prisma.task.update({
+      where: { id: taskId },
+      data: { sourceRepositoryId: repoId, sourceIssue: 1 },
+    });
+  } finally {
+    await prisma.$disconnect();
+  }
+
+  const vorher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const alsAngelegt = vorher.project.tasks.find(
+    (t: { id: string }) => t.id === taskId,
+  );
+  expect(alsAngelegt.sourceIssue).toBe(1);
+  expect(alsAngelegt.status).toBe("TODO");
+
+  // Abgleich anstossen – er fragt den Zustand des Issues nach.
+  const sync = await request.post(`/api/repositories/${repoId}/sync`);
+  const syncBody = await sync.json();
+
+  /**
+   * Dieser Test greift als einziger wirklich nach draussen. Ist GitHub nicht
+   * erreichbar oder das anonyme Rate-Limit ausgeschoepft, sagt er das statt
+   * rot zu werden – ein fremder Dienst darf die Testreihe nicht bestimmen.
+   */
+  if (!sync.ok()) {
+    test.skip(true, `GitHub nicht erreichbar: ${syncBody.message ?? sync.status()}`);
+    return;
+  }
+
+  const nachher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const abgehakt = nachher.project.tasks.find((t: { id: string }) => t.id === taskId);
+  expect(abgehakt.status).toBe("DONE");
+  expect(abgehakt.doneAt).not.toBeNull();
+
+  // Und ein zweiter Lauf aendert nichts mehr – abgehakt bleibt abgehakt,
+  // ohne dass erneut nachgefragt wird.
+  const nochmal = await request.post(`/api/repositories/${repoId}/sync`);
+  expect((await nochmal.json()).message ?? "").not.toMatch(/abgehakt/);
+});
+
+test("Webhook: Signatur entscheidet, sonst passiert nichts", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Hakenprojekt", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  // Ohne eingerichteten Webhook ist der Endpunkt stumm – und zwar mit 404,
+  // damit die ID nicht bestaetigt wird.
+  const ohne = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json" },
+    data: { action: "closed", issue: { number: 1 } },
+  });
+  expect(ohne.status()).toBe(404);
+
+  // Einrichten liefert das Geheimnis genau einmal zurueck.
+  const eingerichtet = await request.post(`/api/repositories/${repoId}/webhook`);
+  expect(eingerichtet.status()).toBe(200);
+  const { secret, url } = await eingerichtet.json();
+  expect(typeof secret).toBe("string");
+  expect(secret.length).toBeGreaterThanOrEqual(64);
+  expect(url).toContain(`/api/webhooks/${repoId}`);
+
+  // Und danach nirgends mehr: weder im Projekt noch am Repository.
+  const geladen = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  expect(JSON.stringify(geladen)).not.toContain(secret);
+  expect(geladen.project.repositories[0].webhookSecret).toBeUndefined();
+
+  // Eine Aufgabe, die an einem Issue haengt – von Hand gesetzt gibt es
+  // nicht, also ueber die Uebernahme aus dem Snapshot. Stattdessen prueft
+  // dieser Test die Grenze selbst: ohne gueltige Signatur passiert nichts.
+  const rumpf = JSON.stringify({ action: "closed", issue: { number: 4242 } });
+
+  const falsch = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": "sha256=00",
+    },
+    data: rumpf,
+  });
+  expect(falsch.status()).toBe(401);
+
+  const gar_keine = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json", "X-GitHub-Event": "issues" },
+    data: rumpf,
+  });
+  expect(gar_keine.status()).toBe(401);
+
+  // Mit richtiger Signatur wird der Aufruf angenommen. Zu Issue 4242 gibt
+  // es keine Aufgabe – erwartet ist also "angenommen, nichts zugeordnet".
+  const { createHmac } = await import("node:crypto");
+  const signatur = createHmac("sha256", secret).update(rumpf, "utf8").digest("hex");
+  const richtig = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(richtig.status()).toBe(200);
+  const antwort = await richtig.json();
+  expect(antwort).toMatchObject({ ok: true, handled: "issue", matched: false });
+
+  // Dieselbe Signatur zu einem anderen Rumpf gilt nicht.
+  const veraendert = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: JSON.stringify({ action: "closed", issue: { number: 9999 } }),
+  });
+  expect(veraendert.status()).toBe(401);
+
+  // Fremde Konten koennen den Haken weder einrichten noch zuruecknehmen.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await fremd.post(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  expect((await fremd.delete(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  await fremd.dispose();
+
+  // Zuruecknehmen schliesst den Endpunkt wieder.
+  expect((await request.delete(`/api/repositories/${repoId}/webhook`)).ok()).toBeTruthy();
+  const danach = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(danach.status()).toBe(404);
+});
+
 test("Brett: Reihenfolge und Mehrfachauswahl", async ({ request, playwright }) => {
   await login(request, ADMIN);
 
@@ -532,6 +763,112 @@ test("Projektvorlagen: aus Projekt sichern und anwenden", async ({ request, play
   expect((await request.delete(`/api/templates/${vorlage.id}`)).ok()).toBeTruthy();
 });
 
+test("Verlauf blaettert per Cursor, ohne Zeilen zu verlieren", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Die bisherigen Tests haben reichlich Verlauf erzeugt. Erst alles auf
+  // einmal holen, dann in kleinen Seiten – beides muss dieselbe Menge sein.
+  const alles = await (await request.get("/api/activity?limit=100")).json();
+  expect(alles.activities.length).toBeGreaterThan(5);
+
+  const ids: string[] = [];
+  let cursor: { vor: string; id: string } | null = null;
+  for (let seite = 0; seite < 60; seite += 1) {
+    const query = cursor
+      ? `?limit=3&vor=${encodeURIComponent(cursor.vor)}&id=${encodeURIComponent(cursor.id)}`
+      : "?limit=3";
+    const antwort = await request.get(`/api/activity${query}`);
+    expect(antwort.ok()).toBeTruthy();
+    const seiteBody = await antwort.json();
+    ids.push(...seiteBody.activities.map((eintrag: { id: string }) => eintrag.id));
+    if (!seiteBody.weitere) break;
+    cursor = seiteBody.naechster;
+    expect(cursor).not.toBeNull();
+  }
+
+  // Der eigentliche Punkt: keine Dubletten und keine Luecken, auch wenn
+  // mehrere Eintraege denselben Zeitstempel tragen.
+  expect(new Set(ids).size).toBe(ids.length);
+  expect(ids.length).toBe(alles.activities.length);
+
+  // Absteigend sortiert.
+  const zeiten: number[] = alles.activities.map((eintrag: { createdAt: string }) =>
+    Date.parse(eintrag.createdAt),
+  );
+  for (let i = 1; i < zeiten.length; i += 1) {
+    expect(zeiten[i]).toBeLessThanOrEqual(zeiten[i - 1]);
+  }
+
+  // Unbrauchbare Cursor fangen von vorn an, statt zu scheitern.
+  const kaputt = await request.get("/api/activity?vor=keindatum&id=x");
+  expect(kaputt.ok()).toBeTruthy();
+  expect((await kaputt.json()).activities.length).toBeGreaterThan(0);
+
+  // Und ein fremdes Konto sieht ausschliesslich seinen eigenen Verlauf.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  const fremderVerlauf = await (await fremd.get("/api/activity")).json();
+  const eigeneIds = new Set(ids);
+  for (const eintrag of fremderVerlauf.activities) {
+    expect(eigeneIds.has(eintrag.id)).toBe(false);
+  }
+  await fremd.dispose();
+});
+
+test("Volltextsuche findet auch Aufgaben", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Suchprojekt" } })).json()
+  ).project;
+
+  for (const task of [
+    {
+      title: "Dockerfile aufraeumen",
+      description: "Die Schichten im Container neu ordnen, damit der Bau schneller wird.",
+    },
+    { title: "Rechnungen exportieren", description: "Monatlicher Export als CSV." },
+    { title: "Erledigtes mit Container", description: "Auch das soll gefunden werden.", status: "DONE" },
+    { title: "Ohne Bezug", description: "Voellig anderer Inhalt." },
+  ]) {
+    expect((await request.post(`/api/projects/${projekt.id}/tasks`, { data: task })).status()).toBe(
+      201,
+    );
+  }
+
+  // Titel und Beschreibung werden durchsucht.
+  const container = await (await request.get("/api/search?q=Container")).json();
+  const titel = container.tasks.map((treffer: { title: string }) => treffer.title);
+  expect(titel).toContain("Dockerfile aufraeumen");
+  // Erledigtes bleibt drin – wer sucht, sucht oft gerade das Abgehakte.
+  expect(titel).toContain("Erledigtes mit Container");
+  expect(titel).not.toContain("Ohne Bezug");
+
+  // Deutsche Stammformen: "Rechnung" findet "Rechnungen".
+  const rechnung = await (await request.get("/api/search?q=Rechnung")).json();
+  expect(rechnung.tasks.map((t: { title: string }) => t.title)).toContain(
+    "Rechnungen exportieren",
+  );
+
+  // Das Projekt taucht in projectIds auf, damit das Brett es einblendet.
+  expect(container.projectIds).toContain(projekt.id);
+
+  // Zu kurze Eingaben liefern leere Listen statt Unsinn.
+  const kurz = await (await request.get("/api/search?q=a")).json();
+  expect(kurz.tasks).toEqual([]);
+  expect(kurz.hits).toEqual([]);
+
+  // Und ein fremdes Konto findet nichts davon.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await (await fremd.get("/api/search?q=Container")).json()).tasks).toHaveLength(0);
+  await fremd.dispose();
+});
+
 test("Der Bildoptimierer ist zu", async ({ playwright }) => {
   // /_next/image reicht jedes Bild durch sharp und damit durch libvips, fuer
   // das es regelmaessig Schwachstellen gibt. Nebula benutzt next/image

e2e/ui.spec.ts

@@ -106,6 +106,192 @@ test("Volltextsuche findet Notizen", async ({ page }) => {
   await expect(page.getByText("Treffer in Notizen")).toBeVisible();
 });
 
+test("Listenansicht auf Telefonbreite ohne seitliches Scrollen", async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+
+  await page.getByRole("button", { name: "Liste" }).click();
+  await expect(page.getByRole("link", { name: /Projekt Oberflaechentest/ })).toBeVisible();
+
+  // Der eigentliche Punkt der Ansicht: sie passt in die Breite. Frueher schob
+  // die Steuerleiste den Knopf "Neues Projekt" aus dem Bild und die ganze
+  // Seite liess sich seitwaerts schieben.
+  const masse = await page.evaluate(() => ({
+    scrollWidth: document.documentElement.scrollWidth,
+    clientWidth: document.documentElement.clientWidth,
+  }));
+  expect(masse.scrollWidth).toBeLessThanOrEqual(masse.clientWidth + 1);
+
+  // Auch der Knopf muss erreichbar bleiben – auf dieser Breite traegt er nur
+  // noch das Pluszeichen und lebt von seinem aria-label. Geprueft wird die
+  // rechte Kante: genau die lag vorher ausserhalb des Bildschirms.
+  const knopf = page.getByRole("button", { name: "Neues Projekt" });
+  await expect(knopf).toBeVisible();
+  const kasten = await knopf.boundingBox();
+  expect(kasten).not.toBeNull();
+  expect(kasten!.x + kasten!.width).toBeLessThanOrEqual(masse.clientWidth);
+});
+
+test("Schnellerfassung legt Idee und Aufgabe mit einem Feld an", async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+
+  await page.getByRole("button", { name: "Schnell erfassen" }).click();
+  const dialog = page.getByRole("dialog");
+  await expect(dialog).toBeVisible();
+
+  // Idee: nur der Name, alles andere kommt aus den Vorgaben des Schemas.
+  await page.fill("#quick-title", "Aus der Bahn notiert");
+  await dialog.getByRole("button", { name: "Anlegen" }).click();
+
+  // Der Dialog bleibt offen und bestaetigt – das ist der Punkt der
+  // Schnellerfassung: die naechste Idee soll ohne Umweg hineingehen.
+  await expect(dialog.getByText("Angelegt")).toBeVisible();
+  await expect(dialog.getByRole("link", { name: "Aus der Bahn notiert" })).toBeVisible();
+  await expect(page.locator("#quick-title")).toHaveValue("");
+
+  // Aufgabe: derselbe Dialog, ein Feld mehr.
+  await dialog.getByRole("button", { name: "Aufgabe", exact: true }).click();
+  await page.fill("#quick-title", "Unterwegs eingefallen");
+  await expect(page.locator("#quick-project")).toBeVisible();
+  await dialog.getByRole("button", { name: "Anlegen" }).click();
+  await expect(dialog.getByRole("link", { name: "Unterwegs eingefallen" })).toBeVisible();
+
+  await page.keyboard.press("Escape");
+  await expect(dialog).toBeHidden();
+
+  // Die Idee steht als Projekt im Dashboard.
+  await page.goto("/");
+  await expect(page.getByText("Aus der Bahn notiert")).toBeVisible();
+});
+
+test("Dialoge weichen der Bildschirmtastatur aus", async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+  await page.getByRole("button", { name: "Schnell erfassen" }).click();
+  await expect(page.getByRole("dialog")).toBeVisible();
+
+  const TASTATUR = 336;
+
+  /**
+   * Eine echte Tastatur laesst sich nicht einblenden. Stattdessen meldet
+   * visualViewport eine kleinere Hoehe – genau die Schnittstelle, an der
+   * der Dialog haengt. Ueberschrieben wird am echten Objekt: der Dialog
+   * merkt sich beim Oeffnen eine Referenz darauf.
+   */
+  await page.evaluate((tastatur) => {
+    const fenster = window.visualViewport;
+    if (!fenster) throw new Error("visualViewport fehlt");
+    const hoehe = window.innerHeight - tastatur;
+    Object.defineProperty(fenster, "height", { get: () => hoehe, configurable: true });
+    Object.defineProperty(fenster, "offsetTop", { get: () => 0, configurable: true });
+    fenster.dispatchEvent(new Event("resize"));
+  }, TASTATUR);
+
+  await page.waitForTimeout(300);
+
+  // Eingabefeld und Absendeknopf muessen oberhalb der Tastatur liegen.
+  // Vorher stand der Dialog mittig im vollen Fenster – und damit zur
+  // Haelfte darunter.
+  const frei = 667 - TASTATUR;
+  for (const ziel of [
+    page.locator("#quick-title"),
+    page.getByRole("dialog").getByRole("button", { name: "Anlegen" }),
+  ]) {
+    const kasten = await ziel.boundingBox();
+    expect(kasten).not.toBeNull();
+    expect(kasten!.y + kasten!.height).toBeLessThanOrEqual(frei);
+  }
+
+  await page.keyboard.press("Escape");
+});
+
+test("Aufgabenuebersicht sammelt ueber alle Projekte und hakt ab", async ({ page }) => {
+  await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
+  await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
+
+  // Die zuvor per Schnellerfassung angelegte Aufgabe taucht hier auf,
+  // obwohl sie in einem anderen Projekt haengt.
+  const zeile = page.getByRole("listitem").filter({ hasText: "Unterwegs eingefallen" });
+  await expect(zeile).toBeVisible();
+
+  // Abhaken aus der Uebersicht heraus.
+  await zeile.getByRole("button", { name: /abhaken/ }).click();
+  // Ohne "Erledigte einblenden" verschwindet sie damit aus der Liste.
+  await expect(zeile).toBeHidden();
+
+  await page.getByLabel("Erledigte einblenden").check();
+  await expect(
+    page.getByRole("listitem").filter({ hasText: "Unterwegs eingefallen" }),
+  ).toBeVisible();
+});
+
+test("Wochenrueckblick zeigt, was diese Woche passiert ist", async ({ page }) => {
+  // Erreichbar vom Dashboard aus, ohne vierten Punkt in der Kopfleiste.
+  await page.getByRole("link", { name: /Wochenrückblick/ }).click();
+  await expect(page).toHaveURL(/\/rueckblick$/);
+  await expect(page.getByRole("heading", { name: "Diese Woche", level: 1 })).toBeVisible();
+
+  // Die Vorgaenge der bisherigen Tests liegen in dieser Woche, es muss also
+  // etwas dastehen – und das Projekt gehoert an jede Zeile.
+  await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
+
+  // Blättern: zurück und wieder her.
+  await page.getByRole("link", { name: "Eine Woche zurück" }).click();
+  await expect(page).toHaveURL(/woche=-1/);
+  await expect(page.getByRole("heading", { name: "Vorige Woche", level: 1 })).toBeVisible();
+
+  await page.getByRole("link", { name: "Diese Woche", exact: true }).click();
+  await expect(page).toHaveURL(/\/rueckblick$/);
+
+  // Auch ueber die Schnellsuche erreichbar.
+  await page.goto("/");
+  await page.keyboard.press("Control+k");
+  await page.getByPlaceholder(/^Projekt, /).fill("Rückblick");
+  await page.keyboard.press("Enter");
+  await expect(page).toHaveURL(/\/rueckblick/);
+});
+
+test("Globale Zeitleiste zeigt den Verlauf ueber alle Projekte", async ({ page }) => {
+  // Vom Wochenrueckblick aus verlinkt.
+  await page.goto("/rueckblick");
+  await page.getByRole("link", { name: /Ganzer Verlauf/ }).click();
+  await expect(page).toHaveURL(/\/verlauf$/);
+  await expect(page.getByRole("heading", { name: "Verlauf", level: 1 })).toBeVisible();
+
+  // Eintraege mit Projektbezug – ohne den ist eine uebergreifende Liste
+  // nicht zu lesen.
+  await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
+  await expect(page.getByText(/Vorgänge geladen|Vorgang geladen/)).toBeVisible();
+
+  // Auch ueber die Schnellsuche erreichbar.
+  await page.goto("/");
+  await page.keyboard.press("Control+k");
+  await page.getByPlaceholder(/^Projekt, /).fill("Verlauf");
+  await page.keyboard.press("Enter");
+  await expect(page).toHaveURL(/\/verlauf/);
+});
+
+test("Aufgabendashboard laesst sich durchsuchen", async ({ page }) => {
+  await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
+  await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
+
+  const suchfeld = page.getByLabel("Aufgaben durchsuchen");
+  await expect(suchfeld).toBeVisible();
+
+  // Aus den frueheren Tests gibt es "Erste Aufgabe" und "Zweite Aufgabe".
+  await suchfeld.fill("Erste");
+  await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
+  await expect(page.getByRole("listitem").filter({ hasText: "Zweite Aufgabe" })).toBeHidden();
+
+  // Ohne Treffer erklaert der Leerzustand, worin gesucht wurde.
+  await suchfeld.fill("gibtesnichtxyz");
+  await expect(page.getByText("Keine Treffer")).toBeVisible();
+  await expect(page.getByText(/Titel, Beschreibung, Labels und Projektname/)).toBeVisible();
+
+  // Zuruecksetzen bringt alles wieder.
+  await page.getByRole("button", { name: "Suche zuruecksetzen" }).click();
+  await expect(suchfeld).toHaveValue("");
+  await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
+});
+
 test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   await page.keyboard.press("Control+k");
   await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
@@ -113,7 +299,7 @@ test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   // Ohne Eingabe stehen Projekte und Bereiche bereit.
   await expect(page.getByRole("dialog").getByText("Oberflaechentest")).toBeVisible();
 
-  await page.getByPlaceholder(/Projekt, Notiz oder Bereich/).fill("Zaunkoenig");
+  await page.getByPlaceholder(/^Projekt, /).fill("Zaunkoenig");
   await expect(page.getByRole("dialog").getByText(/in Oberflaechentest/)).toBeVisible();
 
   // Enter springt zum ersten Treffer.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "nebula",
-  "version": "1.2.0",
+  "version": "1.10.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "nebula",
-      "version": "1.2.0",
+      "version": "1.10.1",
       "hasInstallScript": true,
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nebula",
-  "version": "1.5.0",
+  "version": "1.10.1",
   "private": true,
   "description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
   "scripts": {
@@ -16,7 +16,7 @@
     "db:studio": "prisma studio",
     "db:seed": "prisma db seed",
     "db:reset": "prisma migrate reset",
-    "docker:db": "docker compose up -d db",
+    "docker:db": "docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d db",
     "docker:db:down": "docker compose stop db",
     "docker:up": "docker compose --profile full up -d --build",
     "docker:down": "docker compose --profile full down",

prisma/migrations/20260815000000_repository_webhook/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "Repository" ADD COLUMN     "webhookLastAt" TIMESTAMP(3),
+ADD COLUMN     "webhookSecret" TEXT;

prisma/migrations/20260818000000_task_fulltext/migration.sql

@@ -0,0 +1,20 @@
+-- Volltextsuche ueber Aufgaben.
+--
+-- Wie Note_fulltext_idx ein Ausdrucksindex: Prisma kann so etwas im Schema
+-- nicht abbilden und kennt ihn deshalb nicht. Nachgeprueft mit
+-- "prisma migrate diff" gegen das Schema - es kommt "empty migration"
+-- heraus, der Index wird also weder angelegt noch geloescht. Trotzdem beim
+-- Erzeugen kuenftiger Migrationen kurz hinsehen.
+--
+-- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
+-- Postgres berechnet to_tsvector dann je Zeile.
+--
+-- Der Ausdruck muss Zeichen fuer Zeichen dem in src/app/api/search/route.ts
+-- entsprechen, sonst greift der Index nicht. Die zweistellige Form von
+-- to_tsvector mit fester Konfiguration ist IMMUTABLE und damit indizierbar.
+--
+-- Anders als bei der Notiz ist auch die Beschreibung optional, deshalb steht
+-- coalesce um beide Spalten.
+
+CREATE INDEX "Task_fulltext_idx" ON "Task"
+  USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || coalesce("description", '')));

prisma/schema.prisma

@@ -407,6 +407,16 @@ model Repository {
   notifiedCiState   String?
   notifiedRelease   String?
 
+  /// Gemeinsames Geheimnis fuer eingehende Webhooks, verschluesselt wie die
+  /// Zugangstoken. Je Repository, weil der Haken im Git-System dort
+  /// eingetragen wird und sich einzeln zuruecknehmen laesst.
+  /// NULL heisst: fuer dieses Repository ist kein Webhook eingerichtet, und
+  /// eingehende Aufrufe werden abgewiesen.
+  webhookSecret String?
+  /// Wann zuletzt ein gueltiger Webhook ankam – die einzige Rueckmeldung
+  /// darueber, ob der Haken im Git-System wirklich funktioniert.
+  webhookLastAt DateTime?
+
   snapshot RepoSnapshot?
 
   createdAt DateTime @default(now())

scripts/setup.sh

@@ -0,0 +1,79 @@
+#!/bin/sh
+# ─────────────────────────────────────────────────────────────
+#  Legt die .env an und wuerfelt ein APP_SECRET.
+#
+#  Dasselbe wie scripts/setup.mjs, aber ohne Node: auf einem reinen
+#  Docker-Host ist keins installiert, und nur zum Erzeugen einer Textdatei
+#  eines zu verlangen waere albern. Braucht nichts ausser einer POSIX-Shell.
+#
+#  Aufruf:  ./scripts/setup.sh
+#           ./scripts/setup.sh --force    (vorhandene .env ueberschreiben)
+# ─────────────────────────────────────────────────────────────
+set -eu
+
+root="$(cd "$(dirname "$0")/.." && pwd)"
+env_datei="$root/.env"
+vorlage="$root/.env.example"
+force=0
+
+[ "${1:-}" = "--force" ] && force=1
+
+if [ -t 1 ]; then
+  gruen=$'\033[32m'; gelb=$'\033[33m'; cyan=$'\033[36m'; dim=$'\033[2m'; aus=$'\033[0m'
+else
+  gruen=""; gelb=""; cyan=""; dim=""; aus=""
+fi
+
+[ -f "$vorlage" ] || { echo "${gelb}.env.example nicht gefunden – abgebrochen.${aus}" >&2; exit 1; }
+
+# ── Zufall ───────────────────────────────────────────────────
+# openssl ist auf den meisten Systemen da, aber nicht auf allen. /dev/urandom
+# gibt es ueberall, wo diese Shell laeuft – und base64 ebenso.
+zufall() {
+  if command -v openssl >/dev/null 2>&1; then
+    openssl rand -base64 32
+  else
+    head -c 32 /dev/urandom | base64
+  fi | tr -d '\n'
+}
+
+if [ -f "$env_datei" ] && [ "$force" -eq 0 ]; then
+  echo "${gelb}·${aus} .env existiert bereits – sie wird nicht ueberschrieben."
+  echo "  ${dim}Mit --force neu anlegen (die alte wird gesichert).${aus}"
+else
+  if [ -f "$env_datei" ]; then
+    sicherung="$env_datei.$(date +%Y%m%d%H%M%S).bak"
+    cp "$env_datei" "$sicherung"
+    echo "${gelb}·${aus} Alte .env gesichert: $(basename "$sicherung")"
+  fi
+
+  secret="$(zufall)"
+  # Das Geheimnis kann / und + enthalten; als sed-Ersetzung waeren das
+  # Sonderzeichen. Deshalb zeilenweise ersetzen statt mit einem Ausdruck.
+  : > "$env_datei"
+  while IFS= read -r zeile || [ -n "$zeile" ]; do
+    case "$zeile" in
+      APP_SECRET=*) printf 'APP_SECRET="%s"\n' "$secret" >> "$env_datei" ;;
+      *) printf '%s\n' "$zeile" >> "$env_datei" ;;
+    esac
+  done < "$vorlage"
+
+  chmod 600 "$env_datei"
+  echo "${gruen}✓${aus} .env angelegt, APP_SECRET zufaellig erzeugt, Rechte auf 600."
+fi
+
+echo
+echo "${cyan}Noch anzupassen${aus}"
+echo "${dim}─────────────────────────────────────────────${aus}"
+echo "  APP_URL            die Adresse, unter der du Nebula aufrufst"
+echo "                     ${dim}bestimmt die WebAuthn-rpID – passt sie nicht, scheitern Passkeys${aus}"
+echo "  POSTGRES_PASSWORD  die Voreinstellung ist fuer Entwicklung gedacht"
+echo "  APP_PORT           auf einem Server: 127.0.0.1:3000 hinter den Reverse Proxy"
+echo
+echo "${cyan}Danach${aus}"
+echo "${dim}─────────────────────────────────────────────${aus}"
+echo "  docker compose --profile full up -d --build"
+echo "  ${dim}Der Container spielt die Migrationen beim Start selbst ein.${aus}"
+echo
+echo "  Ausfuehrlich: DEPLOYMENT.md"
+echo

scripts/update.sh

@@ -40,6 +40,13 @@ else
   rot=""; gruen=""; gelb=""; fett=""; aus=""
 fi
 
+# Die Version aus der package.json lesen – ohne Node. Auf einem reinen
+# Docker-Host ist keins installiert, und dieses Skript soll dort laufen.
+paket_version() {
+  sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$root/package.json" \
+    | head -n 1
+}
+
 schritt() { printf '\n%s▸ %s%s\n' "$fett" "$1" "$aus"; }
 ok()      { printf '  %s✓%s %s\n' "$gruen" "$aus" "$1"; }
 warnung() { printf '  %s!%s %s\n' "$gelb" "$aus" "$1"; }
@@ -50,7 +57,7 @@ schritt "Voraussetzungen"
 
 command -v docker >/dev/null || abbruch "docker nicht gefunden."
 docker compose version >/dev/null 2>&1 || abbruch "docker compose (v2) nicht gefunden."
-[ -f "$root/.env" ] || abbruch "Keine .env in $root. Zuerst 'node scripts/setup.mjs' ausfuehren."
+[ -f "$root/.env" ] || abbruch "Keine .env in $root. Zuerst './scripts/setup.sh' ausfuehren."
 [ -f "$root/docker-compose.yml" ] || abbruch "Kein docker-compose.yml in $root."
 ok "docker, compose und .env vorhanden"
 
@@ -61,15 +68,22 @@ fi
 ok "APP_SECRET gesetzt"
 
 vorher="$(git rev-parse --short HEAD 2>/dev/null || echo "unbekannt")"
-version_vorher="$(node -p "require('./package.json').version" 2>/dev/null || echo "?")"
+version_vorher="$(paket_version)"
 printf '  Aktuell: v%s (%s)\n' "$version_vorher" "$vorher"
 
 # ── Neuen Stand holen ────────────────────────────────────────
 if [ "$pull" -eq 1 ]; then
   schritt "Neuen Stand holen"
 
-  if [ -n "$(git status --porcelain)" ]; then
-    abbruch "Das Arbeitsverzeichnis ist nicht sauber. Bitte erst committen oder verwerfen."
+  schmutz="$(git status --porcelain)"
+  if [ -n "$schmutz" ]; then
+    # Nicht nur meckern, sondern zeigen, worum es geht – sonst muss man
+    # raten, was man da eigentlich verwerfen soll.
+    printf '\n%sGeaendert gegenueber dem Stand im Git:%s\n' "$fett" "$aus"
+    printf '%s\n' "$schmutz" | sed 's/^/    /'
+    printf '\n  Verwerfen:  git checkout -- .\n'
+    printf '  Behalten:   git stash\n'
+    abbruch "Das Arbeitsverzeichnis ist nicht sauber."
   fi
 
   git fetch --all --tags --quiet
@@ -83,7 +97,7 @@ if [ "$pull" -eq 1 ]; then
   fi
 
   nachher="$(git rev-parse --short HEAD)"
-  version_nachher="$(node -p "require('./package.json').version" 2>/dev/null || echo "?")"
+  version_nachher="$(paket_version)"
 
   if [ "$vorher" = "$nachher" ]; then
     warnung "Kein neuer Stand – es wird trotzdem neu gebaut."
@@ -111,7 +125,9 @@ docker compose up -d db >/dev/null
 sicherung=""
 if [ -x "$root/scripts/backup.sh" ]; then
   ausgabe="$("$root/scripts/backup.sh" 2>&1)" || abbruch "Sicherung fehlgeschlagen:\n$ausgabe"
-  sicherung="$(printf '%s' "$ausgabe" | grep -oE '[^ ]*backups/[^ ]*\.sql[^ ]*' | tail -n 1 || true)"
+  # backup.sh setzt den Pfad in Anfuehrungszeichen – die gehoeren nicht in
+  # den Namen, sonst laesst sich der Vorschlag am Ende nicht kopieren.
+  sicherung="$(printf '%s' "$ausgabe" | grep -oE '[^ "]*backups/[^ "]*\.sql[^ "]*' | tail -n 1 || true)"
   ok "Gesichert${sicherung:+: $sicherung}"
 else
   warnung "scripts/backup.sh fehlt – es wird ohne Sicherung fortgefahren."
@@ -132,16 +148,17 @@ ok "Container gestartet"
 # ── Gesundheitspruefung ──────────────────────────────────────
 schritt "Gesundheitspruefung"
 
-port="$(sed -n 's/^[[:space:]]*APP_PORT[[:space:]]*=[[:space:]]*"\{0,1\}\([^"#]*\)"\{0,1\}[[:space:]]*$/\1/p' "$root/.env" | tail -n 1)"
-port="${port:-3000}"
-
+# Gefragt wird der Container selbst, nicht der Host. Das Abbild bringt einen
+# HEALTHCHECK mit, und so ist es einerlei, ob APP_PORT nur eine Nummer ist
+# oder wie auf einem Server "127.0.0.1:3000" – und curl braucht es auch nicht.
 gesund=0
-for versuch in $(seq 1 30); do
-  if curl -fsS "http://127.0.0.1:${port}/api/health" >/dev/null 2>&1; then
-    gesund=1
-    break
-  fi
-  sleep 2
+for _ in $(seq 1 40); do
+  zustand="$(docker inspect --format '{{.State.Health.Status}}' nebula-app 2>/dev/null || echo "weg")"
+  case "$zustand" in
+    healthy) gesund=1; break ;;
+    unhealthy) break ;;
+  esac
+  sleep 3
 done
 
 if [ "$gesund" -ne 1 ]; then
@@ -150,14 +167,28 @@ if [ "$gesund" -ne 1 ]; then
   printf '\n%sZurueck zur vorigen Fassung:%s\n' "$fett" "$aus"
   printf '  git checkout %s && ./scripts/update.sh --no-pull --yes\n' "$vorher"
   [ -n "$sicherung" ] && printf '  Datenbank notfalls: ./scripts/restore.sh %s\n' "$sicherung"
-  abbruch "Die Anwendung antwortet nach 60 Sekunden nicht gesund."
+  abbruch "Der Container meldet sich nach zwei Minuten nicht gesund (Zustand: ${zustand})."
+fi
+ok "Container meldet sich gesund"
+
+# Die Anzeige der Adresse. Nicht die .env raten, sondern Docker fragen: mit
+# docker-compose.server.yml veroeffentlicht der Container gar keinen Port und
+# haengt nur im Netz des Reverse Proxy. Dann gibt "port" nichts zurueck.
+adresse="$(docker compose --profile full port app 3000 2>/dev/null | tail -n 1 || true)"
+
+if [ -n "$adresse" ]; then
+  port="${adresse##*:}"
+  if command -v curl >/dev/null 2>&1; then
+    antwort_json="$(curl -fsS "http://127.0.0.1:${port}/api/health" 2>/dev/null || true)"
+    [ -n "$antwort_json" ] && ok "Antwort: $antwort_json"
+  fi
+  wo="$adresse"
+else
+  wo="im Docker-Netz (kein Host-Port veroeffentlicht)"
 fi
 
-antwort_json="$(curl -fsS "http://127.0.0.1:${port}/api/health")"
-ok "Gesund: $antwort_json"
-
 # ── Fertig ───────────────────────────────────────────────────
-version_jetzt="$(node -p "require('./package.json').version" 2>/dev/null || echo "?")"
-printf '\n%s%s✓ Nebula v%s laeuft auf Port %s%s\n' "$gruen" "$fett" "$version_jetzt" "$port" "$aus"
+version_jetzt="$(paket_version)"
+printf '\n%s%s✓ Nebula v%s laeuft auf %s%s\n' "$gruen" "$fett" "$version_jetzt" "$wo" "$aus"
 [ -n "$sicherung" ] && printf '  Sicherung vor dem Update: %s\n' "$sicherung"
 printf '  Log mitlesen: docker compose --profile full logs -f app\n\n'

src/app/api/account/password/route.ts

@@ -47,7 +47,7 @@ export async function POST(request: Request) {
     }
   }
 
-  const weak = validatePasswordStrength(parsed.data.newPassword);
+  const weak = validatePasswordStrength(parsed.data.newPassword, user.username);
   if (weak) {
     return NextResponse.json({ error: weak, fields: { newPassword: weak } }, { status: 422 });
   }

src/app/api/activity/route.ts

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import {
+  SEITEN_ORDNUNG,
+  cursorAus,
+  seitenBedingung,
+  seitenGroesse,
+} from "@/lib/timeline";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Der Verlauf ueber alle Projekte, neueste Eintraege zuerst.
+ *
+ * Geblaettert wird per Cursor (`vor` = Zeitpunkt, `id` = Eintrag), nicht per
+ * Offset – siehe lib/timeline. Zurueck kommt der Cursor fuer die naechste
+ * Seite gleich mit, damit der Aufrufer ihn nicht selbst zusammensetzen muss.
+ */
+export async function GET(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const params = new URL(request.url).searchParams;
+  const cursor = cursorAus(params.get("vor"), params.get("id"));
+  const take = seitenGroesse(params.get("limit"));
+
+  /**
+   * Einen mehr holen als angefragt: daran laesst sich ablesen, ob es
+   * weitergeht, ohne dafuer zaehlen zu muessen.
+   */
+  const gefunden = await prisma.activity.findMany({
+    where: seitenBedingung(auth.user.id, cursor),
+    orderBy: SEITEN_ORDNUNG,
+    take: take + 1,
+    select: {
+      id: true,
+      kind: true,
+      summary: true,
+      createdAt: true,
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+  });
+
+  const weitere = gefunden.length > take;
+  const activities = weitere ? gefunden.slice(0, take) : gefunden;
+  const letzter = activities[activities.length - 1];
+
+  return NextResponse.json({
+    activities: activities.map((eintrag) => ({
+      ...eintrag,
+      createdAt: eintrag.createdAt.toISOString(),
+    })),
+    weitere,
+    naechster: weitere && letzter ? { vor: letzter.createdAt.toISOString(), id: letzter.id } : null,
+  });
+}

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

@@ -69,7 +69,7 @@ export async function PATCH(request: Request, { params }: Params) {
   }
 
   if (password) {
-    const weak = validatePasswordStrength(password);
+    const weak = validatePasswordStrength(password, target.username);
     if (weak) {
       return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
     }

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

@@ -47,7 +47,7 @@ export async function POST(request: Request) {
 
   const { username, displayName, email, password, role } = parsed.data;
 
-  const weak = validatePasswordStrength(password);
+  const weak = validatePasswordStrength(password, username);
   if (weak) {
     return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
   }

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

@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { createPendingLogin, setMfaCookie } from "@/lib/auth/mfa";
-import { fakeVerifyDelay, verifyPassword } from "@/lib/auth/password";
+import { fakeVerifyDelay, hashPassword, needsRehash, verifyPassword } from "@/lib/auth/password";
 import { createSession, setSessionCookie } from "@/lib/auth/session";
 import { lockRemainingSeconds, noteFailedLogin, noteSuccessfulLogin } from "@/lib/auth/users";
 import { prisma } from "@/lib/db";
@@ -42,6 +42,30 @@ export async function POST(request: Request) {
     return jsonError(GENERIC, 401);
   }
 
+  /**
+   * Erst das Passwort pruefen, dann ueber den Kontozustand reden.
+   *
+   * Frueher standen die Abfragen auf gesperrt, deaktiviert und
+   * "kein Passwort hinterlegt" **vor** der Pruefung und beantworteten sich
+   * damit ohne jede Kenntnis des Passworts. Wer einen Benutzernamen riet,
+   * bekam an der Antwort gesagt, ob es ihn gibt – genau die Aufzaehlbarkeit,
+   * die der einheitliche Text GENERIC sonst verhindert.
+   *
+   * Jetzt gilt: falsches Passwort → immer dieselbe Antwort. Die
+   * hilfreichere Auskunft bekommt nur, wer das Passwort kennt.
+   */
+  const valid = user.passwordHash
+    ? await verifyPassword(password, user.passwordHash)
+    : // Kein Passwort hinterlegt (reines Passkey-Konto): trotzdem Zeit
+      // verbrennen, damit sich der Fall nicht an der Antwortdauer zeigt.
+      await fakeVerifyDelay().then(() => false);
+
+  if (!valid) {
+    // Fehlversuche nur zaehlen, wo es ein Passwort zu erraten gibt.
+    if (user.passwordHash) await noteFailedLogin(user.id);
+    return jsonError(GENERIC, 401);
+  }
+
   const locked = lockRemainingSeconds(user.lockedUntil);
   if (locked > 0) {
     return jsonError(
@@ -51,22 +75,20 @@ export async function POST(request: Request) {
   }
 
   if (!user.isActive) {
-    await fakeVerifyDelay();
     return jsonError("Dieses Konto ist deaktiviert.", 403);
   }
 
-  if (!user.passwordHash) {
-    await fakeVerifyDelay();
-    return jsonError(
-      "Fuer dieses Konto ist kein Passwort hinterlegt – bitte mit Passkey anmelden.",
-      401,
-    );
-  }
-
-  const valid = await verifyPassword(password, user.passwordHash);
-  if (!valid) {
-    await noteFailedLogin(user.id);
-    return jsonError(GENERIC, 401);
+  /**
+   * Der Aufwand beim Hashen ist gestiegen. Wer sich mit einem Passwort
+   * anmeldet, dessen Hash noch nach den alten Vorgaben erzeugt wurde,
+   * bekommt hier still einen neuen – es ist der einzige Moment, in dem das
+   * Klartextpasswort vorliegt. Nebenlaeufig, damit die Anmeldung nicht auf
+   * die halbe Sekunde wartet.
+   */
+  if (needsRehash(user.passwordHash)) {
+    void hashPassword(password)
+      .then((neu) => prisma.user.update({ where: { id: user.id }, data: { passwordHash: neu } }))
+      .catch(() => undefined);
   }
 
   // Das Passwort stimmt. Ist ein zweiter Faktor eingerichtet, entsteht hier

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

@@ -39,7 +39,7 @@ export async function POST(request: Request) {
 
   const { username, displayName, email, password } = parsed.data;
 
-  const weak = validatePasswordStrength(password);
+  const weak = validatePasswordStrength(password, username);
   if (weak) {
     return NextResponse.json({ error: weak, fields: { password: weak } }, { status: 422 });
   }

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

@@ -34,7 +34,7 @@ export async function POST(request: Request) {
 
   const { username, displayName, email, password, mode } = parsed.data;
 
-  const weak = validatePasswordStrength(password);
+  const weak = validatePasswordStrength(password, username);
   if (weak) {
     return NextResponse.json(
       { error: weak, fields: { password: weak } },

src/app/api/repositories/[id]/webhook/route.ts

@@ -0,0 +1,63 @@
+import { randomBytes } from "node:crypto";
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { APP_URL } from "@/lib/config";
+import { encryptSecret } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+import { ownedRepository } from "@/lib/repositories";
+import { jsonError } from "@/lib/security/request";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/**
+ * Richtet den Webhook eines Repositories ein oder nimmt ihn zurueck.
+ *
+ * Das Geheimnis wird hier erzeugt und **genau einmal** im Klartext
+ * zurueckgegeben – danach liegt es nur noch verschluesselt in der Datenbank,
+ * wie die Zugangstoken. Wer es verliert, erzeugt ein neues; das alte gilt
+ * dann nicht mehr.
+ *
+ * Eingetragen wird der Haken im Git-System von Hand. Ihn ueber die API
+ * anzulegen waere machbar, verlangte aber Administrationsrechte am
+ * Repository – deutlich mehr, als Nebula sonst braucht.
+ */
+export async function POST(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const repository = await ownedRepository(id, auth.user.id);
+  if (!repository) return jsonError("Repository nicht gefunden", 404);
+
+  // 32 Byte, hexadezimal. Lang genug, dass Raten aussichtslos ist, und
+  // ohne Sonderzeichen, die in Formularfeldern Aerger machen.
+  const secret = randomBytes(32).toString("hex");
+
+  await prisma.repository.update({
+    where: { id: repository.id },
+    data: { webhookSecret: encryptSecret(secret), webhookLastAt: null },
+  });
+
+  return NextResponse.json({
+    secret,
+    url: `${APP_URL}/api/webhooks/${repository.id}`,
+  });
+}
+
+export async function DELETE(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const repository = await ownedRepository(id, auth.user.id);
+  if (!repository) return jsonError("Repository nicht gefunden", 404);
+
+  await prisma.repository.update({
+    where: { id: repository.id },
+    data: { webhookSecret: null, webhookLastAt: null },
+  });
+
+  return NextResponse.json({ ok: true });
+}

src/app/api/search/route.ts

@@ -12,16 +12,30 @@ interface Hit {
   snippet: string;
 }
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  /** Ausschnitt aus der Beschreibung; leer, wenn nur der Titel passte. */
+  snippet: string;
+}
+
 /**
- * Volltextsuche ueber Notizen.
+ * Volltextsuche ueber Notizen und Aufgaben.
  *
  * Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt
- * Name, Kurzbeschreibung und Tags ab. Notizen liegen dort nicht vor – die
- * mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser Endpunkt:
- * Postgres sucht mit seiner deutschen Textsuche direkt in der Datenbank.
+ * Name, Kurzbeschreibung und Tags ab. Notizen und Aufgaben liegen dort nicht
+ * vor – die mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser
+ * Endpunkt: Postgres sucht mit seiner deutschen Textsuche direkt in der
+ * Datenbank.
  *
  * ts_headline liefert gleich den passenden Ausschnitt mit; die Hervorhebung
  * kommt als [[…]] zurueck, damit die Oberflaeche kein HTML einbetten muss.
+ *
+ * Das Feld heisst weiterhin "hits" und meint die Notizen – umbenennen haette
+ * nur Aufrufer gebrochen, ohne etwas zu verbessern. Aufgaben kommen als
+ * eigenes Feld dazu.
  */
 export async function GET(request: Request) {
   const auth = await requireUserApi();
@@ -29,7 +43,7 @@ export async function GET(request: Request) {
 
   const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
   if (query.length < 2) {
-    return NextResponse.json({ query, hits: [], projectIds: [] });
+    return NextResponse.json({ query, hits: [], tasks: [], projectIds: [] });
   }
 
   // websearch_to_tsquery versteht Eingaben wie "docker -compose" oder
@@ -57,11 +71,48 @@ export async function GET(request: Request) {
     LIMIT 50
   `;
 
+  /**
+   * Dieselbe Rechnung fuer Aufgaben.
+   *
+   * Der Ausdruck in to_tsvector muss Zeichen fuer Zeichen dem in der
+   * Migration entsprechen (Task_fulltext_idx), sonst greift der Index nicht
+   * und Postgres rechnet ihn je Zeile neu.
+   *
+   * Erledigtes bleibt drin: wer sucht, sucht oft gerade das, was er letzte
+   * Woche abgehakt hat.
+   */
+  const tasks = await prisma.$queryRaw<TaskHit[]>`
+    SELECT
+      t."projectId" AS "projectId",
+      t."id"        AS "taskId",
+      t."title"     AS "title",
+      t."status"::text AS "status",
+      ts_headline(
+        'german',
+        coalesce(t."description", ''),
+        websearch_to_tsquery('german', ${query}),
+        'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
+      ) AS "snippet"
+    FROM "Task" t
+    JOIN "Project" p ON p."id" = t."projectId"
+    WHERE p."ownerId" = ${auth.user.id}
+      AND to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", ''))
+          @@ websearch_to_tsquery('german', ${query})
+    ORDER BY ts_rank(
+      to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", '')),
+      websearch_to_tsquery('german', ${query})
+    ) DESC
+    LIMIT 50
+  `;
+
   return NextResponse.json({
     query,
     hits,
+    tasks,
     // Die Oberflaeche braucht vor allem die betroffenen Projekte, um sie im
-    // Board einzublenden.
-    projectIds: Array.from(new Set(hits.map((hit) => hit.projectId))),
+    // Board einzublenden – jetzt aus beiden Quellen.
+    projectIds: Array.from(
+      new Set([...hits.map((hit) => hit.projectId), ...tasks.map((hit) => hit.projectId)]),
+    ),
   });
 }

src/app/api/tasks/[id]/issue/route.ts

@@ -0,0 +1,141 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { recordActivity, shorten } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { APP_URL } from "@/lib/config";
+import { prisma } from "@/lib/db";
+import { GitApiError, clientForConnection } from "@/lib/git";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { formatZodError } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+const schema = z.object({
+  /** Aus welchem Repository. Leer heisst: dem fuehrenden. */
+  repositoryId: z.string().optional(),
+});
+
+/**
+ * Legt zu einer Aufgabe ein Issue im verknuepften Repository an.
+ *
+ * Der einzige Weg, auf dem Nebula von sich aus etwas in ein fremdes System
+ * schreibt – deshalb ausdruecklich angestossen und nie nebenbei. Umgekehrt
+ * gibt es die Uebernahme von Issues als Aufgaben schon laenger
+ * (tasks/from-issues); die Felder sourceIssue, sourceUrl und
+ * sourceRepositoryId sind dieselben, und die Eindeutigkeit je Repository
+ * verhindert, dass beide Wege dasselbe doppelt anlegen.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+
+  // Besitz haengt am Projekt – die Aufgabe selbst kennt keinen Besitzer.
+  const task = await prisma.task.findFirst({
+    where: { id, project: { ownerId: auth.user.id } },
+    select: {
+      id: true,
+      title: true,
+      description: true,
+      projectId: true,
+      sourceIssue: true,
+      sourceUrl: true,
+      project: { select: { name: true } },
+    },
+  });
+  if (!task) return jsonError("Aufgabe nicht gefunden", 404);
+
+  // Schon verknuepft: nicht noch einmal anlegen. Ein zweites Issue zur
+  // selben Aufgabe waere genau die Dublette, die from-issues vermeidet.
+  if (task.sourceIssue !== null) {
+    return NextResponse.json(
+      {
+        error: "Diese Aufgabe haengt bereits an einem Issue.",
+        issue: { number: task.sourceIssue, url: task.sourceUrl },
+      },
+      { status: 409 },
+    );
+  }
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = schema.safeParse(body.data ?? {});
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  // Die Besitzerbedingung laeuft ueber das Projekt, dessen Besitz eben
+  // geprueft wurde – eine fremde Repository-ID trifft hier also nichts.
+  const repository = await prisma.repository.findFirst({
+    where: {
+      projectId: task.projectId,
+      ...(parsed.data.repositoryId ? { id: parsed.data.repositoryId } : {}),
+    },
+    orderBy: [{ position: "asc" }, { createdAt: "asc" }],
+    include: { connection: true },
+  });
+
+  if (!repository) {
+    return jsonError("Das Projekt hat kein verknuepftes Repository.", 422);
+  }
+  if (!repository.connection) {
+    return jsonError(
+      "Das Repository haengt an keiner Git-Verbindung – ohne Token laesst sich nichts anlegen.",
+      422,
+    );
+  }
+  if (!repository.repoOwner || !repository.repoName) {
+    return jsonError("Am Repository fehlen Owner oder Name.", 422);
+  }
+
+  const client = clientForConnection(repository.connection);
+
+  // Rueckverweis in den Rumpf: wer das Issue im Git-System liest, soll
+  // wissen, wo es herkommt und wo der Rest der Notizen liegt.
+  const rumpf = [
+    task.description?.trim() || null,
+    `_Angelegt aus [${task.project.name}](${APP_URL}/projects/${task.projectId}) in Nebula._`,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  try {
+    const issue = await client.createIssue(
+      { owner: repository.repoOwner, name: repository.repoName },
+      { title: task.title, body: rumpf },
+    );
+
+    const aktualisiert = await prisma.task.update({
+      where: { id: task.id },
+      data: {
+        sourceIssue: issue.number,
+        sourceUrl: issue.url,
+        sourceRepositoryId: repository.id,
+      },
+    });
+
+    await recordActivity({
+      projectId: task.projectId,
+      userId: auth.user.id,
+      kind: "TASK_ADDED",
+      summary: `Issue #${issue.number} angelegt zu: ${shorten(task.title, 50)}`,
+      meta: { taskId: task.id, issue: issue.number, url: issue.url },
+    });
+
+    return NextResponse.json({ task: aktualisiert, issue }, { status: 201 });
+  } catch (error) {
+    // Der Aufruf ging nach draussen; die Meldung des Git-Systems ist
+    // hilfreicher als ein pauschales "hat nicht geklappt".
+    if (error instanceof GitApiError) {
+      return jsonError(`Issue konnte nicht angelegt werden: ${error.message}`, 502);
+    }
+    return jsonError("Issue konnte nicht angelegt werden.", 502);
+  }
+}

src/app/api/tasks/[id]/route.ts

@@ -10,6 +10,7 @@ import {
   refreshDerivedProgress,
   spawnRecurrence,
 } from "@/lib/tasks";
+import { issueShouldBeOpen, mirrorStatusToIssue } from "@/lib/tasks/issues";
 import { formatZodError, taskUpdateSchema } from "@/lib/validation";
 
 export const dynamic = "force-dynamic";
@@ -74,6 +75,23 @@ export async function PATCH(request: Request, { params }: Params) {
 
   await refreshDerivedProgress(existing.projectId);
 
+  /**
+   * Haengt die Aufgabe an einem Issue, wandert der Zustand mit: erledigt
+   * schliesst es, ein Zurueckziehen oeffnet es wieder. Nur die Grenze um
+   * ERLEDIGT geht nach draussen – mehr kennt ein Issue nicht.
+   *
+   * Fehlertolerant und ohne den Aufrufer warten zu lassen, was schiefgehen
+   * kann: ein nicht erreichbares Git-System darf das Abhaken nicht
+   * verhindern. Beim naechsten Wechsel wird es erneut versucht.
+   */
+  if (update.status !== undefined) {
+    const vorher = issueShouldBeOpen(existing.status);
+    const nachher = issueShouldBeOpen(update.status as TaskStatus);
+    if (vorher !== nachher) {
+      await mirrorStatusToIssue(id, update.status as TaskStatus);
+    }
+  }
+
   // Nur der Spaltenwechsel kommt in den Verlauf. Ein umbenannter Titel oder
   // ein neues Label sind zu kleinteilig, um die Geschichte des Projekts zu
   // erzaehlen – und beim Ziehen im Brett ist der Wechsel die eigentliche Tat.

src/app/api/webhooks/[repositoryId]/route.ts

@@ -0,0 +1,142 @@
+import { NextResponse } from "next/server";
+import { tryDecryptSecret } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+import { rateLimit } from "@/lib/security/rateLimit";
+import { syncRepository } from "@/lib/sync";
+import { completeTaskFromIssue, statusForIssueState } from "@/lib/tasks/issues";
+import { refreshDerivedProgress } from "@/lib/tasks";
+import { parseEvent, verifySignature } from "@/lib/webhooks/verify";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ repositoryId: string }> };
+
+/** Groesse des Rumpfes deckeln – ein Push-Ereignis ist nie ein Megabyte. */
+const MAX_BODY = 512 * 1024;
+
+/**
+ * Eingehende Webhooks von GitHub, GitLab und Gitea.
+ *
+ * Der einzige Endpunkt ohne Anmeldung, der etwas schreibt. Ausgewiesen wird
+ * sich mit einer Signatur ueber den Rumpf, geprueft gegen das Geheimnis, das
+ * beim Einrichten am Repository hinterlegt wurde.
+ *
+ * Absichtlich sparsam in dem, was er tut:
+ *
+ *   push    – stoesst denselben Abgleich an wie der Zeitgeber
+ *   issues  – geschlossen oder wieder geoeffnet wandert an die Aufgabe
+ *
+ * Alles andere wird angenommen und liegen gelassen. Ein Webhook, der mit
+ * einem Fehler antwortet, wird von den Systemen wiederholt und irgendwann
+ * abgeschaltet – deshalb ist "verstanden, nichts zu tun" die richtige
+ * Antwort auf ein unbekanntes Ereignis.
+ *
+ * Was hier NICHT passiert: der Rumpf wird nie als Quelle fuer Inhalte
+ * benutzt. Titel, Beschreibung und Zustand einer Aufgabe kommen weiter aus
+ * Nebula beziehungsweise beim naechsten Abgleich aus der API. Wer das
+ * Geheimnis kennt, kann also hoechstens eine Aufgabe auf- oder zumachen und
+ * einen Abgleich ausloesen – nicht beliebige Daten einschleusen.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const { repositoryId } = await params;
+
+  // Die ID steht in der URL und ist damit halboeffentlich. Ein Deckel
+  // dagegen, sie als Orakel zu benutzen oder den Abgleich zu verheizen.
+  const limit = rateLimit(`webhook:${repositoryId}`, 60, 60_000);
+  if (!limit.ok) {
+    return NextResponse.json(
+      { error: "Zu viele Aufrufe." },
+      { status: 429, headers: { "Retry-After": String(limit.retryAfter) } },
+    );
+  }
+
+  const repository = await prisma.repository.findUnique({
+    where: { id: repositoryId },
+    include: { connection: true },
+  });
+
+  // Unbekanntes Repository und fehlendes Geheimnis sind dieselbe Antwort:
+  // ob es die ID gibt, geht den Anrufer nichts an.
+  const secret = repository?.webhookSecret
+    ? tryDecryptSecret(repository.webhookSecret)
+    : null;
+  if (!repository || !secret) {
+    return NextResponse.json({ error: "Unbekannt." }, { status: 404 });
+  }
+
+  const roh = await request.text();
+  if (roh.length > MAX_BODY) {
+    return NextResponse.json({ error: "Rumpf zu gross." }, { status: 413 });
+  }
+
+  /**
+   * Der **rohe** Rumpf geht in die Pruefung, nicht das geparste Objekt:
+   * durch JSON.parse und JSON.stringify gedreht kaeme eine andere Zeichen-
+   * folge heraus und die Signatur passte nie.
+   */
+  const provider = repository.connection?.provider ?? "GITEA";
+  const geprueft = verifySignature(provider, secret, roh, request.headers);
+  if (!geprueft.ok) {
+    return NextResponse.json({ error: "Signatur ungueltig." }, { status: 401 });
+  }
+
+  let payload: unknown = null;
+  try {
+    payload = JSON.parse(roh);
+  } catch {
+    return NextResponse.json({ error: "Kein gueltiges JSON." }, { status: 400 });
+  }
+
+  const eventName =
+    request.headers.get("x-github-event") ??
+    request.headers.get("x-gitea-event") ??
+    request.headers.get("x-gitlab-event");
+
+  const ereignis = parseEvent(provider, eventName, payload);
+
+  // Ab hier gilt der Aufruf als echt – das ist die Rueckmeldung darueber,
+  // ob der Haken im Git-System ueberhaupt funktioniert.
+  await prisma.repository.update({
+    where: { id: repository.id },
+    data: { webhookLastAt: new Date() },
+  });
+
+  if (ereignis.kind === "push") {
+    // Derselbe Weg wie beim Zeitgeber – nur eben sofort statt beim
+    // naechsten Durchlauf.
+    await syncRepository(repository.id).catch(() => undefined);
+    return NextResponse.json({ ok: true, handled: "push" });
+  }
+
+  if (ereignis.kind === "issue") {
+    const task = await prisma.task.findFirst({
+      where: { sourceRepositoryId: repository.id, sourceIssue: ereignis.number },
+      select: { id: true, status: true, projectId: true },
+    });
+    if (!task) {
+      return NextResponse.json({ ok: true, handled: "issue", matched: false });
+    }
+
+    const ziel = statusForIssueState(ereignis.open, task.status);
+
+    if (ziel === "DONE" && task.status !== "DONE") {
+      // Ueber die gemeinsame Funktion, damit ein geschlossenes Issue
+      // dasselbe bewirkt wie ein Haken in der Oberflaeche: naechste Fassung
+      // einer wiederkehrenden Aufgabe und ein Eintrag im Verlauf.
+      await completeTaskFromIssue(task.id, "webhook");
+    } else if (ziel !== task.status) {
+      // Wieder geoeffnet. Das darf nur der Webhook, weil hier ein echtes
+      // "reopened" vorliegt – der Abgleich sieht nur Zustaende und wuerde
+      // sonst eine bewusst erledigte Aufgabe aufmachen.
+      await prisma.task.update({
+        where: { id: task.id },
+        data: { status: ziel, doneAt: null },
+      });
+      await refreshDerivedProgress(task.projectId);
+    }
+
+    return NextResponse.json({ ok: true, handled: "issue", matched: true, status: ziel });
+  }
+
+  return NextResponse.json({ ok: true, handled: "ignored", event: ereignis.name });
+}

src/app/components.css

@@ -277,6 +277,21 @@
     border: 1px solid transparent;
   }
 
+  /**
+   * Auf Zeigergeraeten reichen die 36px, die sich aus Schriftgroesse und
+   * Innenabstand ergeben. Ein Finger trifft das nicht zuverlaessig – dort
+   * gilt die uebliche Untergrenze von 44px.
+   *
+   * Ueber "pointer: coarse" statt einer Breitenabfrage: entscheidend ist das
+   * Eingabegeraet, nicht die Fenstergroesse. Ein Tablet im Querformat ist
+   * breit und wird trotzdem mit dem Finger bedient.
+   */
+  @media (pointer: coarse) {
+    .btn {
+      min-height: 2.75rem;
+    }
+  }
+
   .btn:disabled {
     opacity: 0.5;
     cursor: not-allowed;
@@ -335,6 +350,19 @@
       box-shadow 0.2s ease;
   }
 
+  /**
+   * Unter 16px zoomt iOS Safari beim Hineintippen die ganze Seite heran und
+   * kehrt danach nicht von selbst zurueck – aus einem Formular wird so eine
+   * Schiebepartie. Deshalb auf Beruehrungsgeraeten volle 16px, unabhaengig
+   * von der Fensterbreite.
+   */
+  @media (pointer: coarse) {
+    .field {
+      font-size: 1rem;
+      padding: 0.65rem 0.85rem;
+    }
+  }
+
   .field::placeholder {
     color: rgba(148, 163, 184, 0.6);
   }
@@ -416,4 +444,22 @@
   .range::-moz-range-track {
     background: transparent;
   }
+
+  /* Ein 16px-Griff ist mit dem Finger kaum zu fassen. Die Spur bleibt
+     schmal, damit der Regler nicht ploetzlich klobig wirkt. */
+  @media (pointer: coarse) {
+    .range {
+      height: 10px;
+    }
+
+    .range::-webkit-slider-thumb {
+      height: 24px;
+      width: 24px;
+    }
+
+    .range::-moz-range-thumb {
+      height: 22px;
+      width: 22px;
+    }
+  }
 }

src/app/globals.css

@@ -38,6 +38,13 @@
     Consolas, "DejaVu Sans Mono", monospace;
 
   --radius-card: 1.25rem;
+
+  /* Eine Stufe unterhalb von Tailwinds "sm" (40rem). Zwischen 320px und
+     640px liegt der gesamte Telefonbereich, und dort ist der Unterschied
+     zwischen "Beschriftung passt noch" und "passt nicht mehr" oft nur ein
+     Zentimeter breit. 22rem trennt die wirklich schmalen Geraete (iPhone SE
+     der ersten Reihe, 320px) vom Rest, der bei 360px und mehr anfaengt. */
+  --breakpoint-xs: 22rem;
 }
 
 :root {
@@ -63,7 +70,14 @@
     font-family: var(--font-sans);
     -webkit-font-smoothing: antialiased;
     text-rendering: optimizeLegibility;
+    /* Ein Notnagel gegen seitliches Scrollen, kein Ersatz fuer richtiges
+       Umbrechen: was hier abgeschnitten wird, ist auf dem Telefon einfach
+       nicht mehr erreichbar. Die Ursachen gehoeren in die Komponenten. */
     overflow-x: hidden;
+    /* Mit viewportFit: "cover" reicht die Seite bis in die Ecken; ohne diese
+       Einrueckung stuende der Inhalt im Querformat unter der Kameraleiste. */
+    padding-left: env(safe-area-inset-left);
+    padding-right: env(safe-area-inset-right);
   }
 
   ::selection {

src/app/layout.tsx

@@ -42,6 +42,11 @@ export const viewport: Viewport = {
   themeColor: "#05060f",
   width: "device-width",
   initialScale: 1,
+  // Die Seite reicht bis unter Statusleiste und Home-Anzeige; das ist noetig,
+  // damit der Hintergrund im installierten Betrieb nicht an einem weissen
+  // Balken endet. Was dadurch verdeckt wuerde, holen die env(safe-area-*)
+  // in globals.css wieder heraus.
+  viewportFit: "cover",
 };
 
 export default async function RootLayout({

src/app/page.tsx

@@ -1,4 +1,5 @@
-import { CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
+import Link from "next/link";
+import { CalendarRange, CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
 import { ProjectBoard } from "@/components/ProjectBoard";
 import { StatCard } from "@/components/StatCard";
 import { requireUserPage } from "@/lib/auth/guard";
@@ -50,15 +51,28 @@ export default async function DashboardPage() {
           Ideen festhalten, Status pflegen, Notizen sammeln – und live sehen, was in den
           verknuepften Repositories bei GitHub, GitLab und Gitea passiert.
         </p>
+        {/* Kein weiterer Punkt in der Kopfleiste – die ist auf dem Telefon
+            schon eng. Der Rueckblick haengt dort, wo man ohnehin hinsieht. */}
+        <Link
+          href="/rueckblick"
+          className="mt-3 inline-flex items-center gap-1.5 text-sm text-violet-300 underline-offset-2 hover:underline"
+        >
+          <CalendarRange className="h-4 w-4" />
+          Wochenrückblick ansehen
+        </Link>
       </header>
 
-      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-5">
+      {/* Zwei Spalten schon auf dem Telefon: einspaltig fuellten die fuenf
+          Kacheln dort den ganzen ersten Bildschirm, und die Projekte – der
+          eigentliche Inhalt – begannen erst nach dem zweiten Wischen. */}
+      <div className="grid grid-cols-2 gap-3 sm:gap-4 lg:grid-cols-5">
         <StatCard
           label="Projekte"
           value={active.length}
           hint={`Ø Fortschritt ${averageProgress}%`}
           icon={CircleDot}
           color="#a78bfa"
+          className="col-span-2 lg:col-span-1"
         />
         <StatCard
           label="Ideen"

src/app/projects/[id]/page.tsx

@@ -11,7 +11,7 @@ import { TaskBoard } from "@/components/tasks/TaskBoard";
 import { requireUserPage } from "@/lib/auth/guard";
 import { getSessionUser } from "@/lib/auth/session";
 import { prisma } from "@/lib/db";
-import { connectionSafeSelect, projectDetailInclude } from "@/lib/projects";
+import { connectionSafeSelect, projectDetailInclude, webhookRepositoryIds } from "@/lib/projects";
 import type { ConnectionSafe, ProjectDetail } from "@/types";
 
 export const dynamic = "force-dynamic";
@@ -55,6 +55,9 @@ export default async function ProjectPage({ params }: PageProps) {
 
   const detail = project as unknown as ProjectDetail;
 
+  // Nur die Angabe "hier haengt ein Webhook", nicht das Geheimnis selbst.
+  const webhookIds = await webhookRepositoryIds(detail.id);
+
   const fuehrend = detail.repositories[0]?.snapshot;
   const readme = fuehrend?.readme
     ? {
@@ -82,8 +85,16 @@ export default async function ProjectPage({ params }: PageProps) {
         progressFromTasks={detail.progressFromTasks}
       />
 
+      {/*
+        min-w-0 an beiden Spalten ist hier nicht Kosmetik, sondern der Kern:
+        ein Rasterkind hat "min-width: auto" und weigert sich damit, unter
+        die Inhaltsbreite seines breitesten Kindes zu schrumpfen. Die
+        Heatmap ist ueber 700px breit – auf dem Telefon zog sie damit die
+        ganze Spalte und mit ihr die Seite auseinander. Erst mit min-w-0
+        greift das overflow-x-auto darin ueberhaupt.
+      */}
       <div className="grid gap-6 lg:grid-cols-12">
-        <div className="space-y-6 lg:col-span-5">
+        <div className="min-w-0 space-y-6 lg:col-span-5">
           <section className="glass p-5">
             <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-300">
               <FileText className="h-4 w-4 text-cyan-300" />
@@ -112,10 +123,11 @@ export default async function ProjectPage({ params }: PageProps) {
           <NotesPanel projectId={detail.id} notes={detail.notes} />
         </div>
 
-        <div className="space-y-6 lg:col-span-7">
+        <div className="min-w-0 space-y-6 lg:col-span-7">
           <GitPanel
             project={detail}
             connections={connections as unknown as ConnectionSafe[]}
+            webhookRepoIds={webhookIds}
           />
           <ActivityFeed projectId={detail.id} initial={detail.activities} />
         </div>

src/app/rueckblick/page.tsx

@@ -0,0 +1,139 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { ArrowLeft, ArrowRight, CalendarRange, History } from "lucide-react";
+import { WeeklyReview } from "@/components/WeeklyReview";
+import { requireUserPage } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { tagesschluessel, wocheUm, wochenName, wochenTitel, zaehleWoche } from "@/lib/review";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = { title: "Wochenrückblick" };
+
+/** Wie weit sich zurueckblaettern laesst – der Verlauf haelt ohnehin nur 200 je Projekt. */
+const MAX_RUECKBLICK = 25;
+
+export default async function ReviewPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ woche?: string }>;
+}) {
+  const user = await requireUserPage();
+  const params = await searchParams;
+
+  // Nur nach hinten blaettern: die Zukunft ist im Rueckblick leer.
+  const gewuenscht = Number(params.woche ?? 0);
+  const versatz = Number.isFinite(gewuenscht)
+    ? Math.min(0, Math.max(-MAX_RUECKBLICK, Math.trunc(gewuenscht)))
+    : 0;
+
+  const woche = wocheUm(new Date(), versatz);
+
+  /**
+   * Der Verlauf kennt keinen Besitzer – die Trennung laeuft ueber das
+   * Projekt. Die Bedingung steht deshalb als erste in der where-Klausel.
+   */
+  const activities = await prisma.activity.findMany({
+    where: {
+      project: { ownerId: user.id },
+      createdAt: { gte: woche.von, lt: woche.bis },
+    },
+    include: {
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+    // meta kommt mit, weil die Kennzahlen daran ablesen, was erledigt
+    // wurde – verlaesslicher als der Anzeigetext.
+    orderBy: { createdAt: "desc" },
+    // Deckel gegen eine Woche, in der ein Abgleich Amok gelaufen ist.
+    take: 500,
+  });
+
+  /**
+   * Nach Kalendertagen buendeln – auf dem Server, damit Server-Render und
+   * Hydration nicht auseinanderlaufen. "Welcher Tag" haengt an der Zeitzone.
+   */
+  const nachTag = new Map<string, ReviewEntry[]>();
+  for (const eintrag of activities) {
+    const schluessel = tagesschluessel(eintrag.createdAt);
+    const liste = nachTag.get(schluessel) ?? [];
+    liste.push({
+      id: eintrag.id,
+      kind: eintrag.kind,
+      summary: eintrag.summary,
+      createdAt: eintrag.createdAt.toISOString(),
+      project: eintrag.project,
+      user: eintrag.user,
+    });
+    nachTag.set(schluessel, liste);
+  }
+
+  // Neuester Tag zuerst, und nur Tage, an denen etwas war.
+  const tage: ReviewDay[] = [...woche.tage]
+    .reverse()
+    .map((tag) => ({ tag, eintraege: nachTag.get(tag) ?? [] }))
+    .filter((eintrag) => eintrag.eintraege.length > 0);
+
+  const kennzahlen = zaehleWoche(activities);
+
+  return (
+    <div className="space-y-5">
+      <header className="fade-up pt-4">
+        <p className="text-[11px] font-semibold uppercase tracking-[0.3em] text-violet-300/70">
+          Über alle Projekte
+        </p>
+        <div className="mt-2 flex flex-wrap items-end justify-between gap-3">
+          <div>
+            <h1 className="text-2xl font-semibold tracking-tight text-white sm:text-3xl">
+              {wochenName(woche)}
+            </h1>
+            <p className="mt-1 flex items-center gap-1.5 text-sm text-slate-400">
+              <CalendarRange className="h-3.5 w-3.5" />
+              {wochenTitel(woche)}
+            </p>
+          </div>
+
+          <nav className="flex items-center gap-2" aria-label="Woche wählen">
+            <Link
+              href={`/rueckblick?woche=${versatz - 1}`}
+              className="btn btn-ghost px-2.5 py-1.5 text-xs"
+              aria-label="Eine Woche zurück"
+              // Am Ende des Zeitraums bleibt der Verweis stehen, wird aber
+              // wirkungslos – die Seite klemmt den Wert ohnehin.
+              aria-disabled={versatz <= -MAX_RUECKBLICK}
+            >
+              <ArrowLeft className="h-3.5 w-3.5" />
+              Früher
+            </Link>
+            {versatz < 0 ? (
+              <Link
+                href={`/rueckblick?woche=${versatz + 1}`}
+                className="btn btn-ghost px-2.5 py-1.5 text-xs"
+                aria-label="Eine Woche vor"
+              >
+                Später
+                <ArrowRight className="h-3.5 w-3.5" />
+              </Link>
+            ) : null}
+            {versatz !== 0 ? (
+              <Link href="/rueckblick" className="btn btn-ghost px-2.5 py-1.5 text-xs">
+                Diese Woche
+              </Link>
+            ) : null}
+            <Link href="/verlauf" className="btn btn-ghost px-2.5 py-1.5 text-xs">
+              <History className="h-3.5 w-3.5" />
+              Ganzer Verlauf
+            </Link>
+          </nav>
+        </div>
+      </header>
+
+      <WeeklyReview
+        tage={tage}
+        kennzahlen={kennzahlen}
+        istDieseWoche={versatz === 0}
+      />
+    </div>
+  );
+}

src/app/tasks/page.tsx

@@ -0,0 +1,52 @@
+import type { Metadata } from "next";
+import { TaskOverview } from "@/components/tasks/TaskOverview";
+import { requireUserPage } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { dueBucket } from "@/lib/tasks";
+import type { TaskOverviewItem } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = { title: "Aufgaben" };
+
+export default async function TasksPage() {
+  const user = await requireUserPage();
+
+  /**
+   * Die Aufgabe kennt keinen Besitzer – die Trennung laeuft ueber das
+   * Projekt. Die Bedingung steht deshalb als einzige und erste in der
+   * where-Klausel; eine fremde Aufgabe kann hier gar nicht auftauchen.
+   */
+  const tasks = await prisma.task.findMany({
+    where: { project: { ownerId: user.id } },
+    include: {
+      project: { select: { id: true, name: true, accent: true, status: true } },
+    },
+    // NULL-Termine sortiert Postgres bei ASC ans Ende – genau richtig,
+    // Aufgaben ohne Termin gehoeren nicht nach oben.
+    orderBy: [{ dueDate: "asc" }, { position: "asc" }],
+  });
+
+  /**
+   * Das Fach wird auf dem Server bestimmt, nicht im Browser. "Heute" haengt
+   * an der Uhr, und zwei verschiedene Antworten zwischen Server-Render und
+   * Hydration waeren genau der Fehler, den die feste Zeitzone in lib/utils
+   * sonst vermeidet.
+   */
+  const jetzt = new Date();
+  const items: TaskOverviewItem[] = tasks.map((task) => ({
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    dueDate: task.dueDate ? task.dueDate.toISOString() : null,
+    labels: task.labels,
+    recurrence: task.recurrence,
+    sourceIssue: task.sourceIssue,
+    sourceUrl: task.sourceUrl,
+    bucket: dueBucket(task.dueDate, jetzt),
+    project: task.project,
+  }));
+
+  return <TaskOverview tasks={items} />;
+}

src/app/verlauf/page.tsx

@@ -0,0 +1,77 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { CalendarRange, History } from "lucide-react";
+import { Timeline } from "@/components/Timeline";
+import { requireUserPage } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { SEITE, SEITEN_ORDNUNG, seitenBedingung } from "@/lib/timeline";
+import type { ReviewEntry } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = { title: "Verlauf" };
+
+/**
+ * Der Verlauf ueber alle Projekte, fortlaufend.
+ *
+ * Die erste Seite kommt serverseitig mit, damit sofort etwas dasteht; alles
+ * Weitere holt der Knopf per Cursor nach. Anders als der Wochenrueckblick
+ * hat diese Seite keine Grenze und kein Fazit – sie laeuft zurueck, solange
+ * es Eintraege gibt.
+ */
+export default async function TimelinePage() {
+  const user = await requireUserPage();
+
+  const gefunden = await prisma.activity.findMany({
+    where: seitenBedingung(user.id, null),
+    orderBy: SEITEN_ORDNUNG,
+    // Einen mehr, um zu wissen, ob es weitergeht.
+    take: SEITE + 1,
+    select: {
+      id: true,
+      kind: true,
+      summary: true,
+      createdAt: true,
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+  });
+
+  const weitere = gefunden.length > SEITE;
+  const erste: ReviewEntry[] = (weitere ? gefunden.slice(0, SEITE) : gefunden).map((eintrag) => ({
+    id: eintrag.id,
+    kind: eintrag.kind,
+    summary: eintrag.summary,
+    createdAt: eintrag.createdAt.toISOString(),
+    project: eintrag.project,
+    user: eintrag.user,
+  }));
+
+  return (
+    <div className="space-y-5">
+      <header className="fade-up pt-4">
+        <p className="text-[11px] font-semibold uppercase tracking-[0.3em] text-violet-300/70">
+          Über alle Projekte
+        </p>
+        <div className="mt-2 flex flex-wrap items-end justify-between gap-3">
+          <div>
+            <h1 className="flex items-center gap-2 text-2xl font-semibold tracking-tight text-white sm:text-3xl">
+              <History className="h-6 w-6 text-violet-300" />
+              Verlauf
+            </h1>
+            <p className="mt-1 text-sm text-slate-400">
+              Alles, was passiert ist – vom Neuesten rückwärts.
+            </p>
+          </div>
+
+          <Link href="/rueckblick" className="btn btn-ghost px-3 py-1.5 text-xs">
+            <CalendarRange className="h-3.5 w-3.5" />
+            Wochenrückblick
+          </Link>
+        </div>
+      </header>
+
+      <Timeline erste={erste} weitere={weitere} />
+    </div>
+  );
+}

src/components/ActivityFeed.tsx

@@ -1,23 +1,9 @@
 "use client";
 
 import { useState } from "react";
-import {
-  AlertTriangle,
-  ArrowRight,
-  Bot,
-  Download,
-  GitCommitHorizontal,
-  History,
-  Link2,
-  Loader2,
-  NotebookPen,
-  Pencil,
-  Plus,
-  Signpost,
-  Sparkles,
-  Trash2,
-} from "lucide-react";
-import type { ActivityEntry, ActivityKind } from "@/types";
+import { Bot, History, Loader2 } from "lucide-react";
+import { ACTIVITY_KINDS } from "@/components/activityKinds";
+import type { ActivityEntry } from "@/types";
 import { formatDateTime, formatRelative } from "@/lib/utils";
 
 /**
@@ -29,21 +15,6 @@ import { formatDateTime, formatRelative } from "@/lib/utils";
  * obersten fuenf liest.
  */
 
-const KINDS: Record<ActivityKind, { icon: typeof Sparkles; color: string }> = {
-  PROJECT_CREATED: { icon: Sparkles, color: "text-violet-300" },
-  PROJECT_UPDATED: { icon: Pencil, color: "text-slate-400" },
-  STATUS_CHANGED: { icon: Signpost, color: "text-cyan-300" },
-  NOTE_ADDED: { icon: NotebookPen, color: "text-blue-300" },
-  NOTE_UPDATED: { icon: Pencil, color: "text-blue-300" },
-  NOTE_DELETED: { icon: Trash2, color: "text-rose-300" },
-  TASK_ADDED: { icon: Plus, color: "text-emerald-300" },
-  TASK_MOVED: { icon: ArrowRight, color: "text-violet-300" },
-  TASK_DELETED: { icon: Trash2, color: "text-rose-300" },
-  TASKS_IMPORTED: { icon: Download, color: "text-amber-300" },
-  REPO_LINKED: { icon: Link2, color: "text-cyan-300" },
-  REPO_COMMITS: { icon: GitCommitHorizontal, color: "text-emerald-300" },
-  SYNC_FAILED: { icon: AlertTriangle, color: "text-rose-300" },
-};
 
 export function ActivityFeed({
   projectId,
@@ -88,7 +59,7 @@ export function ActivityFeed({
       ) : (
         <ol className="mt-4 space-y-0">
           {entries.map((entry, index) => {
-            const meta = KINDS[entry.kind] ?? KINDS.PROJECT_UPDATED;
+            const meta = ACTIVITY_KINDS[entry.kind] ?? ACTIVITY_KINDS.PROJECT_UPDATED;
             const Icon = meta.icon;
             const letzter = index === entries.length - 1;
 

src/components/ActivityRow.tsx

@@ -0,0 +1,126 @@
+import Link from "next/link";
+import { ACTIVITY_KINDS } from "@/components/activityKinds";
+import { accentOf } from "@/lib/status";
+import { cn } from "@/lib/utils";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+/**
+ * Darstellung von Verlaufseintraegen – eine Zeile und die Gruppierung nach
+ * Kalendertagen.
+ *
+ * Bewusst ohne "use client" und ohne Hooks: so laesst sich beides sowohl aus
+ * einer Server-Komponente (Wochenrueckblick) als auch aus einer
+ * Client-Komponente (Zeitleiste mit Nachladen) heraus benutzen. Zwei Kopien
+ * derselben Zeile waeren beim naechsten Feinschliff auseinandergelaufen.
+ *
+ * Alle Formate mit fester Zeitzone – dieselbe Ueberlegung wie in lib/utils:
+ * sonst weichen Server-Render und Hydration voneinander ab.
+ */
+
+const WOCHENTAG = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  weekday: "long",
+});
+const TAG_MONAT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  day: "numeric",
+  month: "long",
+});
+const TAG_MONAT_JAHR = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  day: "numeric",
+  month: "long",
+  year: "numeric",
+});
+const UHRZEIT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  hour: "2-digit",
+  minute: "2-digit",
+});
+
+/** "2026-08-17" → ein Zeitpunkt mittags, damit die Zeitzone nichts verschiebt. */
+function alsDatum(tag: string): Date {
+  const [j, m, t] = tag.split("-").map(Number);
+  return new Date(Date.UTC(j, m - 1, t, 12));
+}
+
+export function ActivityDayGroups({
+  tage,
+  /** Bei Tagen aus anderen Jahren gehoert die Jahreszahl dazu. */
+  mitJahr = false,
+}: {
+  tage: ReviewDay[];
+  mitJahr?: boolean;
+}) {
+  const format = mitJahr ? TAG_MONAT_JAHR : TAG_MONAT;
+
+  return (
+    <div className="space-y-6">
+      {tage.map((tag) => {
+        const datum = alsDatum(tag.tag);
+        return (
+          <section key={tag.tag}>
+            <div className="mb-2.5 flex flex-wrap items-baseline gap-x-2.5 gap-y-1">
+              <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-300">
+                {WOCHENTAG.format(datum)}
+              </h2>
+              <span className="text-xs text-slate-500">{format.format(datum)}</span>
+              <span className="rounded-full bg-white/6 px-2 py-0.5 text-[11px] tabular-nums text-slate-400">
+                {tag.eintraege.length}
+              </span>
+              <span className="h-px flex-1 bg-gradient-to-r from-white/10 to-transparent" />
+            </div>
+
+            <ul className="glass divide-y divide-white/6 overflow-hidden">
+              {tag.eintraege.map((eintrag) => (
+                <ActivityRow key={eintrag.id} eintrag={eintrag} />
+              ))}
+            </ul>
+          </section>
+        );
+      })}
+    </div>
+  );
+}
+
+export function ActivityRow({ eintrag }: { eintrag: ReviewEntry }) {
+  const art = ACTIVITY_KINDS[eintrag.kind] ?? ACTIVITY_KINDS.PROJECT_UPDATED;
+  const Icon = art.icon;
+  const accent = accentOf(eintrag.project.accent);
+
+  return (
+    <li className="flex items-start gap-2.5 px-3 py-2.5 sm:gap-3 sm:px-4">
+      <span className={cn("mt-0.5 shrink-0", art.color)} title={art.label}>
+        <Icon className="h-4 w-4" />
+      </span>
+
+      <div className="min-w-0 flex-1">
+        <p className="text-sm leading-snug text-slate-200">{eintrag.summary}</p>
+        <div className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-[11px] text-slate-500">
+          {/* Das Projekt gehoert in jede Zeile – ohne es ist eine
+              projektuebergreifende Liste nicht zu lesen. */}
+          <Link
+            href={`/projects/${eintrag.project.id}`}
+            className="inline-flex max-w-[12rem] items-center gap-1.5 truncate text-slate-400 underline-offset-2 hover:text-violet-300 hover:underline"
+          >
+            <span
+              className="h-1.5 w-1.5 shrink-0 rounded-full"
+              style={{ backgroundColor: accent.from }}
+              aria-hidden="true"
+            />
+            {eintrag.project.name}
+          </Link>
+          <span className="tabular-nums">{UHRZEIT.format(new Date(eintrag.createdAt))} Uhr</span>
+          {eintrag.user ? (
+            <span className="hidden xs:inline">
+              {eintrag.user.displayName?.trim() || eintrag.user.username}
+            </span>
+          ) : (
+            // Ohne Benutzer: das war der Zeitgeber oder ein Webhook.
+            <span className="hidden text-slate-600 xs:inline">automatisch</span>
+          )}
+        </div>
+      </div>
+    </li>
+  );
+}

src/components/BulkBar.tsx

@@ -66,8 +66,13 @@ export function BulkBar({
   }
 
   return (
-    <div className="pointer-events-none fixed inset-x-0 bottom-4 z-[90] flex justify-center px-4">
-      <div className="popover pointer-events-auto flex flex-wrap items-center gap-2 px-3 py-2 shadow-2xl">
+    // Der Abstand nach unten beruecksichtigt die Home-Anzeige des iPhones;
+    // ohne das liegt die Leiste im installierten Betrieb darunter.
+    <div
+      className="pointer-events-none fixed inset-x-0 bottom-4 z-[90] flex justify-center px-3"
+      style={{ bottom: "calc(1rem + env(safe-area-inset-bottom))" }}
+    >
+      <div className="popover pointer-events-auto flex max-w-full flex-wrap items-center justify-center gap-2 px-3 py-2 shadow-2xl">
         <span className="px-1 text-sm tabular-nums text-slate-200">
           {ids.length} ausgewählt
         </span>
@@ -122,8 +127,17 @@ export function BulkBar({
           <Tag className="h-3.5 w-3.5" />
           Tags
         </button>
-        <Popover open={tagsOpen} anchorRef={tagsRef} onClose={() => setTagsOpen(false)} align="start">
-          <div className="w-64 space-y-2 p-3">
+        {/* Die Breite gehoert an den Popover, nicht an sein Kind: der Popover
+            setzt overflow-hidden, ein breiteres Kind wird schlicht
+            abgeschnitten – frueher um die Haelfte des Abbrechen-Knopfs. */}
+        <Popover
+          open={tagsOpen}
+          anchorRef={tagsRef}
+          onClose={() => setTagsOpen(false)}
+          align="start"
+          width={288}
+        >
+          <div className="space-y-2 p-3">
             <label className="field-label" htmlFor="bulk-tags">
               Tags (kommagetrennt)
             </label>

src/components/CommandPalette.tsx

@@ -5,8 +5,11 @@ import { createPortal } from "react-dom";
 import { useRouter } from "next/navigation";
 import {
   Bell,
+  CalendarRange,
+  CheckSquare,
   CornerDownLeft,
   GitBranch,
+  History,
   LayoutDashboard,
   Loader2,
   NotebookPen,
@@ -15,8 +18,9 @@ import {
   Settings,
   UserRound,
 } from "lucide-react";
-import type { ProjectStatus } from "@prisma/client";
+import type { ProjectStatus, TaskStatus } from "@prisma/client";
 import { statusOf } from "@/lib/status";
+import { TASK_STATUS_META } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 
 /**
@@ -37,6 +41,14 @@ interface ProjectHit {
   tags: string[];
 }
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  snippet: string;
+}
+
 interface NoteHit {
   projectId: string;
   noteId: string;
@@ -55,6 +67,27 @@ interface Action {
 
 const ACTIONS: Action[] = [
   { id: "dashboard", label: "Dashboard", hint: "Alle Projekte", icon: LayoutDashboard, href: "/" },
+  {
+    id: "rueckblick",
+    label: "Wochenrückblick",
+    hint: "Was diese Woche passiert ist",
+    icon: CalendarRange,
+    href: "/rueckblick",
+  },
+  {
+    id: "verlauf",
+    label: "Verlauf",
+    hint: "Alles, was passiert ist – über alle Projekte",
+    icon: History,
+    href: "/verlauf",
+  },
+  {
+    id: "tasks",
+    label: "Aufgaben",
+    hint: "Über alle Projekte, nach Fälligkeit",
+    icon: CheckSquare,
+    href: "/tasks",
+  },
   {
     id: "connections",
     label: "Git-Verbindungen",
@@ -83,7 +116,8 @@ const ACTIONS: Action[] = [
 type Entry =
   | { kind: "action"; key: string; action: Action }
   | { kind: "project"; key: string; project: ProjectHit }
-  | { kind: "note"; key: string; note: NoteHit; projectName: string };
+  | { kind: "note"; key: string; note: NoteHit; projectName: string }
+  | { kind: "task"; key: string; task: TaskHit; projectName: string };
 
 export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
   const router = useRouter();
@@ -92,6 +126,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
   const [query, setQuery] = useState("");
   const [projects, setProjects] = useState<ProjectHit[] | null>(null);
   const [notes, setNotes] = useState<NoteHit[]>([]);
+  const [aufgaben, setAufgaben] = useState<TaskHit[]>([]);
   const [active, setActive] = useState(0);
   const [loading, setLoading] = useState(false);
   const listRef = useRef<HTMLDivElement>(null);
@@ -130,6 +165,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     const needle = query.trim();
     if (needle.length < 2) {
       setNotes([]);
+      setAufgaben([]);
       return;
     }
     const controller = new AbortController();
@@ -139,8 +175,9 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
           signal: controller.signal,
         });
         if (!response.ok) return;
-        const body = (await response.json()) as { hits: NoteHit[] };
+        const body = (await response.json()) as { hits: NoteHit[]; tasks: TaskHit[] };
         setNotes(body.hits ?? []);
+        setAufgaben(body.tasks ?? []);
       } catch {
         // Abbruch beim Weitertippen ist der Normalfall.
       }
@@ -155,6 +192,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     if (!open) {
       setQuery("");
       setNotes([]);
+      setAufgaben([]);
       setActive(0);
     }
   }, [open]);
@@ -194,6 +232,17 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     for (const project of passendeProjekte.slice(0, 8)) {
       result.push({ kind: "project", key: `p-${project.id}`, project });
     }
+    // Aufgaben vor Notizen: wer tippt, sucht haeufiger etwas zu Tun als
+    // etwas Notiertes.
+    for (const treffer of aufgaben.slice(0, 5)) {
+      result.push({
+        kind: "task",
+        key: `t-${treffer.taskId}`,
+        task: treffer,
+        projectName:
+          (projects ?? []).find((project) => project.id === treffer.projectId)?.name ?? "Projekt",
+      });
+    }
     for (const hit of notes.slice(0, 5)) {
       result.push({
         kind: "note",
@@ -207,7 +256,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
       result.push({ kind: "action", key: `a-${action.id}`, action });
     }
     return result;
-  }, [query, projects, notes, isAdmin]);
+  }, [query, projects, notes, aufgaben, isAdmin]);
 
   useEffect(() => {
     setActive((current) => Math.min(current, Math.max(0, entries.length - 1)));
@@ -218,6 +267,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
       setOpen(false);
       if (entry.kind === "action") router.push(entry.action.href);
       else if (entry.kind === "project") router.push(`/projects/${entry.project.id}`);
+      else if (entry.kind === "task") router.push(`/projects/${entry.task.projectId}`);
       else router.push(`/projects/${entry.note.projectId}`);
     },
     [router],
@@ -268,7 +318,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
             value={query}
             onChange={(event) => setQuery(event.target.value)}
             onKeyDown={onInputKey}
-            placeholder="Projekt, Notiz oder Bereich…"
+            placeholder="Projekt, Aufgabe, Notiz oder Bereich…"
             className="w-full bg-transparent text-sm text-slate-100 outline-none placeholder:text-slate-600"
           />
           {loading ? <Loader2 className="h-3.5 w-3.5 animate-spin text-slate-600" /> : null}
@@ -322,6 +372,23 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
                       {statusOf(entry.project.status).short}
                     </span>
                   </>
+                ) : entry.kind === "task" ? (
+                  <>
+                    <CheckSquare className="mt-0.5 h-4 w-4 shrink-0 text-emerald-300/70" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.task.title}
+                        <span className="ml-1.5 text-[11px] text-slate-500">
+                          in {entry.projectName}
+                        </span>
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.task.snippet.replace(/\[\[|\]\]/g, "").trim() ||
+                          TASK_STATUS_META[entry.task.status as TaskStatus]?.label ||
+                          "Aufgabe"}
+                      </span>
+                    </span>
+                  </>
                 ) : (
                   <>
                     <NotebookPen className="mt-0.5 h-4 w-4 shrink-0 text-violet-300/70" />

src/components/GitPanel.tsx

@@ -17,6 +17,7 @@ import {
   Lock,
   Package,
   Plus,
+  Radio,
   RefreshCw,
   ShieldCheck,
   Star,
@@ -26,6 +27,7 @@ import {
 import { CiBadge } from "@/components/CiBadge";
 import { Heatmap } from "@/components/Heatmap";
 import { RepositoryDialog } from "@/components/RepositoryDialog";
+import { WebhookDialog } from "@/components/WebhookDialog";
 import { Sparkline } from "@/components/Sparkline";
 import { repoTitle } from "@/lib/git/meta";
 import { asArray, asCalendar, asRecord } from "@/types";
@@ -55,9 +57,13 @@ type TabKey = (typeof TABS)[number]["key"];
 export function GitPanel({
   project,
   connections,
+  webhookRepoIds = [],
 }: {
   project: ProjectDetail;
   connections: ConnectionSafe[];
+  /** Repositories mit hinterlegtem Webhook. Das Geheimnis selbst bleibt
+      auf dem Server – hier kommt nur an, ob eines existiert. */
+  webhookRepoIds?: string[];
 }) {
   const router = useRouter();
   const [tab, setTab] = useState<TabKey>("pulls");
@@ -65,6 +71,7 @@ export function GitPanel({
   const [importing, setImporting] = useState(false);
   const [message, setMessage] = useState<{ ok: boolean; text: string } | null>(null);
   const [addOpen, setAddOpen] = useState(false);
+  const [webhookOpen, setWebhookOpen] = useState(false);
 
   const repositories = project.repositories;
   const [selectedId, setSelectedId] = useState<string | null>(repositories[0]?.id ?? null);
@@ -72,6 +79,7 @@ export function GitPanel({
   // Nach dem Entfernen zeigt die Auswahl ins Leere – dann auf das fuehrende
   // zurueckfallen, statt eine leere Ansicht zu zeigen.
   const repository = repositories.find((entry) => entry.id === selectedId) ?? repositories[0] ?? null;
+  const webhookAktiv = repository ? webhookRepoIds.includes(repository.id) : false;
 
   /** Offene Issues als Aufgaben anlegen – ohne erneuten Abruf beim Provider. */
   async function importIssues() {
@@ -280,6 +288,24 @@ export function GitPanel({
               Repository
             </button>
           )}
+          <button
+            type="button"
+            onClick={() => setWebhookOpen(true)}
+            className={cn(
+              "rounded-lg p-2 transition-colors",
+              webhookAktiv
+                ? "text-emerald-300 hover:bg-emerald-500/10"
+                : "text-slate-500 hover:bg-white/8 hover:text-violet-300",
+            )}
+            aria-label="Webhook einrichten"
+            title={
+              webhookAktiv
+                ? "Webhook ist eingerichtet – meldet Aenderungen sofort"
+                : "Webhook einrichten – Aenderungen sofort statt beim naechsten Abgleich"
+            }
+          >
+            <Radio className="h-4 w-4" />
+          </button>
           <button
             type="button"
             onClick={() => removeRepository(repository)}
@@ -312,6 +338,16 @@ export function GitPanel({
         connections={connections}
       />
 
+      <WebhookDialog
+        open={webhookOpen}
+        onClose={() => setWebhookOpen(false)}
+        repositoryId={repository.id}
+        repositoryTitle={repoTitle(repository)}
+        provider={repository.connection?.provider ?? null}
+        eingerichtet={webhookAktiv}
+        zuletzt={repository.webhookLastAt}
+      />
+
       {message ? (
         <p
           className={cn(

src/components/Heatmap.tsx

@@ -114,12 +114,18 @@ export function Heatmap({ calendar }: { calendar: CommitCalendar }) {
         </p>
       </div>
 
-      <div className="overflow-x-auto">
+      <div className="-mx-1 overflow-x-auto px-1">
+        {/*
+          Kein max-w-full: zusammen mit der festen Hoehe staucht das die
+          Wochen auf schmalen Anzeigen zu einem unlesbaren Streifen, statt
+          den Elter seitlich scrollen zu lassen. Die Kalenderfelder haben
+          eine feste Groesse – die Karte gehoert geschoben, nicht gequetscht.
+        */}
         <svg
           viewBox={`0 0 ${breite + 22} ${hoehe}`}
           width={breite + 22}
           height={hoehe}
-          className="max-w-full"
+          className="block shrink-0"
           role="img"
           aria-label={`Commits je Tag seit ${formatDate(calendar.from)}: ${gesamt} an ${tageMitCommits} Tagen`}
         >

src/components/KanbanBoard.tsx

@@ -253,7 +253,11 @@ function Column({
       // Eindeutiger Anker fuer Tests und Automatisierung.
       data-column={status}
       className={cn(
-        "flex w-[17rem] shrink-0 flex-col rounded-2xl border border-white/6 bg-white/2 transition-colors",
+        // Schmaler auf dem Telefon: bei 17rem stand die zweite Spalte fast
+        // vollstaendig ausserhalb des Bildschirms, und ohne einen sichtbaren
+        // Rest der naechsten Spalte sieht man dem Brett nicht an, dass es
+        // seitlich weitergeht.
+        "flex w-[14rem] shrink-0 flex-col rounded-2xl border border-white/6 bg-white/2 transition-colors sm:w-[17rem]",
         isOver && "border-violet-400/40 bg-violet-500/6",
       )}
     >

src/components/ProjectBoard.tsx

@@ -3,10 +3,12 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
 import {
+  CheckSquare,
   Columns3,
   Database,
   Download,
   LayoutGrid,
+  List,
   ListFilter,
   NotebookPen,
   Plus,
@@ -15,17 +17,27 @@ import {
   Upload,
   X,
 } from "lucide-react";
-import type { ProjectStatus } from "@prisma/client";
+import type { ProjectStatus, TaskStatus } from "@prisma/client";
 import { BulkBar } from "@/components/BulkBar";
 import { ImportDialog } from "@/components/ImportDialog";
 import { KanbanBoard } from "@/components/KanbanBoard";
 import { ProjectCard } from "@/components/ProjectCard";
 import { ProjectDialog } from "@/components/ProjectDialog";
+import { ProjectList } from "@/components/ProjectList";
 import { Popover } from "@/components/ui/Popover";
 import { STATUS_META, STATUS_ORDER } from "@/lib/status";
+import { TASK_STATUS_META } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 import type { ConnectionSafe, ProjectListItem } from "@/types";
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  snippet: string;
+}
+
 interface NoteHit {
   projectId: string;
   noteId: string;
@@ -53,9 +65,17 @@ function highlight(snippet: string): React.ReactNode[] {
 }
 
 type SortKey = "updated" | "created" | "name" | "progress" | "priority";
-type ViewMode = "grid" | "grouped" | "kanban";
+type ViewMode = "grid" | "list" | "grouped" | "kanban";
 
-const VIEWS: ViewMode[] = ["grid", "grouped", "kanban"];
+const VIEWS: ViewMode[] = ["grid", "list", "grouped", "kanban"];
+
+/** Reihenfolge der Umschalter – zugleich die Beschriftung der Knoepfe. */
+const VIEW_META: Record<ViewMode, { label: string; title: string; icon: typeof LayoutGrid }> = {
+  grid: { label: "Raster", title: "Rasteransicht", icon: LayoutGrid },
+  list: { label: "Liste", title: "Kompakte Liste", icon: List },
+  grouped: { label: "Gruppiert", title: "Nach Status gruppiert", icon: Rows3 },
+  kanban: { label: "Brett", title: "Kanban – Status per Ziehen aendern", icon: Columns3 },
+};
 
 /** Wo Ansicht, Sortierung und Archivschalter im Browser liegen. */
 const ANSICHT_SCHLUESSEL = "nebula.board";
@@ -125,6 +145,7 @@ export function ProjectBoard({
   const [dataMenuOpen, setDataMenuOpen] = useState(false);
   const dataButtonRef = useRef<HTMLButtonElement>(null);
   const [noteHits, setNoteHits] = useState<NoteHit[]>([]);
+  const [taskHits, setTaskHits] = useState<TaskHit[]>([]);
   const [selection, setSelection] = useState<Set<string>>(new Set());
 
   /**
@@ -137,6 +158,7 @@ export function ProjectBoard({
     const needle = query.trim();
     if (needle.length < 2) {
       setNoteHits([]);
+      setTaskHits([]);
       return;
     }
 
@@ -147,8 +169,9 @@ export function ProjectBoard({
           signal: controller.signal,
         });
         if (!response.ok) return;
-        const body = (await response.json()) as { hits: NoteHit[] };
+        const body = (await response.json()) as { hits: NoteHit[]; tasks: TaskHit[] };
         setNoteHits(body.hits ?? []);
+        setTaskHits(body.tasks ?? []);
       } catch {
         // Abgebrochene Anfragen sind der Normalfall beim Tippen.
       }
@@ -161,8 +184,12 @@ export function ProjectBoard({
   }, [query]);
 
   const noteHitProjectIds = useMemo(
-    () => new Set(noteHits.map((hit) => hit.projectId)),
-    [noteHits],
+    () =>
+      new Set([
+        ...noteHits.map((hit) => hit.projectId),
+        ...taskHits.map((hit) => hit.projectId),
+      ]),
+    [noteHits, taskHits],
   );
 
   const counts = useMemo(() => {
@@ -190,7 +217,7 @@ export function ProjectBoard({
         project.repositories.some((repo) =>
           (repo.snapshot?.fullName ?? "").toLowerCase().includes(needle),
         ) ||
-        // Treffer in Notizen kommen vom Server dazu.
+        // Treffer in Notizen und Aufgaben kommen vom Server dazu.
         noteHitProjectIds.has(project.id)
       );
     });
@@ -255,10 +282,14 @@ export function ProjectBoard({
 
   return (
     <section className="space-y-5">
-      {/* Steuerleiste */}
-      <div className="glass flex flex-col gap-4 p-4">
-        <div className="flex flex-wrap items-center gap-3">
-          <div className="relative min-w-[220px] flex-1">
+      {/* Steuerleiste.
+          Auf dem Telefon steht die Suche allein in der ersten Zeile und die
+          Werkzeuge darunter. Frueher lagen beide in einer Zeile, die nicht
+          umbrechen konnte – der Knopf "Neues Projekt" wurde dabei aus dem
+          Bild geschoben und die ganze Seite seitlich scrollbar. */}
+      <div className="glass flex flex-col gap-3 p-3 sm:gap-4 sm:p-4">
+        <div className="flex flex-col gap-3 sm:flex-row sm:flex-wrap sm:items-center">
+          <div className="relative min-w-0 sm:min-w-[220px] sm:flex-1">
             <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-slate-500" />
             <input
               className="field pl-9"
@@ -282,9 +313,12 @@ export function ProjectBoard({
             <label className="sr-only" htmlFor="sort">
               Sortierung
             </label>
+            {/* min-w-0 ist hier entscheidend: ohne das weigert sich ein
+                Flex-Kind, unter seine Inhaltsbreite zu schrumpfen, und
+                drueckt stattdessen die Nachbarn hinaus. */}
             <select
               id="sort"
-              className="field w-auto min-w-[11rem]"
+              className="field w-auto min-w-0 flex-1 truncate sm:flex-none sm:min-w-[11rem]"
               value={sort}
               onChange={(event) => setSort(event.target.value as SortKey)}
               // Im Brett zaehlt die Anordnung von Hand. Die Sortierung hier
@@ -303,50 +337,11 @@ export function ProjectBoard({
               ))}
             </select>
 
-            <div className="flex overflow-hidden rounded-xl border border-white/9">
-              <button
-                type="button"
-                onClick={() => setView("grid")}
-                className={cn(
-                  "p-2 transition-colors",
-                  view === "grid" ? "bg-white/10 text-white" : "text-slate-500 hover:text-white",
-                )}
-                aria-label="Rasteransicht"
-                title="Rasteransicht"
-              >
-                <LayoutGrid className="h-4 w-4" />
-              </button>
-              <button
-                type="button"
-                onClick={() => setView("grouped")}
-                className={cn(
-                  "p-2 transition-colors",
-                  view === "grouped" ? "bg-white/10 text-white" : "text-slate-500 hover:text-white",
-                )}
-                aria-label="Nach Status gruppiert"
-                title="Nach Status gruppiert"
-              >
-                <Rows3 className="h-4 w-4" />
-              </button>
-              <button
-                type="button"
-                onClick={() => setView("kanban")}
-                className={cn(
-                  "p-2 transition-colors",
-                  view === "kanban" ? "bg-white/10 text-white" : "text-slate-500 hover:text-white",
-                )}
-                aria-label="Kanban-Spalten"
-                title="Kanban – Status per Ziehen aendern"
-              >
-                <Columns3 className="h-4 w-4" />
-              </button>
-            </div>
-
             <button
               ref={dataButtonRef}
               type="button"
               onClick={() => setDataMenuOpen((value) => !value)}
-              className="rounded-xl border border-white/9 p-2 text-slate-500 transition-colors hover:text-white"
+              className="shrink-0 rounded-xl border border-white/9 p-2.5 text-slate-500 transition-colors hover:text-white"
               aria-label="Daten exportieren oder importieren"
               title="Export und Import"
               aria-haspopup="menu"
@@ -355,13 +350,51 @@ export function ProjectBoard({
               <Database className="h-4 w-4" />
             </button>
 
-            <button type="button" className="btn btn-primary" onClick={() => setDialogOpen(true)}>
+            <button
+              type="button"
+              className="btn btn-primary shrink-0"
+              onClick={() => setDialogOpen(true)}
+              // Unterhalb von sm bleibt nur das Pluszeichen stehen. Ohne
+              // eigene Beschriftung liest ein Screenreader dann gar nichts vor.
+              aria-label="Neues Projekt"
+            >
               <Plus className="h-4 w-4" />
               <span className="hidden sm:inline">Neues Projekt</span>
             </button>
           </div>
         </div>
 
+        {/* Ansichtsumschalter: auf schmalen Anzeigen ueber die volle Breite,
+            damit die vier Knoepfe gross genug zum Treffen bleiben. */}
+        <div
+          className="flex overflow-hidden rounded-xl border border-white/9 sm:w-auto sm:self-start"
+          role="group"
+          aria-label="Ansicht"
+        >
+          {VIEWS.map((mode) => {
+            const { label, title, icon: Icon } = VIEW_META[mode];
+            const active = view === mode;
+            return (
+              <button
+                key={mode}
+                type="button"
+                onClick={() => setView(mode)}
+                className={cn(
+                  "flex flex-1 items-center justify-center gap-1.5 px-3 py-2 text-xs transition-colors sm:flex-none",
+                  active ? "bg-white/10 text-white" : "text-slate-500 hover:text-white",
+                )}
+                aria-pressed={active}
+                title={title}
+              >
+                <Icon className="h-4 w-4 shrink-0" />
+                {/* Nur auf den schmalsten Anzeigen bleiben die Symbole allein –
+                    dort waeren vier Beschriftungen enger als die Fingerkuppe. */}
+                <span className="hidden xs:inline">{label}</span>
+              </button>
+            );
+          })}
+        </div>
+
         <div className="flex flex-wrap items-center gap-2">
           <span className="mr-1 inline-flex items-center gap-1.5 text-[11px] uppercase tracking-wider text-slate-500">
             <ListFilter className="h-3.5 w-3.5" />
@@ -418,6 +451,60 @@ export function ProjectBoard({
         </div>
       </div>
 
+      {/* Treffer in Aufgaben */}
+      {taskHits.length > 0 ? (
+        <div className="glass fade-up p-4">
+          <h2 className="mb-2.5 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-wider text-slate-400">
+            <CheckSquare className="h-3.5 w-3.5 text-emerald-300" />
+            Treffer in Aufgaben
+            <span className="rounded-full bg-white/6 px-2 py-0.5 tabular-nums text-slate-400">
+              {taskHits.length}
+            </span>
+          </h2>
+          <ul className="space-y-1">
+            {taskHits.slice(0, 8).map((hit) => {
+              const project = projects.find((entry) => entry.id === hit.projectId);
+              const status = TASK_STATUS_META[hit.status as TaskStatus];
+              return (
+                <li key={hit.taskId}>
+                  <Link
+                    href={`/projects/${hit.projectId}`}
+                    className="block rounded-lg px-2.5 py-2 transition-colors hover:bg-white/5"
+                  >
+                    <span className="flex flex-wrap items-baseline gap-x-2">
+                      <span className="text-sm text-slate-200">{hit.title}</span>
+                      <span className="text-[11px] text-slate-500">
+                        · {project?.name ?? "Projekt"}
+                      </span>
+                      {status ? (
+                        <span
+                          className="inline-flex items-center gap-1 text-[11px]"
+                          style={{ color: status.color }}
+                        >
+                          {status.label}
+                        </span>
+                      ) : null}
+                    </span>
+                    {/* Nur wenn die Beschreibung etwas beitraegt – passte
+                        allein der Titel, ist der Ausschnitt leer. */}
+                    {hit.snippet.trim() ? (
+                      <span className="mt-0.5 block text-xs leading-snug text-slate-400">
+                        {highlight(hit.snippet)}
+                      </span>
+                    ) : null}
+                  </Link>
+                </li>
+              );
+            })}
+          </ul>
+          {taskHits.length > 8 ? (
+            <p className="mt-2 px-2.5 text-[11px] text-slate-600">
+              … und {taskHits.length - 8} weitere
+            </p>
+          ) : null}
+        </div>
+      ) : null}
+
       {/* Treffer in Notizen */}
       {noteHits.length > 0 ? (
         <div className="glass fade-up p-4">
@@ -471,6 +558,8 @@ export function ProjectBoard({
           selection={selection}
           onToggleSelect={toggleSelect}
         />
+      ) : view === "list" ? (
+        <ProjectList projects={visible} selection={selection} onToggleSelect={toggleSelect} />
       ) : view === "grid" ? (
         <div className="grid gap-4 sm:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4">
           {visible.map((project, index) => (

src/components/ProjectHeader.tsx

@@ -74,7 +74,7 @@ export function ProjectHeader({
 
   return (
     <header
-      className="glass relative overflow-hidden p-6"
+      className="glass relative overflow-hidden p-4 sm:p-6"
       style={
         {
           "--accent-from": accent.from,
@@ -168,9 +168,13 @@ export function ProjectHeader({
           ) : null}
         </div>
 
-        <div className="flex flex-col items-end gap-3">
+        {/* Auf dem Telefon steht dieser Block unter dem Titel und faengt
+            links an; erst ab sm rueckt er nach rechts neben ihn. Vorher
+            standen vier Knoepfe in einer Zeile, die nicht umbrechen durfte –
+            "Loeschen" lag damit ausserhalb des Bildschirms. */}
+        <div className="flex flex-wrap items-center gap-2 sm:flex-col sm:items-end sm:gap-3">
           <StatusSelect projectId={project.id} status={project.status} />
-          <div className="flex gap-2">
+          <div className="flex flex-wrap gap-2">
             <button
               ref={exportButtonRef}
               type="button"
@@ -179,6 +183,7 @@ export function ProjectHeader({
               aria-haspopup="menu"
               aria-expanded={exportOpen}
               title="Exportieren"
+              aria-label="Exportieren"
             >
               <Download className="h-3.5 w-3.5" />
             </button>
@@ -187,6 +192,7 @@ export function ProjectHeader({
               className="btn btn-ghost px-2.5 py-1.5 text-xs"
               onClick={() => setTemplateOpen(true)}
               title="Als Vorlage sichern"
+              aria-label="Als Vorlage sichern"
             >
               <BookmarkPlus className="h-3.5 w-3.5" />
             </button>

src/components/ProjectList.tsx

@@ -0,0 +1,204 @@
+"use client";
+
+import Link from "next/link";
+import { useState } from "react";
+import {
+  AlertTriangle,
+  CheckSquare,
+  GitBranch,
+  GitCommitHorizontal,
+  NotebookPen,
+  Star,
+} from "lucide-react";
+import { StatusSelect } from "@/components/StatusSelect";
+import { PRIORITY_META, accentOf, statusOf } from "@/lib/status";
+import { cn, formatRelative } from "@/lib/utils";
+import type { ProjectListItem } from "@/types";
+
+/**
+ * Listenansicht des Boards.
+ *
+ * Warum zusaetzlich zum Raster: eine Karte braucht rund 260px Hoehe, auf dem
+ * Telefon steht sie zwangslaeufig allein in der Zeile. Fuenf Projekte fuellen
+ * damit zwei Bildschirme, bevor man ueberhaupt etwas vergleichen kann. Eine
+ * Zeile kommt mit einem Viertel davon aus, und weil alle Zeilen gleich
+ * aufgebaut sind, liegen Name, Fortschritt und Status untereinander – genau
+ * das, was das Raster auf schmalen Anzeigen verliert.
+ */
+export function ProjectList({
+  projects,
+  selection,
+  onToggleSelect,
+}: {
+  projects: ProjectListItem[];
+  selection: Set<string>;
+  onToggleSelect?: (id: string, selected: boolean) => void;
+}) {
+  return (
+    <ul className="glass fade-up divide-y divide-white/6 overflow-hidden">
+      {projects.map((project) => (
+        <ProjectRow
+          key={project.id}
+          project={project}
+          selected={selection.has(project.id)}
+          onToggleSelect={onToggleSelect}
+        />
+      ))}
+    </ul>
+  );
+}
+
+function ProjectRow({
+  project,
+  selected,
+  onToggleSelect,
+}: {
+  project: ProjectListItem;
+  selected: boolean;
+  onToggleSelect?: (id: string, selected: boolean) => void;
+}) {
+  const accent = accentOf(project.accent);
+  const meta = statusOf(project.status);
+  const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
+  const snapshot = project.repositories[0]?.snapshot ?? null;
+  const syncError = project.repositories.find((repo) => repo.syncError)?.syncError ?? null;
+  const [favorite, setFavorite] = useState(project.favorite);
+
+  async function toggleFavorite() {
+    const next = !favorite;
+    setFavorite(next);
+    try {
+      const response = await fetch(`/api/projects/${project.id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ favorite: next }),
+      });
+      if (!response.ok) throw new Error("failed");
+    } catch {
+      setFavorite(!next);
+    }
+  }
+
+  return (
+    <li
+      className={cn("group relative transition-colors", selected && "bg-violet-500/8")}
+      style={
+        {
+          "--accent-from": accent.from,
+          "--accent-to": accent.to,
+        } as React.CSSProperties
+      }
+    >
+      {/* Die ganze Zeile ist der Link; was darueber bedienbar sein soll,
+          bekommt weiter unten die Zeigerereignisse zurueck. */}
+      <Link
+        href={`/projects/${project.id}`}
+        className="absolute inset-0 z-0 focus:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-violet-400/60"
+        aria-label={`Projekt ${project.name} oeffnen`}
+      />
+
+      <div className="pointer-events-none relative z-10 flex items-center gap-2.5 px-3 py-2.5 transition-colors group-hover:bg-white/4 sm:gap-3 sm:px-4 sm:py-3">
+        {onToggleSelect ? (
+          <input
+            type="checkbox"
+            checked={selected}
+            onChange={(event) => onToggleSelect(project.id, event.target.checked)}
+            aria-label={`${project.name} auswaehlen`}
+            className={cn(
+              "pointer-events-auto h-4 w-4 shrink-0 accent-violet-500 transition-opacity",
+              !selected && "opacity-35 group-hover:opacity-100 focus-visible:opacity-100",
+            )}
+          />
+        ) : null}
+
+        {/* Statusfarbe als Streifen: auf einen Blick erkennbar, ohne Platz
+            fuer eine Beschriftung zu verbrauchen. */}
+        <span
+          className="h-8 w-1 shrink-0 rounded-full"
+          style={{ backgroundColor: meta.color }}
+          aria-hidden="true"
+        />
+
+        <div className="min-w-0 flex-1">
+          <div className="flex items-center gap-1.5">
+            <h3 className="truncate text-sm font-medium text-white group-hover:text-violet-200">
+              {project.name}
+            </h3>
+            {favorite ? (
+              <Star className="h-3 w-3 shrink-0 fill-amber-300 text-amber-300" />
+            ) : null}
+            {syncError ? (
+              <AlertTriangle className="h-3 w-3 shrink-0 text-rose-300/80" aria-label="Sync-Fehler" />
+            ) : null}
+          </div>
+
+          <div className="mt-1.5 flex items-center gap-2 text-[11px] text-slate-500">
+            <span className="h-1 w-16 shrink-0 overflow-hidden rounded-full bg-white/8 sm:w-24">
+              <span
+                className="accent-bar block h-full rounded-full"
+                style={{ width: `${Math.max(2, project.progress)}%` }}
+              />
+            </span>
+            <span className="shrink-0 tabular-nums">{project.progress}%</span>
+
+            {/* Was nicht mehr in die Zeile passt, faellt der Reihe nach weg,
+                statt sie zu sprengen. */}
+            {project._count.tasks > 0 ? (
+              <span className="hidden shrink-0 items-center gap-1 xs:inline-flex">
+                <CheckSquare className="h-3 w-3" />
+                {project.tasks.length}/{project._count.tasks}
+              </span>
+            ) : null}
+            {project._count.notes > 0 ? (
+              <span className="hidden shrink-0 items-center gap-1 sm:inline-flex">
+                <NotebookPen className="h-3 w-3" />
+                {project._count.notes}
+              </span>
+            ) : null}
+            {snapshot?.defaultBranch ? (
+              <span className="hidden shrink-0 items-center gap-1 font-mono md:inline-flex">
+                <GitBranch className="h-3 w-3" />
+                {snapshot.defaultBranch}
+              </span>
+            ) : null}
+            {snapshot?.lastCommitAt ? (
+              <span
+                className="hidden shrink-0 items-center gap-1 lg:inline-flex"
+                suppressHydrationWarning
+              >
+                <GitCommitHorizontal className="h-3 w-3" />
+                {formatRelative(snapshot.lastCommitAt)}
+              </span>
+            ) : null}
+
+            <span
+              className="ml-auto hidden shrink-0 uppercase tracking-wider md:inline"
+              style={{ color: priority.color }}
+              title={`Prioritaet: ${priority.label}`}
+            >
+              {priority.label}
+            </span>
+          </div>
+        </div>
+
+        <button
+          type="button"
+          onClick={toggleFavorite}
+          aria-label={favorite ? "Favorit entfernen" : "Als Favorit markieren"}
+          className={cn(
+            "pointer-events-auto hidden shrink-0 rounded-lg p-2 transition-colors sm:block",
+            favorite
+              ? "text-amber-300 hover:bg-amber-400/10"
+              : "text-slate-600 hover:bg-white/8 hover:text-amber-300",
+          )}
+        >
+          <Star className={cn("h-4 w-4", favorite && "fill-current")} />
+        </button>
+
+        <div className="pointer-events-auto shrink-0">
+          <StatusSelect projectId={project.id} status={project.status} variant="compact" />
+        </div>
+      </div>
+    </li>
+  );
+}

src/components/QuickCapture.tsx

@@ -0,0 +1,282 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import { CheckSquare, Lightbulb, Loader2, Zap } from "lucide-react";
+import { Modal } from "@/components/ui/Modal";
+import { cn } from "@/lib/utils";
+
+/**
+ * Schnellerfassung: ein Feld, Enter, fertig.
+ *
+ * „Ideen festhalten" ist der erste Satz auf dem Dashboard – der Weg dorthin
+ * fuehrte aber ueber einen Dialog mit sieben Feldern. Unterwegs auf dem
+ * Telefon ist das der Unterschied zwischen „schreib ich schnell auf" und
+ * „mach ich spaeter", und spaeter heisst gar nicht.
+ *
+ * Deshalb bleibt hier alles weg, was sich nachziehen laesst: Projekte
+ * entstehen als Idee, Aufgaben als offen. Beschreibung, Status, Termin und
+ * der ganze Rest kommen am Rechner dazu, wenn ueberhaupt.
+ *
+ * Der Dialog bleibt nach dem Anlegen offen und leert nur das Feld. Wer eine
+ * Idee notiert, hat meistens gleich die naechste – ihn jedes Mal neu zu
+ * oeffnen waere genau die Huerde, die hier wegsoll.
+ */
+
+interface ProjektHit {
+  id: string;
+  name: string;
+}
+
+/** Zuletzt gewaehltes Projekt, damit die Aufgabenerfassung nicht jedes Mal fragt. */
+const PROJEKT_SCHLUESSEL = "nebula.quickcapture.projekt";
+
+type Modus = "idee" | "aufgabe";
+
+interface Angelegt {
+  art: Modus;
+  titel: string;
+  href: string;
+}
+
+export function QuickCapture({
+  open,
+  onClose,
+  initialMode = "idee",
+}: {
+  open: boolean;
+  onClose: () => void;
+  /** Aus der Aufgabenuebersicht heraus faengt der Dialog bei "aufgabe" an. */
+  initialMode?: Modus;
+}) {
+  const router = useRouter();
+  const eingabeRef = useRef<HTMLInputElement>(null);
+
+  const [modus, setModus] = useState<Modus>(initialMode);
+  const [titel, setTitel] = useState("");
+  const [projekte, setProjekte] = useState<ProjektHit[]>([]);
+  const [projektId, setProjektId] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [fehler, setFehler] = useState<string | null>(null);
+  const [angelegt, setAngelegt] = useState<Angelegt[]>([]);
+
+  // Beim Oeffnen zuruecksetzen – ein Dialog, der noch die Eingabe von
+  // vorgestern zeigt, ist schlimmer als einer, der leer ist.
+  useEffect(() => {
+    if (!open) return;
+    setTitel("");
+    setFehler(null);
+    setAngelegt([]);
+    setModus(initialMode);
+  }, [open, initialMode]);
+
+  /**
+   * Die Projektliste wird erst gebraucht, wenn jemand eine Aufgabe erfasst.
+   * Sie beim Oeffnen zu holen waere eine Abfrage fuer den haeufigeren Fall,
+   * in dem sie niemand ansieht.
+   */
+  useEffect(() => {
+    if (!open || modus !== "aufgabe" || projekte.length > 0) return;
+
+    let abgebrochen = false;
+    (async () => {
+      try {
+        const antwort = await fetch("/api/projects");
+        if (!antwort.ok) return;
+        const daten = (await antwort.json()) as { projects?: ProjektHit[] };
+        if (abgebrochen) return;
+
+        const liste = (daten.projects ?? []).map(({ id, name }) => ({ id, name }));
+        setProjekte(liste);
+
+        const gemerkt = window.localStorage.getItem(PROJEKT_SCHLUESSEL);
+        const gueltig = gemerkt && liste.some((eintrag) => eintrag.id === gemerkt);
+        setProjektId(gueltig ? gemerkt : (liste[0]?.id ?? ""));
+      } catch {
+        // Ohne Liste bleibt der Waehler leer; der Hinweis darunter erklaert es.
+      }
+    })();
+
+    return () => {
+      abgebrochen = true;
+    };
+  }, [open, modus, projekte.length]);
+
+  async function absenden(event: React.FormEvent) {
+    event.preventDefault();
+    const wert = titel.trim();
+    if (!wert || busy) return;
+
+    setBusy(true);
+    setFehler(null);
+
+    try {
+      if (modus === "idee") {
+        const antwort = await fetch("/api/projects", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          // Nur der Name. Alles andere setzt das Schema: Status IDEA,
+          // Prioritaet normal, Fortschritt 0.
+          body: JSON.stringify({ name: wert }),
+        });
+        const nutzlast = await antwort.json().catch(() => ({}));
+        if (!antwort.ok) throw new Error(nutzlast.error ?? "Anlegen fehlgeschlagen.");
+
+        setAngelegt((bisher) => [
+          { art: "idee", titel: wert, href: `/projects/${nutzlast.project.id}` },
+          ...bisher,
+        ]);
+      } else {
+        if (!projektId) throw new Error("Kein Projekt gewaehlt.");
+        const antwort = await fetch(`/api/projects/${projektId}/tasks`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ title: wert }),
+        });
+        const nutzlast = await antwort.json().catch(() => ({}));
+        if (!antwort.ok) throw new Error(nutzlast.error ?? "Anlegen fehlgeschlagen.");
+
+        window.localStorage.setItem(PROJEKT_SCHLUESSEL, projektId);
+        setAngelegt((bisher) => [
+          { art: "aufgabe", titel: wert, href: `/projects/${projektId}` },
+          ...bisher,
+        ]);
+      }
+
+      setTitel("");
+      eingabeRef.current?.focus();
+      router.refresh();
+    } catch (gefangen) {
+      setFehler(gefangen instanceof Error ? gefangen.message : String(gefangen));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      width="md"
+      title="Schnell erfassen"
+      description="Ein Feld genuegt. Beschreibung, Status und Termin lassen sich spaeter nachziehen."
+    >
+      <form onSubmit={absenden} className="space-y-4">
+        <div className="flex overflow-hidden rounded-xl border border-white/9" role="group">
+          {(
+            [
+              { wert: "idee", label: "Idee", hinweis: "Neues Projekt", icon: Lightbulb },
+              { wert: "aufgabe", label: "Aufgabe", hinweis: "In einem Projekt", icon: CheckSquare },
+            ] as const
+          ).map(({ wert, label, hinweis, icon: Icon }) => (
+            <button
+              key={wert}
+              type="button"
+              onClick={() => setModus(wert)}
+              aria-pressed={modus === wert}
+              className={cn(
+                "flex flex-1 items-center justify-center gap-2 px-3 py-2.5 text-sm transition-colors",
+                modus === wert ? "bg-white/10 text-white" : "text-slate-400 hover:text-white",
+              )}
+              title={hinweis}
+            >
+              <Icon className="h-4 w-4 shrink-0" />
+              {label}
+            </button>
+          ))}
+        </div>
+
+        <div>
+          <label className="field-label" htmlFor="quick-title">
+            {modus === "idee" ? "Wie heisst die Idee?" : "Was ist zu tun?"}
+          </label>
+          <input
+            id="quick-title"
+            ref={eingabeRef}
+            className="field"
+            value={titel}
+            onChange={(event) => setTitel(event.target.value)}
+            placeholder={modus === "idee" ? "z. B. Pixelgarten" : "z. B. Favicon austauschen"}
+            maxLength={modus === "idee" ? 120 : 200}
+            required
+            autoFocus
+            // enterKeyHint stellt auf dem Telefon die Absendetaste um – sonst
+            // steht dort „Weiter", obwohl es nichts weiter gibt.
+            enterKeyHint="done"
+          />
+        </div>
+
+        {modus === "aufgabe" ? (
+          <div>
+            <label className="field-label" htmlFor="quick-project">
+              Projekt
+            </label>
+            {projekte.length > 0 ? (
+              <select
+                id="quick-project"
+                className="field"
+                value={projektId}
+                onChange={(event) => setProjektId(event.target.value)}
+              >
+                {projekte.map((projekt) => (
+                  <option key={projekt.id} value={projekt.id}>
+                    {projekt.name}
+                  </option>
+                ))}
+              </select>
+            ) : (
+              <p className="text-sm text-slate-500">
+                Noch kein Projekt vorhanden – leg zuerst eine Idee an.
+              </p>
+            )}
+          </div>
+        ) : null}
+
+        {fehler ? (
+          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
+            {fehler}
+          </p>
+        ) : null}
+
+        {angelegt.length > 0 ? (
+          <div className="rounded-lg border border-emerald-500/25 bg-emerald-500/8 px-3 py-2">
+            <p className="text-[11px] font-semibold uppercase tracking-wider text-emerald-300/80">
+              Angelegt
+            </p>
+            <ul className="mt-1 space-y-0.5">
+              {angelegt.slice(0, 5).map((eintrag, index) => (
+                <li key={`${eintrag.href}-${index}`} className="truncate text-sm">
+                  <Link
+                    href={eintrag.href}
+                    onClick={onClose}
+                    className="text-emerald-100 underline-offset-2 hover:underline"
+                  >
+                    {eintrag.titel}
+                  </Link>
+                  <span className="ml-1.5 text-[11px] text-emerald-300/60">
+                    {eintrag.art === "idee" ? "Projekt" : "Aufgabe"}
+                  </span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        ) : null}
+
+        <div className="flex justify-end gap-2 pt-1">
+          <button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
+            {angelegt.length > 0 ? "Fertig" : "Abbrechen"}
+          </button>
+          <button
+            type="submit"
+            className="btn btn-primary"
+            disabled={busy || !titel.trim() || (modus === "aufgabe" && !projektId)}
+          >
+            {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Zap className="h-4 w-4" />}
+            Anlegen
+          </button>
+        </div>
+      </form>
+    </Modal>
+  );
+}

src/components/StatCard.tsx

@@ -1,4 +1,5 @@
 import type { LucideIcon } from "lucide-react";
+import { cn } from "@/lib/utils";
 
 interface StatCardProps {
   label: string;
@@ -6,26 +7,33 @@ interface StatCardProps {
   hint?: string;
   icon: LucideIcon;
   color: string;
+  className?: string;
 }
 
-export function StatCard({ label, value, hint, icon: Icon, color }: StatCardProps) {
+export function StatCard({ label, value, hint, icon: Icon, color, className }: StatCardProps) {
   return (
-    <div className="glass relative overflow-hidden p-4">
+    <div className={cn("glass relative overflow-hidden p-3 sm:p-4", className)}>
       <div
         className="pointer-events-none absolute -right-6 -top-8 h-24 w-24 rounded-full opacity-25 blur-2xl"
         style={{ backgroundColor: color }}
         aria-hidden="true"
       />
-      <div className="flex items-start justify-between gap-3">
+      <div className="flex items-start justify-between gap-2 sm:gap-3">
         <div className="min-w-0">
-          <p className="text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">
+          {/* Umbrechen statt abschneiden: in der zweispaltigen Anordnung auf
+              dem Telefon endeten "In Entwicklung" und "Repos verknuepft"
+              sonst beide als "In Entwickl…" – zwei Kacheln, die sich nicht
+              mehr unterscheiden liessen. */}
+          <p className="text-[11px] font-semibold uppercase leading-tight tracking-[0.14em] text-slate-500">
             {label}
           </p>
-          <p className="mt-2 text-3xl font-semibold tabular-nums text-white">{value}</p>
-          {hint ? <p className="mt-1 truncate text-xs text-slate-500">{hint}</p> : null}
+          <p className="mt-1.5 text-2xl font-semibold tabular-nums text-white sm:mt-2 sm:text-3xl">
+            {value}
+          </p>
+          {hint ? <p className="mt-1 text-xs leading-tight text-slate-500">{hint}</p> : null}
         </div>
         <span
-          className="grid h-9 w-9 shrink-0 place-items-center rounded-xl"
+          className="grid h-8 w-8 shrink-0 place-items-center rounded-xl sm:h-9 sm:w-9"
           style={{ backgroundColor: `${color}1f`, color }}
         >
           <Icon className="h-4 w-4" />

src/components/Timeline.tsx

@@ -0,0 +1,126 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { ChevronDown, History, Loader2 } from "lucide-react";
+import { ActivityDayGroups } from "@/components/ActivityRow";
+import { tagesschluessel } from "@/lib/review";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+/**
+ * Die fortlaufende Zeitleiste.
+ *
+ * Client-Komponente, weil hier nachgeladen wird – das ist der Unterschied
+ * zum Wochenrueckblick, der komplett auf dem Server entsteht.
+ *
+ * Die Buendelung nach Tagen passiert hier im Browser. Das ist unbedenklich,
+ * weil tagesschluessel eine feste Zeitzone benutzt: Server und Browser kommen
+ * damit auf denselben Kalendertag, und die erste Seite hydriert ohne
+ * Abweichung.
+ */
+export function Timeline({
+  erste,
+  weitere: gabWeitere,
+}: {
+  erste: ReviewEntry[];
+  weitere: boolean;
+}) {
+  const [eintraege, setEintraege] = useState(erste);
+  const [weitere, setWeitere] = useState(gabWeitere);
+  const [laedt, setLaedt] = useState(false);
+  const [fehler, setFehler] = useState<string | null>(null);
+
+  const tage: ReviewDay[] = useMemo(() => {
+    // Map behaelt die Einfuegereihenfolge – die Eintraege kommen schon
+    // absteigend, also stimmt die Reihenfolge der Tage von selbst.
+    const nachTag = new Map<string, ReviewEntry[]>();
+    for (const eintrag of eintraege) {
+      const schluessel = tagesschluessel(new Date(eintrag.createdAt));
+      const liste = nachTag.get(schluessel) ?? [];
+      liste.push(eintrag);
+      nachTag.set(schluessel, liste);
+    }
+    return [...nachTag.entries()].map(([tag, liste]) => ({ tag, eintraege: liste }));
+  }, [eintraege]);
+
+  async function mehr() {
+    const letzter = eintraege[eintraege.length - 1];
+    if (!letzter) return;
+
+    setLaedt(true);
+    setFehler(null);
+    try {
+      const antwort = await fetch(
+        `/api/activity?vor=${encodeURIComponent(letzter.createdAt)}&id=${encodeURIComponent(letzter.id)}`,
+      );
+      if (!antwort.ok) throw new Error("Verlauf konnte nicht geladen werden.");
+      const nutzlast = (await antwort.json()) as {
+        activities: ReviewEntry[];
+        weitere: boolean;
+      };
+
+      /**
+       * Gegen Dubletten absichern, auch wenn der Cursor sie ausschliesst:
+       * ein zweimal gedrueckter Knopf oder ein wiederholter Aufruf soll
+       * keine Zeile verdoppeln, und React braucht eindeutige Schluessel.
+       */
+      setEintraege((bisher) => {
+        const bekannt = new Set(bisher.map((eintrag) => eintrag.id));
+        return [...bisher, ...nutzlast.activities.filter((eintrag) => !bekannt.has(eintrag.id))];
+      });
+      setWeitere(nutzlast.weitere);
+    } catch (gefangen) {
+      setFehler(gefangen instanceof Error ? gefangen.message : String(gefangen));
+    } finally {
+      setLaedt(false);
+    }
+  }
+
+  if (eintraege.length === 0) {
+    return (
+      <div className="glass fade-up flex flex-col items-center justify-center gap-4 px-6 py-16 text-center">
+        <span className="grid h-14 w-14 place-items-center rounded-2xl bg-gradient-to-br from-violet-500/25 to-cyan-400/20 text-violet-200">
+          <History className="h-6 w-6" />
+        </span>
+        <div>
+          <h2 className="text-lg font-semibold text-white">Noch kein Verlauf</h2>
+          <p className="mt-1 max-w-md text-sm text-slate-400">
+            Sobald du ein Projekt anlegst, Aufgaben verschiebst oder Notizen schreibst, steht es
+            hier.
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-5">
+      {/* Die Jahreszahl gehoert dazu: eine Zeitleiste reicht weit zurueck,
+          und "3. Januar" allein sagt dann nicht genug. */}
+      <ActivityDayGroups tage={tage} mitJahr />
+
+      {fehler ? (
+        <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
+          {fehler}
+        </p>
+      ) : null}
+
+      <div className="flex flex-col items-center gap-2 pt-1">
+        {weitere ? (
+          <button type="button" className="btn btn-ghost" onClick={mehr} disabled={laedt}>
+            {laedt ? (
+              <Loader2 className="h-4 w-4 animate-spin" />
+            ) : (
+              <ChevronDown className="h-4 w-4" />
+            )}
+            Ältere laden
+          </button>
+        ) : (
+          <p className="text-xs text-slate-600">Das war alles.</p>
+        )}
+        <p className="text-[11px] text-slate-600 tabular-nums">
+          {eintraege.length} {eintraege.length === 1 ? "Vorgang" : "Vorgänge"} geladen
+        </p>
+      </div>
+    </div>
+  );
+}

src/components/TopNav.tsx

@@ -4,6 +4,7 @@ import { useRef, useState } from "react";
 import Link from "next/link";
 import { usePathname, useRouter } from "next/navigation";
 import {
+  CheckSquare,
   GitBranch,
   LayoutDashboard,
   LogOut,
@@ -11,13 +12,16 @@ import {
   ShieldCheck,
   Sparkles,
   UserRound,
+  Zap,
 } from "lucide-react";
+import { QuickCapture } from "@/components/QuickCapture";
 import { Popover } from "@/components/ui/Popover";
 import type { SessionUser } from "@/lib/auth/session";
 import { cn } from "@/lib/utils";
 
 const LINKS = [
   { href: "/", label: "Dashboard", icon: LayoutDashboard },
+  { href: "/tasks", label: "Aufgaben", icon: CheckSquare },
   { href: "/connections", label: "Git-Verbindungen", icon: GitBranch },
 ];
 
@@ -34,16 +38,20 @@ export function TopNav({
 
   return (
     <header className="sticky top-0 z-40 border-b border-white/5 bg-[#05060f]/70 backdrop-blur-xl">
-      <div className="mx-auto flex w-full max-w-[1400px] items-center gap-6 px-4 py-3 sm:px-6 lg:px-8">
-        <Link href="/" className="group flex items-center gap-3">
+      <div className="mx-auto flex w-full max-w-[1400px] items-center gap-3 px-4 py-3 sm:gap-6 sm:px-6 lg:px-8">
+        <Link href="/" className="group flex min-w-0 items-center gap-2 sm:gap-3">
           <span className="relative grid h-9 w-9 place-items-center rounded-xl bg-gradient-to-br from-violet-500 via-fuchsia-500 to-cyan-400 shadow-[0_8px_28px_-10px_rgba(168,85,247,0.9)] transition-transform group-hover:scale-105">
             <Sparkles className="h-4 w-4 text-white" strokeWidth={2.4} />
           </span>
-          <span className="flex flex-col leading-none">
-            <span className="text-gradient text-lg font-semibold tracking-tight">
+          <span className="flex min-w-0 flex-col leading-none">
+            <span className="text-gradient truncate text-lg font-semibold tracking-tight">
               {appName}
             </span>
-            <span className="mt-0.5 text-[10px] uppercase tracking-[0.2em] text-slate-500">
+            {/* Der weite Zeichenabstand kostet mehr Platz, als die Zeile wert
+                ist. Seit die Aufgaben als dritter Punkt danebenstehen, brach
+                sie auf 375px mitten im Wort ab – unterhalb von sm bleibt
+                deshalb nur der Name. */}
+            <span className="mt-0.5 hidden truncate text-[10px] uppercase tracking-[0.2em] text-slate-500 sm:block">
               {tagline}
             </span>
           </span>
@@ -51,13 +59,20 @@ export function TopNav({
 
         {user ? (
           <>
-            <nav className="flex items-center gap-1">
+            <nav className="flex shrink-0 items-center gap-1">
               {LINKS.map(({ href, label, icon: Icon }) => {
                 const active = href === "/" ? pathname === "/" : pathname.startsWith(href);
                 return (
                   <Link
                     key={href}
                     href={href}
+                    // Unterhalb von sm bleibt nur das Symbol stehen. Ohne
+                    // eigene Beschriftung ist der Verweis dann fuer einen
+                    // Screenreader namenlos – axe-core meldet das als
+                    // "link-name", und zwar zu Recht: vorgelesen wird nichts.
+                    aria-label={label}
+                    title={label}
+                    aria-current={active ? "page" : undefined}
                     className={cn(
                       "flex items-center gap-2 rounded-lg px-3 py-2 text-sm transition-colors",
                       active
@@ -72,7 +87,8 @@ export function TopNav({
               })}
             </nav>
 
-            <div className="ml-auto">
+            <div className="ml-auto flex items-center gap-2">
+              <QuickCaptureButton />
               <UserMenu user={user} />
             </div>
           </>
@@ -82,6 +98,35 @@ export function TopNav({
   );
 }
 
+/**
+ * Der Einstieg in die Schnellerfassung sitzt in der Kopfleiste, nicht als
+ * schwebender Knopf unten rechts: dort waere er auf schmalen Anzeigen mit
+ * der Auswahlleiste kollidiert, die beim Markieren von Projekten einfaehrt.
+ * In der Kopfleiste ist er auf jeder Seite erreichbar.
+ */
+function QuickCaptureButton() {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={() => setOpen(true)}
+        className="btn btn-ghost px-2.5 py-1.5 sm:px-3"
+        // Unterhalb von sm bleibt nur das Symbol – ohne Beschriftung waere
+        // der Knopf fuer einen Screenreader namenlos.
+        aria-label="Schnell erfassen"
+        title="Schnell erfassen – Idee oder Aufgabe"
+      >
+        <Zap className="h-4 w-4" />
+        <span className="hidden lg:inline">Erfassen</span>
+      </button>
+
+      <QuickCapture open={open} onClose={() => setOpen(false)} />
+    </>
+  );
+}
+
 function UserMenu({ user }: { user: SessionUser }) {
   const router = useRouter();
   const [open, setOpen] = useState(false);

src/components/WebhookDialog.tsx

@@ -0,0 +1,244 @@
+"use client";
+
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+import { Check, Copy, Loader2, Radio, Trash2 } from "lucide-react";
+import type { GitProvider } from "@prisma/client";
+import { Modal } from "@/components/ui/Modal";
+import { formatRelative } from "@/lib/utils";
+
+/**
+ * Einrichtung des Webhooks fuer ein Repository.
+ *
+ * Der Haken wird im Git-System von Hand eingetragen. Ihn ueber die API
+ * anzulegen waere machbar, verlangte aber Administrationsrechte am
+ * Repository – deutlich mehr, als Nebula sonst braucht, und es waere ein
+ * Recht, das die meisten Token gar nicht haben.
+ *
+ * Das Geheimnis ist genau einmal zu sehen: danach liegt nur noch die
+ * verschluesselte Fassung in der Datenbank, wie bei den Zugangstoken.
+ */
+
+/** Wo der Haken im jeweiligen System einzutragen ist. */
+const ANLEITUNG: Record<GitProvider, { pfad: string; ereignisse: string }> = {
+  GITHUB: {
+    pfad: "Settings → Webhooks → Add webhook",
+    ereignisse: "Content type „application/json“, Events: Pushes und Issues",
+  },
+  GITEA: {
+    pfad: "Einstellungen → Webhooks → Gitea",
+    ereignisse: "Auslöser: Push und Issues",
+  },
+  GITLAB: {
+    pfad: "Settings → Webhooks",
+    ereignisse: "Trigger: Push events und Issues events",
+  },
+};
+
+export function WebhookDialog({
+  open,
+  onClose,
+  repositoryId,
+  repositoryTitle,
+  provider,
+  eingerichtet,
+  zuletzt,
+}: {
+  open: boolean;
+  onClose: () => void;
+  repositoryId: string;
+  repositoryTitle: string;
+  provider: GitProvider | null;
+  eingerichtet: boolean;
+  zuletzt: Date | string | null;
+}) {
+  const router = useRouter();
+  const [busy, setBusy] = useState(false);
+  const [fehler, setFehler] = useState<string | null>(null);
+  const [geheimnis, setGeheimnis] = useState<string | null>(null);
+  const [url, setUrl] = useState<string | null>(null);
+  const [kopiert, setKopiert] = useState<string | null>(null);
+
+  // Ohne Verbindung ist das System unbekannt. Dann lieber allgemein bleiben,
+  // als eine Anleitung fuer das falsche zu zeigen.
+  const anleitung = provider ? ANLEITUNG[provider] : null;
+
+  async function erzeugen() {
+    setBusy(true);
+    setFehler(null);
+    try {
+      const antwort = await fetch(`/api/repositories/${repositoryId}/webhook`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+      });
+      const nutzlast = await antwort.json().catch(() => ({}));
+      if (!antwort.ok) throw new Error(nutzlast.error ?? "Fehlgeschlagen.");
+      setGeheimnis(nutzlast.secret);
+      setUrl(nutzlast.url);
+      router.refresh();
+    } catch (gefangen) {
+      setFehler(gefangen instanceof Error ? gefangen.message : String(gefangen));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function zuruecknehmen() {
+    if (!window.confirm("Webhook zuruecknehmen? Eingehende Aufrufe werden dann abgewiesen.")) {
+      return;
+    }
+    setBusy(true);
+    try {
+      await fetch(`/api/repositories/${repositoryId}/webhook`, { method: "DELETE" });
+      setGeheimnis(null);
+      setUrl(null);
+      router.refresh();
+      onClose();
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function kopieren(wert: string, was: string) {
+    try {
+      await navigator.clipboard.writeText(wert);
+      setKopiert(was);
+      setTimeout(() => setKopiert(null), 2000);
+    } catch {
+      // Ohne Zwischenablage bleibt der Text zum Markieren stehen.
+    }
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      width="md"
+      title="Webhook einrichten"
+      description={`Damit meldet ${repositoryTitle} Aenderungen sofort, statt auf den naechsten Abgleich zu warten.`}
+    >
+      <div className="space-y-4">
+        {eingerichtet && !geheimnis ? (
+          <div className="rounded-lg border border-emerald-500/25 bg-emerald-500/8 px-3 py-2.5">
+            <p className="flex items-center gap-2 text-sm text-emerald-100">
+              <Radio className="h-4 w-4 shrink-0" />
+              Webhook ist eingerichtet.
+            </p>
+            <p className="mt-1 text-xs text-emerald-300/70" suppressHydrationWarning>
+              {zuletzt
+                ? `Zuletzt empfangen ${formatRelative(zuletzt)}.`
+                : "Bisher ist noch kein Aufruf angekommen — der Haken im Git-System fehlt vermutlich noch."}
+            </p>
+          </div>
+        ) : null}
+
+        {geheimnis && url ? (
+          <div className="space-y-3">
+            <Feld label="URL" wert={url} kopiert={kopiert === "url"} onCopy={() => kopieren(url, "url")} />
+            <Feld
+              label="Geheimnis (Secret)"
+              wert={geheimnis}
+              kopiert={kopiert === "secret"}
+              onCopy={() => kopieren(geheimnis, "secret")}
+            />
+            <p className="rounded-lg border border-amber-500/25 bg-amber-500/8 px-3 py-2 text-xs text-amber-200">
+              Das Geheimnis ist <strong>jetzt zum einzigen Mal</strong> zu sehen. Danach liegt es
+              nur noch verschluesselt in der Datenbank. Verloren? Dann hier ein neues erzeugen —
+              das alte gilt dann nicht mehr.
+            </p>
+          </div>
+        ) : null}
+
+        <div className="rounded-lg border border-white/8 bg-white/2 px-3 py-2.5 text-xs text-slate-400">
+          <p className="font-semibold text-slate-300">Im Git-System eintragen</p>
+          {anleitung ? (
+            <>
+              <p className="mt-1">{anleitung.pfad}</p>
+              <p className="mt-0.5">{anleitung.ereignisse}</p>
+            </>
+          ) : (
+            <p className="mt-1">
+              In den Einstellungen des Repositories unter „Webhooks“, mit den Ausloesern
+              Push und Issues. Ist eine Git-Verbindung hinterlegt, steht hier der genaue
+              Pfad fuer das jeweilige System.
+            </p>
+          )}
+          <p className="mt-2 text-slate-500">
+            Nebula wertet nur Push und Issues aus. Alles andere wird angenommen und liegen
+            gelassen — ein Fehler wuerde das Git-System sonst zum Wiederholen bringen.
+          </p>
+        </div>
+
+        {fehler ? (
+          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
+            {fehler}
+          </p>
+        ) : null}
+
+        <div className="flex flex-wrap items-center justify-between gap-2 pt-1">
+          {eingerichtet ? (
+            <button
+              type="button"
+              className="btn btn-danger px-3 py-1.5 text-xs"
+              onClick={zuruecknehmen}
+              disabled={busy}
+            >
+              <Trash2 className="h-3.5 w-3.5" />
+              Zuruecknehmen
+            </button>
+          ) : (
+            <span />
+          )}
+
+          <div className="flex gap-2">
+            <button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
+              {geheimnis ? "Fertig" : "Schliessen"}
+            </button>
+            <button type="button" className="btn btn-primary" onClick={erzeugen} disabled={busy}>
+              {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Radio className="h-4 w-4" />}
+              {eingerichtet ? "Neues Geheimnis" : "Einrichten"}
+            </button>
+          </div>
+        </div>
+      </div>
+    </Modal>
+  );
+}
+
+function Feld({
+  label,
+  wert,
+  kopiert,
+  onCopy,
+}: {
+  label: string;
+  wert: string;
+  kopiert: boolean;
+  onCopy: () => void;
+}) {
+  return (
+    <div>
+      <span className="field-label">{label}</span>
+      <div className="flex items-center gap-2">
+        {/* tabIndex: der Kasten scrollt seitlich und muss deshalb auch mit
+            der Tastatur erreichbar sein – sonst kommt man an das Ende einer
+            langen URL nur mit der Maus. */}
+        <code
+          tabIndex={0}
+          className="min-w-0 flex-1 overflow-x-auto rounded-lg border border-white/9 bg-[rgba(8,10,24,0.6)] px-3 py-2 font-mono text-xs text-slate-200"
+        >
+          {wert}
+        </code>
+        <button
+          type="button"
+          onClick={onCopy}
+          className="btn btn-ghost shrink-0 px-2.5 py-2"
+          aria-label={`${label} kopieren`}
+        >
+          {kopiert ? <Check className="h-4 w-4 text-emerald-300" /> : <Copy className="h-4 w-4" />}
+        </button>
+      </div>
+    </div>
+  );
+}

src/components/WeeklyReview.tsx

@@ -0,0 +1,108 @@
+import { CalendarRange, CheckSquare, FolderGit2, NotebookPen, Plus } from "lucide-react";
+import { ActivityDayGroups } from "@/components/ActivityRow";
+import type { Kennzahlen } from "@/lib/review";
+import type { ReviewDay } from "@/types";
+
+/**
+ * Der Wochenrueckblick.
+ *
+ * Bewusst eine Server-Komponente: es gibt nichts zu bedienen, alles steht
+ * beim Rendern fest. Das spart dem Browser den ganzen Verlauf als JavaScript.
+ *
+ * Die Tage kommen fertig gebuendelt und in der richtigen Reihenfolge – die
+ * Zuordnung "welcher Kalendertag" haengt an der Zeitzone und gehoert
+ * deshalb auf den Server.
+ */
+
+export function WeeklyReview({
+  tage,
+  kennzahlen,
+  istDieseWoche,
+}: {
+  tage: ReviewDay[];
+  /** Fertig gezaehlt vom Server – die Anzeige rechnet nichts nach. */
+  kennzahlen: Kennzahlen;
+  istDieseWoche: boolean;
+}) {
+  const { gesamt, projekte, erledigt, neueAufgaben, notizen } = kennzahlen;
+
+  if (gesamt === 0) {
+    return (
+      <div className="glass fade-up flex flex-col items-center justify-center gap-4 px-6 py-16 text-center">
+        <span className="grid h-14 w-14 place-items-center rounded-2xl bg-gradient-to-br from-violet-500/25 to-cyan-400/20 text-violet-200">
+          <CalendarRange className="h-6 w-6" />
+        </span>
+        <div>
+          <h2 className="text-lg font-semibold text-white">
+            {istDieseWoche ? "Diese Woche war es still" : "In dieser Woche ist nichts passiert"}
+          </h2>
+          <p className="mt-1 max-w-md text-sm text-slate-400">
+            {istDieseWoche
+              ? "Sobald du Aufgaben abhakst, Notizen schreibst oder etwas gepusht wird, steht es hier."
+              : "Vielleicht lohnt ein Blick auf eine frühere Woche."}
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-5">
+      {/* Kennzahlen */}
+      <div className="grid grid-cols-2 gap-3 sm:gap-4 lg:grid-cols-4">
+        <Kennzahl label="Vorgänge" wert={gesamt} icon={CalendarRange} color="#a78bfa" />
+        <Kennzahl label="Projekte berührt" wert={projekte} icon={FolderGit2} color="#38bdf8" />
+        <Kennzahl label="Aufgaben erledigt" wert={erledigt} icon={CheckSquare} color="#34d399" />
+        <Kennzahl label="Neue Aufgaben" wert={neueAufgaben} icon={Plus} color="#fbbf24" />
+      </div>
+
+      {notizen > 0 ? (
+        <p className="flex items-center gap-1.5 px-1 text-xs text-slate-500">
+          <NotebookPen className="h-3.5 w-3.5" />
+          Dazu {notizen} {notizen === 1 ? "neue Notiz" : "neue Notizen"}.
+        </p>
+      ) : null}
+
+      {/* Verlauf nach Tagen – dieselbe Darstellung wie in der Zeitleiste. */}
+      <ActivityDayGroups tage={tage} />
+    </div>
+  );
+}
+
+function Kennzahl({
+  label,
+  wert,
+  icon: Icon,
+  color,
+}: {
+  label: string;
+  wert: number;
+  icon: typeof CalendarRange;
+  color: string;
+}) {
+  return (
+    <div className="glass relative overflow-hidden p-3 sm:p-4">
+      <div
+        className="pointer-events-none absolute -right-6 -top-8 h-24 w-24 rounded-full opacity-25 blur-2xl"
+        style={{ backgroundColor: color }}
+        aria-hidden="true"
+      />
+      <div className="flex items-start justify-between gap-2">
+        <div className="min-w-0">
+          <p className="text-[11px] font-semibold uppercase leading-tight tracking-[0.14em] text-slate-500">
+            {label}
+          </p>
+          <p className="mt-1.5 text-2xl font-semibold tabular-nums text-white sm:text-3xl">
+            {wert}
+          </p>
+        </div>
+        <span
+          className="grid h-8 w-8 shrink-0 place-items-center rounded-xl sm:h-9 sm:w-9"
+          style={{ backgroundColor: `${color}1f`, color }}
+        >
+          <Icon className="h-4 w-4" />
+        </span>
+      </div>
+    </div>
+  );
+}

src/components/activityKinds.ts

@@ -0,0 +1,43 @@
+import {
+  AlertTriangle,
+  ArrowRight,
+  Download,
+  GitCommitHorizontal,
+  Link2,
+  NotebookPen,
+  Pencil,
+  Plus,
+  Signpost,
+  Sparkles,
+  Trash2,
+} from "lucide-react";
+import type { ActivityKind } from "@prisma/client";
+
+/**
+ * Symbol und Farbe je Art eines Verlaufseintrags.
+ *
+ * Ausgelagert, weil sie inzwischen an zwei Stellen gebraucht werden: im
+ * Verlauf eines Projekts und im Wochenrueckblick ueber alle Projekte. Zwei
+ * Kopien liefen beim naechsten neuen Eintragstyp auseinander.
+ *
+ * Bewusst ohne "use client" und ohne Prisma-Zugriff – nur Typen und
+ * Symbole, damit beide Seiten es importieren koennen.
+ */
+export const ACTIVITY_KINDS: Record<
+  ActivityKind,
+  { icon: typeof Sparkles; color: string; label: string }
+> = {
+  PROJECT_CREATED: { icon: Sparkles, color: "text-violet-300", label: "Projekt angelegt" },
+  PROJECT_UPDATED: { icon: Pencil, color: "text-slate-400", label: "Projekt bearbeitet" },
+  STATUS_CHANGED: { icon: Signpost, color: "text-cyan-300", label: "Status geändert" },
+  NOTE_ADDED: { icon: NotebookPen, color: "text-blue-300", label: "Notiz" },
+  NOTE_UPDATED: { icon: Pencil, color: "text-blue-300", label: "Notiz bearbeitet" },
+  NOTE_DELETED: { icon: Trash2, color: "text-rose-300", label: "Notiz gelöscht" },
+  TASK_ADDED: { icon: Plus, color: "text-emerald-300", label: "Aufgabe angelegt" },
+  TASK_MOVED: { icon: ArrowRight, color: "text-violet-300", label: "Aufgabe verschoben" },
+  TASK_DELETED: { icon: Trash2, color: "text-rose-300", label: "Aufgabe gelöscht" },
+  TASKS_IMPORTED: { icon: Download, color: "text-amber-300", label: "Aufgaben übernommen" },
+  REPO_LINKED: { icon: Link2, color: "text-cyan-300", label: "Repository verknüpft" },
+  REPO_COMMITS: { icon: GitCommitHorizontal, color: "text-emerald-300", label: "Commits" },
+  SYNC_FAILED: { icon: AlertTriangle, color: "text-rose-300", label: "Abgleich fehlgeschlagen" },
+};

src/components/tasks/TaskCard.test.tsx

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { Task } from "@prisma/client";
+import { TaskCard } from "./TaskCard";
+
+/**
+ * Die Karte ist die einzige Stelle im Projekt, an der eine Aufgabe im
+ * Vorbeigehen zu sehen ist – der Bearbeiten-Dialog verlangt einen Klick.
+ * Steht die Verknuepfung nur dort, weiss niemand vorher, welche Aufgabe
+ * ein Issue hat.
+ *
+ * Serverseitig gerendert wie bei Markdown.test.tsx: es geht um das
+ * erzeugte Markup, nicht um Verhalten im Browser.
+ */
+function aufgabe(felder: Partial<Task> = {}): Task {
+  return {
+    id: "t1",
+    projectId: "p1",
+    title: "Etwas tun",
+    description: null,
+    status: "TODO",
+    position: 0,
+    dueDate: null,
+    labels: [],
+    recurrence: null,
+    sourceIssue: null,
+    sourceUrl: null,
+    sourceRepositoryId: null,
+    createdAt: new Date("2026-08-18T10:00:00Z"),
+    updatedAt: new Date("2026-08-18T10:00:00Z"),
+    ...felder,
+  } as Task;
+}
+
+const markup = (task: Task) => renderToStaticMarkup(<TaskCard task={task} />);
+
+describe("Kennzeichen fuer ein verknuepftes Issue", () => {
+  it("zeigt die Nummer, sobald eine Aufgabe an einem Issue haengt", () => {
+    const html = markup(aufgabe({ sourceIssue: 42 }));
+    expect(html).toContain("#42");
+    expect(html).toContain("Verkn");
+  });
+
+  it("erscheint auch ohne Beschreibung, Datum und Labels", () => {
+    // Der eigentliche Fallstrick: die Fusszeile der Karte wird nur
+    // gerendert, wenn es etwas zu zeigen gibt. Faellt die Verknuepfung aus
+    // dieser Bedingung heraus, bleibt genau die nackte Aufgabe unbeschriftet
+    // – und das ist der haeufige Fall bei einer aus einem Issue erzeugten.
+    const html = markup(
+      aufgabe({ sourceIssue: 7, description: null, dueDate: null, labels: [], recurrence: null }),
+    );
+    expect(html).toContain("#7");
+  });
+
+  it("bleibt weg, wenn keine Verknuepfung besteht", () => {
+    const html = markup(aufgabe({ description: "Text" }));
+    expect(html).not.toContain("Verkn");
+  });
+
+  it("bleibt auf einer erledigten Aufgabe sichtbar", () => {
+    // Die erledigte Karte streicht ihren Titel durch; das Kennzeichen bleibt
+    // in voller Helligkeit. Abzudunkeln war versucht und wieder verworfen –
+    // axe-core rechnete es als Kontrastverstoss ab (10px Text, 3,2:1).
+    // Dass hier ein Issue mitgeschlossen wurde, ist ohnehin gerade dann die
+    // interessante Auskunft.
+    const html = markup(aufgabe({ sourceIssue: 5, status: "DONE" }));
+    expect(html).toContain("#5");
+  });
+
+  it("baut keinen Link in die Karte", () => {
+    // Die Karte steckt in einem <button>; ein <a> darin waere ungueltiges
+    // Markup und im Browser nicht verlaesslich anklickbar.
+    const html = markup(aufgabe({ sourceIssue: 42, sourceUrl: "https://example.com/issues/42" }));
+    expect(html).not.toContain("<a ");
+  });
+
+  it("nennt die Verknuepfung auch fuer Vorlesesoftware", () => {
+    // "#42" allein ergibt vorgelesen keinen Sinn.
+    const html = markup(aufgabe({ sourceIssue: 42 }));
+    expect(html).toMatch(/sr-only[^>]*>Verkn/);
+  });
+});

src/components/tasks/TaskCard.tsx

@@ -1,6 +1,12 @@
 "use client";
 
-import { AlignLeft, CalendarClock, GripVertical, Repeat } from "lucide-react";
+import {
+  AlignLeft,
+  CalendarClock,
+  GitPullRequestArrow,
+  GripVertical,
+  Repeat,
+} from "lucide-react";
 import type { Task } from "@prisma/client";
 import { RECURRENCE_META } from "@/lib/tasks";
 import { cn, formatDate } from "@/lib/utils";
@@ -70,8 +76,26 @@ export function TaskCard({
             {task.title}
           </p>
 
-          {(task.description || task.dueDate || task.recurrence || task.labels.length > 0) && (
+          {(task.description ||
+            task.dueDate ||
+            task.recurrence ||
+            task.sourceIssue ||
+            task.labels.length > 0) && (
             <div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-[10px]">
+              {/* Steht vorn, damit sich eine Spalte danach ueberfliegen laesst.
+                  Bewusst kein Link: die Karte steckt in einem <button>, und ein
+                  <a> darin waere ungueltig. Der Weg zum Issue fuehrt ueber den
+                  Bearbeiten-Dialog, der ihn ohnehin anbietet. */}
+              {task.sourceIssue ? (
+                <span
+                  className="inline-flex items-center gap-1 text-violet-300"
+                  title={`Verknüpft mit Issue #${task.sourceIssue}`}
+                >
+                  <GitPullRequestArrow className="h-2.5 w-2.5" aria-hidden />
+                  <span className="sr-only">Verknüpft mit </span>#{task.sourceIssue}
+                </span>
+              ) : null}
+
               {task.description ? (
                 <AlignLeft className="h-2.5 w-2.5 text-slate-600" aria-label="hat Beschreibung" />
               ) : null}

src/components/tasks/TaskDialog.tsx

@@ -2,12 +2,33 @@
 
 import { useEffect, useState } from "react";
 import { useRouter } from "next/navigation";
-import { Loader2, Trash2 } from "lucide-react";
-import type { Recurrence, Task, TaskStatus } from "@prisma/client";
+import { ExternalLink, GitPullRequestArrow, Loader2, Trash2 } from "lucide-react";
+import type { Recurrence, TaskStatus } from "@prisma/client";
 import { Modal } from "@/components/ui/Modal";
 import { RECURRENCE_META, TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
 import { cn, parseTags } from "@/lib/utils";
 
+/**
+ * Was der Dialog von einer Aufgabe tatsaechlich liest.
+ *
+ * Bewusst nicht der vollstaendige Prisma-Datensatz: die Aufgabenuebersicht
+ * ueber alle Projekte reicht eine schlankere Fassung durch, in der das Datum
+ * als Zeichenkette ankommt – ein Date ueberlebt den Weg vom Server zum
+ * Browser nicht. Ein echtes Task erfuellt diese Form ebenfalls.
+ */
+export interface EditableTask {
+  id: string;
+  title: string;
+  description: string | null;
+  status: TaskStatus;
+  dueDate: Date | string | null;
+  labels: string[];
+  recurrence: Recurrence | null;
+  /** Gesetzt, sobald die Aufgabe an einem Git-Issue haengt. */
+  sourceIssue?: number | null;
+  sourceUrl?: string | null;
+}
+
 /** Datum fuer <input type="date"> – ortszeitbezogen, nicht UTC. */
 function toDateInput(value: Date | string | null): string {
   if (!value) return "";
@@ -26,7 +47,7 @@ export function TaskDialog({
 }: {
   open: boolean;
   projectId: string;
-  task: Task | null;
+  task: EditableTask | null;
   initialStatus: TaskStatus;
   onClose: () => void;
 }) {
@@ -38,10 +59,38 @@ export function TaskDialog({
   const [labels, setLabels] = useState("");
   const [recurrence, setRecurrence] = useState<string>("");
   const [busy, setBusy] = useState(false);
+  const [issueBusy, setIssueBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
   const isEdit = Boolean(task);
 
+  /**
+   * Legt zur Aufgabe ein Issue im verknuepften Repository an.
+   *
+   * Ausdruecklich per Knopf und nicht beim Speichern: was in ein fremdes
+   * System geschrieben wird, soll jemand gewollt haben.
+   */
+  async function createIssue() {
+    if (!task) return;
+    setIssueBusy(true);
+    setError(null);
+    try {
+      const response = await fetch(`/api/tasks/${task.id}/issue`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({}),
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(payload.error ?? "Issue konnte nicht angelegt werden.");
+      onClose();
+      router.refresh();
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setIssueBusy(false);
+    }
+  }
+
   useEffect(() => {
     if (!open) return;
     setTitle(task?.title ?? "");
@@ -231,6 +280,54 @@ export function TaskDialog({
           </p>
         ) : null}
 
+        {/* Verknuepfung mit einem Git-Issue. Nur beim Bearbeiten – zu einer
+            Aufgabe, die es noch nicht gibt, laesst sich keins anlegen. */}
+        {isEdit ? (
+          <div className="rounded-lg border border-white/8 bg-white/2 px-3 py-2.5">
+            {task?.sourceUrl || task?.sourceIssue ? (
+              <p className="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-slate-400">
+                <GitPullRequestArrow className="h-3.5 w-3.5 shrink-0 text-violet-300" />
+                Verknuepft mit
+                {task.sourceUrl ? (
+                  <a
+                    href={task.sourceUrl}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="inline-flex items-center gap-1 text-violet-300 underline-offset-2 hover:underline"
+                  >
+                    Issue #{task.sourceIssue}
+                    <ExternalLink className="h-3 w-3" />
+                  </a>
+                ) : (
+                  <span className="text-slate-300">Issue #{task.sourceIssue}</span>
+                )}
+                <span className="w-full text-[11px] text-slate-500">
+                  Erledigt schliesst das Issue, ein Zurueckziehen oeffnet es wieder.
+                </span>
+              </p>
+            ) : (
+              <div className="flex flex-wrap items-center justify-between gap-2">
+                <span className="text-xs text-slate-500">
+                  Noch nicht mit einem Issue verknuepft.
+                </span>
+                <button
+                  type="button"
+                  className="btn btn-ghost px-2.5 py-1.5 text-xs"
+                  onClick={createIssue}
+                  disabled={busy || issueBusy}
+                >
+                  {issueBusy ? (
+                    <Loader2 className="h-3.5 w-3.5 animate-spin" />
+                  ) : (
+                    <GitPullRequestArrow className="h-3.5 w-3.5" />
+                  )}
+                  Als Issue anlegen
+                </button>
+              </div>
+            )}
+          </div>
+        ) : null}
+
         <div className="flex items-center justify-between gap-2 pt-1">
           {isEdit ? (
             <button

src/components/tasks/TaskOverview.tsx

@@ -0,0 +1,443 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import {
+  CalendarClock,
+  CheckSquare,
+  ExternalLink,
+  Loader2,
+  Plus,
+  Repeat,
+  Search,
+  Square,
+  X,
+} from "lucide-react";
+import type { TaskStatus } from "@prisma/client";
+import { QuickCapture } from "@/components/QuickCapture";
+import { TaskDialog } from "@/components/tasks/TaskDialog";
+import {
+  DUE_BUCKET_META,
+  DUE_BUCKET_ORDER,
+  RECURRENCE_META,
+  TASK_STATUS_META,
+  TASK_STATUS_ORDER,
+} from "@/lib/tasks";
+import { cn, formatDate } from "@/lib/utils";
+import type { TaskOverviewItem } from "@/types";
+
+/** Wo Filter und Schalter im Browser liegen. */
+const ANSICHT_SCHLUESSEL = "nebula.tasks";
+
+/**
+ * Aufgaben ueber alle Projekte hinweg.
+ *
+ * Geordnet wird nach Faelligkeit, nicht nach Spalte: projektuebergreifend
+ * lautet die Frage "was ist ueberfaellig", nicht "was steht wo im Brett".
+ * Aus demselben Grund laesst sich hier bewusst **nichts ziehen** – die
+ * Position einer Aufgabe gilt innerhalb ihrer Spalte in ihrem Projekt und
+ * waere hier ohne Bedeutung. Eine Reihenfolge anzubieten, die nirgends
+ * ankommt, waere ein Versprechen, das die Seite nicht halten kann.
+ */
+export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
+  const router = useRouter();
+  const [statusFilter, setStatusFilter] = useState<TaskStatus[]>([]);
+  const [projektFilter, setProjektFilter] = useState("");
+  const [suche, setSuche] = useState("");
+  const [zeigeErledigte, setZeigeErledigte] = useState(false);
+  const [erfassenOffen, setErfassenOffen] = useState(false);
+  const [laufend, setLaufend] = useState<Set<string>>(new Set());
+  /** Welche Aufgabe gerade im Dialog liegt. null heisst: keiner offen. */
+  const [bearbeiten, setBearbeiten] = useState<TaskOverviewItem | null>(null);
+
+  const projekte = useMemo(() => {
+    const map = new Map<string, string>();
+    for (const task of tasks) map.set(task.project.id, task.project.name);
+    return [...map.entries()]
+      .map(([id, name]) => ({ id, name }))
+      .sort((a, b) => a.name.localeCompare(b.name, "de"));
+  }, [tasks]);
+
+  const zaehler = useMemo(() => {
+    const map = new Map<TaskStatus, number>();
+    for (const task of tasks) map.set(task.status, (map.get(task.status) ?? 0) + 1);
+    return map;
+  }, [tasks]);
+
+  const sichtbar = useMemo(() => {
+    const nadel = suche.toLowerCase().trim();
+
+    return tasks.filter((task) => {
+      // Erledigtes fuellt die Liste sonst mit dem, was gerade nicht ansteht.
+      // Wer allerdings sucht, sucht auch in Erledigtem – sonst findet man
+      // die Aufgabe von letzter Woche nicht wieder.
+      if (
+        !zeigeErledigte &&
+        !nadel &&
+        task.status === "DONE" &&
+        !statusFilter.includes("DONE")
+      ) {
+        return false;
+      }
+      if (statusFilter.length > 0 && !statusFilter.includes(task.status)) return false;
+      if (projektFilter && task.project.id !== projektFilter) return false;
+      if (!nadel) return true;
+
+      // Die Aufgaben liegen hier ohnehin alle vor – das filtert ohne
+      // zusaetzliche Abfrage und ohne Verzoegerung beim Tippen.
+      return (
+        task.title.toLowerCase().includes(nadel) ||
+        (task.description ?? "").toLowerCase().includes(nadel) ||
+        task.labels.some((label) => label.toLowerCase().includes(nadel)) ||
+        task.project.name.toLowerCase().includes(nadel)
+      );
+    });
+  }, [tasks, statusFilter, projektFilter, zeigeErledigte, suche]);
+
+  const faecher = useMemo(() => {
+    return DUE_BUCKET_ORDER.map((bucket) => ({
+      bucket,
+      items: sichtbar.filter((task) => task.bucket === bucket),
+    })).filter((fach) => fach.items.length > 0);
+  }, [sichtbar]);
+
+  const offen = sichtbar.filter((task) => task.status !== "DONE").length;
+  const ueberfaellig = sichtbar.filter(
+    (task) => task.bucket === "overdue" && task.status !== "DONE",
+  ).length;
+
+  function toggleStatus(status: TaskStatus) {
+    setStatusFilter((current) =>
+      current.includes(status)
+        ? current.filter((entry) => entry !== status)
+        : [...current, status],
+    );
+  }
+
+  /**
+   * Abhaken direkt aus der Uebersicht. Der Endpunkt erledigt dabei den Rest:
+   * doneAt, abgeleiteter Fortschritt und – bei wiederkehrenden Aufgaben –
+   * die naechste Fassung.
+   */
+  async function abhaken(task: TaskOverviewItem) {
+    const ziel: TaskStatus = task.status === "DONE" ? "TODO" : "DONE";
+    setLaufend((current) => new Set(current).add(task.id));
+    try {
+      const antwort = await fetch(`/api/tasks/${task.id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ status: ziel }),
+      });
+      if (!antwort.ok) throw new Error("fehlgeschlagen");
+      router.refresh();
+    } catch {
+      // Beim naechsten Laden steht wieder der echte Stand da.
+    } finally {
+      setLaufend((current) => {
+        const next = new Set(current);
+        next.delete(task.id);
+        return next;
+      });
+    }
+  }
+
+  return (
+    <div className="space-y-5">
+      <header className="fade-up flex flex-wrap items-end justify-between gap-3 pt-4">
+        <div>
+          <p className="text-[11px] font-semibold uppercase tracking-[0.3em] text-violet-300/70">
+            Über alle Projekte
+          </p>
+          <h1 className="mt-2 text-2xl font-semibold tracking-tight text-white sm:text-3xl">
+            Aufgaben
+          </h1>
+          <p className="mt-1.5 text-sm text-slate-400">
+            {offen} offen
+            {ueberfaellig > 0 ? (
+              <>
+                {" · "}
+                <span className="text-rose-300">{ueberfaellig} überfällig</span>
+              </>
+            ) : null}
+          </p>
+        </div>
+
+        <button
+          type="button"
+          className="btn btn-primary"
+          onClick={() => setErfassenOffen(true)}
+          aria-label="Neue Aufgabe"
+        >
+          <Plus className="h-4 w-4" />
+          <span className="hidden sm:inline">Neue Aufgabe</span>
+        </button>
+      </header>
+
+      {/* Steuerleiste */}
+      <div className="glass flex flex-col gap-3 p-3 sm:p-4">
+        <div className="relative">
+          <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-slate-500" />
+          <input
+            className="field pl-9"
+            placeholder="Aufgaben durchsuchen – Titel, Beschreibung, Labels…"
+            value={suche}
+            onChange={(event) => setSuche(event.target.value)}
+            aria-label="Aufgaben durchsuchen"
+          />
+          {suche ? (
+            <button
+              type="button"
+              onClick={() => setSuche("")}
+              className="absolute right-2 top-1/2 -translate-y-1/2 rounded p-1 text-slate-500 hover:text-white"
+              aria-label="Suche zuruecksetzen"
+            >
+              <X className="h-3.5 w-3.5" />
+            </button>
+          ) : null}
+        </div>
+
+        <div className="flex flex-wrap items-center gap-2">
+          {TASK_STATUS_ORDER.map((status) => {
+            const meta = TASK_STATUS_META[status];
+            const aktiv = statusFilter.includes(status);
+            return (
+              <button
+                key={status}
+                type="button"
+                onClick={() => toggleStatus(status)}
+                aria-pressed={aktiv}
+                className={cn(
+                  "inline-flex items-center gap-1.5 rounded-full px-2.5 py-1 text-xs ring-1 ring-inset transition-all",
+                  aktiv
+                    ? meta.className
+                    : "text-slate-400 ring-white/10 hover:bg-white/5 hover:text-slate-200",
+                )}
+              >
+                <span
+                  className="h-1.5 w-1.5 rounded-full"
+                  style={{ backgroundColor: meta.color, opacity: aktiv ? 1 : 0.55 }}
+                />
+                {meta.label}
+                <span className="tabular-nums text-slate-500">{zaehler.get(status) ?? 0}</span>
+              </button>
+            );
+          })}
+        </div>
+
+        <div className="flex flex-col gap-2 sm:flex-row sm:items-center">
+          <label className="sr-only" htmlFor="task-project-filter">
+            Projekt
+          </label>
+          <select
+            id="task-project-filter"
+            className="field w-auto min-w-0 sm:min-w-[14rem] sm:flex-none"
+            value={projektFilter}
+            onChange={(event) => setProjektFilter(event.target.value)}
+          >
+            <option value="">Alle Projekte</option>
+            {projekte.map((projekt) => (
+              <option key={projekt.id} value={projekt.id}>
+                {projekt.name}
+              </option>
+            ))}
+          </select>
+
+          <label className="flex cursor-pointer items-center gap-2 text-xs text-slate-500 sm:ml-auto">
+            <input
+              type="checkbox"
+              checked={zeigeErledigte}
+              onChange={(event) => setZeigeErledigte(event.target.checked)}
+              className="h-4 w-4 accent-violet-500"
+            />
+            Erledigte einblenden
+          </label>
+        </div>
+      </div>
+
+      {faecher.length === 0 ? (
+        <div className="glass fade-up flex flex-col items-center justify-center gap-4 px-6 py-16 text-center">
+          <span className="grid h-14 w-14 place-items-center rounded-2xl bg-gradient-to-br from-violet-500/25 to-cyan-400/20 text-violet-200">
+            <CheckSquare className="h-6 w-6" />
+          </span>
+          <div>
+            <h2 className="text-lg font-semibold text-white">
+              {tasks.length === 0
+                ? "Noch keine Aufgaben"
+                : suche.trim()
+                  ? "Keine Treffer"
+                  : "Nichts offen"}
+            </h2>
+            <p className="mt-1 max-w-md text-sm text-slate-400">
+              {tasks.length === 0
+                ? "Aufgaben entstehen im Projekt oder hier über „Neue Aufgabe“."
+                : suche.trim()
+                  ? `Keine Aufgabe passt zu „${suche.trim()}“ – gesucht wird in Titel, Beschreibung, Labels und Projektname.`
+                  : "Alles abgehakt, was zu den Filtern passt."}
+            </p>
+          </div>
+        </div>
+      ) : (
+        <div className="space-y-6">
+          {faecher.map((fach) => {
+            const meta = DUE_BUCKET_META[fach.bucket];
+            return (
+              <section key={fach.bucket}>
+                <div className="mb-2.5 flex items-center gap-2.5">
+                  <span
+                    className="accent-dot h-2 w-2 rounded-full"
+                    style={{ backgroundColor: meta.color, color: meta.color }}
+                  />
+                  <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-300">
+                    {meta.label}
+                  </h2>
+                  <span className="rounded-full bg-white/6 px-2 py-0.5 text-[11px] tabular-nums text-slate-400">
+                    {fach.items.length}
+                  </span>
+                  <span className="h-px flex-1 bg-gradient-to-r from-white/10 to-transparent" />
+                </div>
+
+                <ul className="glass divide-y divide-white/6 overflow-hidden">
+                  {fach.items.map((task) => (
+                    <TaskRow
+                      key={task.id}
+                      task={task}
+                      busy={laufend.has(task.id)}
+                      onToggle={() => abhaken(task)}
+                      onEdit={() => setBearbeiten(task)}
+                    />
+                  ))}
+                </ul>
+              </section>
+            );
+          })}
+        </div>
+      )}
+
+      <QuickCapture
+        open={erfassenOffen}
+        onClose={() => setErfassenOffen(false)}
+        initialMode="aufgabe"
+      />
+
+      {/* Derselbe Dialog wie im Projektbrett – er kennt seine Aufgabe ueber
+          die ID und braucht das Projekt nur zum Anlegen. */}
+      {bearbeiten ? (
+        <TaskDialog
+          open
+          projectId={bearbeiten.project.id}
+          task={bearbeiten}
+          initialStatus={bearbeiten.status}
+          onClose={() => setBearbeiten(null)}
+        />
+      ) : null}
+    </div>
+  );
+}
+
+function TaskRow({
+  task,
+  busy,
+  onToggle,
+  onEdit,
+}: {
+  task: TaskOverviewItem;
+  busy: boolean;
+  onToggle: () => void;
+  onEdit: () => void;
+}) {
+  const meta = TASK_STATUS_META[task.status];
+  const erledigt = task.status === "DONE";
+
+  return (
+    <li className="flex items-center gap-2.5 px-3 py-2.5 transition-colors hover:bg-white/4 sm:gap-3 sm:px-4">
+      <button
+        type="button"
+        onClick={onToggle}
+        disabled={busy}
+        aria-label={erledigt ? `„${task.title}“ wieder öffnen` : `„${task.title}“ abhaken`}
+        className="shrink-0 rounded-lg p-1.5 text-slate-500 transition-colors hover:text-emerald-300 disabled:opacity-50"
+      >
+        {busy ? (
+          <Loader2 className="h-4 w-4 animate-spin" />
+        ) : erledigt ? (
+          <CheckSquare className="h-4 w-4 text-emerald-300" />
+        ) : (
+          <Square className="h-4 w-4" />
+        )}
+      </button>
+
+      <div className="min-w-0 flex-1">
+        <div className="flex items-center gap-1.5">
+          {/* Der Titel oeffnet den Bearbeiten-Dialog. Frueher fuehrte von
+              hier nur der Weg ins Projekt – wer eine Faelligkeit aendern
+              wollte, musste erst dorthin springen und die Aufgabe im Brett
+              wiederfinden. */}
+          <button
+            type="button"
+            onClick={onEdit}
+            className={cn(
+              "truncate text-left text-sm transition-colors hover:text-violet-200",
+              erledigt ? "text-slate-500 line-through" : "text-slate-100",
+            )}
+            title="Aufgabe bearbeiten"
+          >
+            {task.title}
+          </button>
+          {task.recurrence ? (
+            <Repeat
+              className="h-3 w-3 shrink-0 text-slate-500"
+              aria-label={RECURRENCE_META[task.recurrence].label}
+            />
+          ) : null}
+          {task.sourceUrl ? (
+            <a
+              href={task.sourceUrl}
+              target="_blank"
+              rel="noopener noreferrer"
+              className="shrink-0 text-slate-500 transition-colors hover:text-violet-300"
+              aria-label="Zugehöriges Issue öffnen"
+            >
+              <ExternalLink className="h-3 w-3" />
+            </a>
+          ) : null}
+        </div>
+
+        <div className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-[11px] text-slate-500">
+          {/* Das Projekt gehoert in jede Zeile – ohne es ist eine
+              projektuebergreifende Liste nicht zu lesen. */}
+          <Link
+            href={`/projects/${task.project.id}`}
+            className="max-w-[10rem] truncate text-slate-400 underline-offset-2 hover:text-violet-300 hover:underline"
+          >
+            {task.project.name}
+          </Link>
+
+          <span
+            className={cn("inline-flex items-center gap-1 rounded-full px-1.5 ring-1 ring-inset", meta.className)}
+          >
+            {meta.label}
+          </span>
+
+          {task.dueDate ? (
+            <span
+              className={cn(
+                "inline-flex shrink-0 items-center gap-1",
+                task.bucket === "overdue" && !erledigt && "text-rose-300",
+              )}
+            >
+              <CalendarClock className="h-3 w-3" />
+              {formatDate(task.dueDate)}
+            </span>
+          ) : null}
+
+          {task.labels.slice(0, 2).map((label) => (
+            <span key={label} className="hidden rounded bg-white/5 px-1.5 text-slate-400 xs:inline">
+              #{label}
+            </span>
+          ))}
+        </div>
+      </div>
+    </li>
+  );
+}

src/components/ui/Modal.tsx

@@ -33,9 +33,45 @@ export function Modal({
   width = "lg",
 }: ModalProps) {
   const [mounted, setMounted] = useState(false);
+  const [sichtfenster, setSichtfenster] = useState<{ height: number; top: number } | null>(null);
 
   useEffect(() => setMounted(true), []);
 
+  /**
+   * Der Dialog richtet sich nach dem *sichtbaren* Fenster, nicht nach dem
+   * Layoutfenster.
+   *
+   * Auf dem Telefon schiebt sich die Tastatur ueber die untere Haelfte,
+   * ohne dass sich daran etwas fuer die Seite aendert: "position: fixed"
+   * und "100vh" beziehen sich weiter auf das volle Fenster. Ein zentrierter
+   * Dialog liegt damit zur Haelfte unter der Tastatur – genau dort, wo das
+   * Eingabefeld ist.
+   *
+   * Die VisualViewport-API meldet, was wirklich zu sehen ist. Hoehe und
+   * oberer Rand daraus zu setzen rueckt den Dialog in den freien Bereich,
+   * und weil der Behaelter scrollbar ist, holt der Browser das fokussierte
+   * Feld von selbst ins Bild.
+   */
+  useEffect(() => {
+    if (!open) return;
+    const fenster = window.visualViewport;
+    if (!fenster) return;
+
+    const nachfuehren = () => {
+      setSichtfenster({ height: fenster.height, top: fenster.offsetTop });
+    };
+    nachfuehren();
+
+    fenster.addEventListener("resize", nachfuehren);
+    // Beim Scrollen mit offener Tastatur wandert der sichtbare Ausschnitt.
+    fenster.addEventListener("scroll", nachfuehren);
+    return () => {
+      fenster.removeEventListener("resize", nachfuehren);
+      fenster.removeEventListener("scroll", nachfuehren);
+      setSichtfenster(null);
+    };
+  }, [open]);
+
   useEffect(() => {
     if (!open) return;
     const onKey = (event: KeyboardEvent) => {
@@ -53,7 +89,14 @@ export function Modal({
   if (!mounted || !open) return null;
 
   return createPortal(
-    <div className="fixed inset-0 z-[120] flex items-start justify-center overflow-y-auto p-4 sm:p-8">
+    <div
+      className="fixed inset-x-0 z-[120] flex items-start justify-center overflow-y-auto p-3 sm:p-8"
+      style={
+        sichtfenster
+          ? { top: sichtfenster.top, height: sichtfenster.height }
+          : { top: 0, bottom: 0 }
+      }
+    >
       <button
         type="button"
         aria-label="Dialog schliessen"
@@ -65,7 +108,7 @@ export function Modal({
         aria-modal="true"
         aria-label={title}
         className={cn(
-          "popover fade-up relative z-10 my-auto w-full rounded-2xl p-6",
+          "popover fade-up relative z-10 my-auto w-full rounded-2xl p-4 sm:p-6",
           width === "md" && "max-w-lg",
           width === "lg" && "max-w-2xl",
           width === "xl" && "max-w-4xl",

src/components/ui/Popover.tsx

@@ -44,7 +44,11 @@ export function Popover({
 }) {
   const panelRef = useRef<HTMLDivElement>(null);
   const [mounted, setMounted] = useState(false);
-  const [position, setPosition] = useState<{ top: number; left: number } | null>(null);
+  const [position, setPosition] = useState<{
+    top: number;
+    left: number;
+    width: number;
+  } | null>(null);
 
   useEffect(() => setMounted(true), []);
 
@@ -56,14 +60,19 @@ export function Popover({
     const margin = 8;
     const gap = 6;
 
+    // Passt die Wunschbreite nicht ins Fenster, gilt das Fenster. Sonst
+    // liefert die Klemmung unten eine negative linke Kante und das Menue
+    // stuende zur Haelfte ausserhalb des Bildschirms.
+    const effektiv = Math.min(width, window.innerWidth - 2 * margin);
+
     // Bevorzugte Ausrichtung, bei Ueberlauf auf die andere Seite wechseln.
     // Nur Festklemmen am Fensterrand waere schlecht: bei einem Ausloeser weit
     // links stuende das Menue sonst quer ueber der Seite statt an seinem
     // Ausloeser.
-    let left = align === "end" ? rect.right - width : rect.left;
+    let left = align === "end" ? rect.right - effektiv : rect.left;
     if (left < margin) left = rect.left;
-    if (left + width > window.innerWidth - margin) left = rect.right - width;
-    left = Math.min(Math.max(margin, left), window.innerWidth - width - margin);
+    if (left + effektiv > window.innerWidth - margin) left = rect.right - effektiv;
+    left = Math.min(Math.max(margin, left), window.innerWidth - effektiv - margin);
 
     const panelHeight = panelRef.current?.offsetHeight ?? 0;
     let top = rect.bottom + gap;
@@ -73,7 +82,7 @@ export function Popover({
     const fitsAbove = rect.top - gap - panelHeight >= margin;
     if (!fitsBelow && fitsAbove) top = rect.top - gap - panelHeight;
 
-    setPosition({ top, left });
+    setPosition({ top, left, width: effektiv });
   }, [anchorRef, align, width]);
 
   // Bewusst useEffect statt useLayoutEffect: Letzteres warnt beim
@@ -127,7 +136,7 @@ export function Popover({
         position: "fixed",
         top: position?.top ?? -9999,
         left: position?.left ?? -9999,
-        width,
+        width: position?.width ?? width,
         // Bis die Position steht, unsichtbar halten – sonst blitzt das
         // Menue kurz an der falschen Stelle auf.
         visibility: position ? "visible" : "hidden",

src/lib/auth/mfa.ts

@@ -46,7 +46,7 @@ export function setMfaCookie(response: NextResponse, token: string) {
     name: MFA_COOKIE,
     value: token,
     httpOnly: true,
-    sameSite: "lax",
+    sameSite: "strict",
     secure: COOKIES_SECURE,
     path: "/",
     maxAge: Math.floor(MFA_TTL_MS / 1000),
@@ -58,7 +58,7 @@ export function clearMfaCookie(response: NextResponse) {
     name: MFA_COOKIE,
     value: "",
     httpOnly: true,
-    sameSite: "lax",
+    sameSite: "strict",
     secure: COOKIES_SECURE,
     path: "/",
     maxAge: 0,

src/lib/auth/password.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { PASSWORD_MIN_LENGTH } from "./constants";
-import { hashPassword, validatePasswordStrength, verifyPassword } from "./password";
+import { hashPassword, needsRehash, validatePasswordStrength, verifyPassword } from "./password";
 
 describe("hashPassword und verifyPassword", () => {
   it("erkennt das richtige Passwort wieder", async () => {
@@ -64,3 +64,82 @@ describe("validatePasswordStrength", () => {
     expect(validatePasswordStrength("a".repeat(300))).toMatch(/hoechstens/);
   });
 });
+
+describe("Aufwand nach OWASP", () => {
+  it("hasht mit den heute vorgesehenen Parametern", async () => {
+    // OWASP Password Storage Cheat Sheet: N = 2^17, r = 8, p = 1.
+    const hash = await hashPassword("ein-langes-testpasswort");
+    const [, N, r, p] = hash.split("$");
+    expect(Number(N)).toBe(131072);
+    expect(Number(r)).toBe(8);
+    expect(Number(p)).toBe(1);
+  });
+
+  it("prueft alte Hashes weiterhin, weil die Parameter im Hash stehen", async () => {
+    // Von Hand mit den frueheren Werten erzeugt – muss gueltig bleiben,
+    // sonst waere ein Anheben des Aufwands eine Aussperrung.
+    const alt =
+      "scrypt$32768$8$1$" +
+      Buffer.from("salzsalzsalzsalz").toString("base64url") +
+      "$";
+    // Echten Hash mit alten Parametern bauen:
+    const { scrypt } = await import("node:crypto");
+    const { promisify } = await import("node:util");
+    const s = promisify(scrypt) as (a: string, b: Buffer, c: number, d: object) => Promise<Buffer>;
+    const salt = Buffer.from("salzsalzsalzsalz");
+    const derived = await s("ein-langes-testpasswort", salt, 64, {
+      N: 32768,
+      r: 8,
+      p: 1,
+      maxmem: 96 * 1024 * 1024,
+    });
+    const alterHash = `scrypt$32768$8$1$${salt.toString("base64url")}$${derived.toString("base64url")}`;
+    expect(alt.length).toBeGreaterThan(0);
+
+    await expect(verifyPassword("ein-langes-testpasswort", alterHash)).resolves.toBe(true);
+    // ... und wird als erneuerungsbeduerftig erkannt.
+    expect(needsRehash(alterHash)).toBe(true);
+  });
+
+  it("laesst frische Hashes in Ruhe", async () => {
+    expect(needsRehash(await hashPassword("ein-langes-testpasswort"))).toBe(false);
+  });
+
+  it("erkennt gleichwertige Kombinationen als ausreichend", () => {
+    // N=2^16 mit p=2 ergibt denselben Gesamtaufwand wie N=2^17 mit p=1 und
+    // ist nach OWASP ebenso zulaessig.
+    expect(needsRehash("scrypt$65536$8$2$c2FsdA$aGFzaA")).toBe(false);
+    // N=2^15 mit p=1 dagegen nicht – das war der alte Zustand.
+    expect(needsRehash("scrypt$32768$8$1$c2FsdA$aGFzaA")).toBe(true);
+  });
+
+  it("haelt Unsinn fuer erneuerungsbeduerftig", () => {
+    expect(needsRehash("voelliger-unsinn")).toBe(true);
+    expect(needsRehash(null)).toBe(false);
+  });
+});
+
+describe("Schwache Muster", () => {
+  it("weist Wiederholungen ab", () => {
+    expect(validatePasswordStrength("aaaaaaaaaaaa")).toBeTruthy();
+    expect(validatePasswordStrength("abababababab")).toBeTruthy();
+  });
+
+  it("weist Zeichenfolgen ab", () => {
+    expect(validatePasswordStrength("abcdefghijkl")).toBeTruthy();
+    expect(validatePasswordStrength("87654321abcd")).toBeTruthy();
+  });
+
+  it("weist Passwoerter mit dem Benutzernamen ab", () => {
+    expect(validatePasswordStrength("chefin-geheimnis", "chefin")).toMatch(/Benutzernamen/);
+    // Ohne Benutzernamen ist dasselbe Passwort in Ordnung.
+    expect(validatePasswordStrength("chefin-geheimnis")).toBeNull();
+    // Sehr kurze Namen zaehlen nicht – sonst scheitert fast alles.
+    expect(validatePasswordStrength("ab-langes-passwort", "ab")).toBeNull();
+  });
+
+  it("laesst ein gutes Passwort mit Wiederholung durch", () => {
+    // Ein "ll" ist kein Grund zur Ablehnung, solange genug Vielfalt da ist.
+    expect(validatePasswordStrength("Rollladen-Fenster-42")).toBeNull();
+  });
+});

src/lib/auth/password.ts

@@ -17,11 +17,24 @@ const scrypt = promisify(scryptCallback) as (
   options: { N: number; r: number; p: number; maxmem: number },
 ) => Promise<Buffer>;
 
-const PARAMS = { N: 32768, r: 8, p: 1 };
+/**
+ * Arbeitsaufwand nach der Empfehlung des OWASP Password Storage Cheat Sheet:
+ * N = 2^17, r = 8, p = 1. Frueher stand hier N = 2^15 mit p = 1 – das liegt
+ * unter *jeder* der dort genannten zulaessigen Kombinationen (zu 2^15
+ * gehoerte p = 3) und war damit rund dreimal billiger zu knacken als
+ * vorgesehen.
+ *
+ * Gemessen kostet das rund 0,5 s je Pruefung und 128 MiB. Der Speicher
+ * klingt nach viel, ist aber gedeckelt: Node rechnet scrypt im
+ * libuv-Threadpool, standardmaessig vier Faeden parallel. Mehr als rund
+ * 512 MiB koennen also nicht gleichzeitig belegt sein, und davor liegen
+ * noch die Ratenbegrenzungen je IP und je Benutzername.
+ */
+const PARAMS = { N: 131072, r: 8, p: 1 };
 const KEY_LENGTH = 64;
-// scrypt braucht rund 128 * N * r Bytes; der Standardwert von 32 MB reicht
-// dafuer nicht ganz.
-const MAX_MEM = 96 * 1024 * 1024;
+// scrypt braucht rund 128 * N * r Bytes – bei diesen Werten 128 MiB.
+// Etwas Luft nach oben, damit die Pruefung nicht am Deckel scheitert.
+const MAX_MEM = 192 * 1024 * 1024;
 
 export async function hashPassword(password: string): Promise<string> {
   const salt = randomBytes(16);
@@ -72,6 +85,30 @@ export async function verifyPassword(
   return timingSafeEqual(derived, expected);
 }
 
+/**
+ * Ist der gespeicherte Hash mit schwaecheren Parametern erzeugt worden als
+ * heute ueblich?
+ *
+ * Der Aufwand laesst sich nur fuer neue Passwoerter anheben – bestehende
+ * Hashes bleiben sonst fuer immer auf dem alten Stand. OWASP empfiehlt
+ * deshalb, bei der naechsten erfolgreichen Anmeldung still neu zu hashen.
+ * Das geht nur dort, weil das Klartextpasswort ausschliesslich in diesem
+ * Moment vorliegt.
+ */
+export function needsRehash(stored: string | null | undefined): boolean {
+  if (!stored) return false;
+
+  const parts = stored.split("$");
+  if (parts.length !== 6 || parts[0] !== "scrypt") return true;
+
+  const [N, r, p] = [Number(parts[1]), Number(parts[2]), Number(parts[3])];
+  if (!Number.isFinite(N) || !Number.isFinite(r) || !Number.isFinite(p)) return true;
+
+  // Verglichen wird der Gesamtaufwand, nicht Feld fuer Feld: N=2^16 mit p=2
+  // ist nach OWASP genauso zulaessig wie N=2^17 mit p=1.
+  return N * r * p < PARAMS.N * PARAMS.r * PARAMS.p;
+}
+
 /**
  * Verbrennt vergleichbar viel Zeit wie eine echte Pruefung. Wird aufgerufen,
  * wenn es den Benutzernamen gar nicht gibt – sonst liesse sich an der
@@ -84,27 +121,102 @@ export async function fakeVerifyDelay(): Promise<void> {
   });
 }
 
+/**
+ * Naheliegende Passwoerter.
+ *
+ * ASVS 2.1.7 verlangt einen Abgleich gegen bekannte geleakte Passwoerter.
+ * Ein Dienst wie Have-I-Been-Pwned schiede dafuer aus – Nebula ruft
+ * grundsaetzlich nichts von aussen, und ein Passwort-Praefix nach draussen
+ * zu geben widerspraeche dem erst recht. Diese Liste ist der Kompromiss:
+ * die haeufigsten deutschen und englischen Kandidaten, dazu weiter unten
+ * Muster statt Einzelwoerter, was mehr abdeckt als jede Liste dieser Groesse.
+ */
 const OBVIOUS = new Set([
-  "password", "passwort", "12345678", "123456789", "1234567890",
-  "qwertzuiop", "qwertyuiop", "administrator", "changeme", "letmein",
-  "willkommen", "nebula123", "geheim123",
+  // Klassiker
+  "password", "password1", "password123", "passwort", "passwort1",
+  "passwort123", "kennwort", "geheim", "geheim123", "changeme", "letmein",
+  "welcome", "willkommen", "willkommen1", "administrator", "admin1234",
+  "iloveyou", "sunshine", "princess", "dragon", "monkey", "football",
+  "baseball", "superman", "trustno1", "starwars", "whatever", "freedom",
+  // Zahlen und Tastaturlaeufe
+  "12345678", "123456789", "1234567890", "87654321", "11111111",
+  "qwertzuiop", "qwertyuiop", "asdfghjkl", "qwertz123", "qwerty123",
+  "1qay2wsx", "1q2w3e4r", "1q2w3e4r5t", "asdf1234", "qwer1234",
+  // Deutsch
+  "sommer2024", "sommer2025", "sommer2026", "winter2024", "winter2025",
+  "winter2026", "fussball", "deutschland", "hallowelt", "sonnenschein",
+  "schatz123", "liebling", "blumen123", "internet", "computer",
+  // Projektnah
+  "nebula", "nebula123", "nebula2026", "dashboard", "vibecoding",
 ]);
 
 export { PASSWORD_MIN_LENGTH };
 
-/** Gibt eine Fehlermeldung zurueck oder null, wenn das Passwort taugt. */
-export function validatePasswordStrength(password: string): string | null {
+/**
+ * Laenge der laengsten auf- oder absteigenden Zeichenfolge ("abcd", "4321").
+ *
+ * Zurueckgegeben wird die Laenge und nicht nur ein Ja/Nein: entscheidend ist,
+ * *wie viel* des Passworts aus der Folge besteht. Ein "de" mitten in einem
+ * Wort ist harmlos, "abcdefghijkl" ist das ganze Passwort.
+ */
+function laengsteFolge(wert: string): number {
+  if (wert.length < 2) return wert.length;
+  let beste = 1;
+  let auf = 1;
+  let ab = 1;
+  for (let i = 1; i < wert.length; i += 1) {
+    const schritt = wert.charCodeAt(i) - wert.charCodeAt(i - 1);
+    auf = schritt === 1 ? auf + 1 : 1;
+    ab = schritt === -1 ? ab + 1 : 1;
+    beste = Math.max(beste, auf, ab);
+  }
+  return beste;
+}
+
+/**
+ * Gibt eine Fehlermeldung zurueck oder null, wenn das Passwort taugt.
+ *
+ * Bewusst **keine** Zusammensetzungsregeln ("mindestens ein Sonderzeichen").
+ * ASVS 2.1.9 raet ausdruecklich davon ab: sie treiben Leute zu "Passwort1!"
+ * und senken die Entropie, statt sie zu heben. Geprueft wird stattdessen
+ * auf Laenge und auf das, was nachweislich schwach ist.
+ */
+export function validatePasswordStrength(
+  password: string,
+  /** Benutzername des Kontos, falls bekannt – er darf nicht im Passwort stehen. */
+  username?: string | null,
+): string | null {
   if (password.length < PASSWORD_MIN_LENGTH) {
     return `Das Passwort muss mindestens ${PASSWORD_MIN_LENGTH} Zeichen haben.`;
   }
   if (password.length > 200) {
     return "Das Passwort darf hoechstens 200 Zeichen haben.";
   }
-  if (OBVIOUS.has(password.toLowerCase())) {
+
+  const klein = password.toLowerCase();
+
+  if (OBVIOUS.has(klein)) {
     return "Dieses Passwort ist zu naheliegend.";
   }
   if (/^\d+$/.test(password)) {
     return "Nur Ziffern reichen nicht – bitte Buchstaben oder Zeichen ergaenzen.";
   }
+  // Zu wenig verschiedene Zeichen – deckt "aaaaaaaa" ebenso ab wie
+  // "abababab" oder "12121212", ohne dafuer je ein eigenes Muster zu
+  // brauchen.
+  if (new Set(klein).size <= 4) {
+    return "Das Passwort benutzt zu wenige verschiedene Zeichen.";
+  }
+  // Und wenn der groesste Teil des Passworts eine durchlaufende Folge ist.
+  if (laengsteFolge(klein) >= Math.max(6, Math.ceil(password.length * 0.6))) {
+    return "Zeichenfolgen wie „abcd“ oder „4321“ sind zu leicht zu raten.";
+  }
+  // Ein Passwort, das den Benutzernamen enthaelt, ist der erste Versuch
+  // jedes Angreifers.
+  const name = username?.trim().toLowerCase();
+  if (name && name.length >= 3 && klein.includes(name)) {
+    return "Das Passwort darf den Benutzernamen nicht enthalten.";
+  }
+
   return null;
 }

src/lib/auth/session.ts

@@ -2,7 +2,12 @@ import { createHash, randomBytes } from "node:crypto";
 import { cookies } from "next/headers";
 import type { NextResponse } from "next/server";
 import type { User } from "@prisma/client";
-import { COOKIES_SECURE, SESSION_COOKIE, SESSION_TTL_MS } from "@/lib/config";
+import {
+  COOKIES_SECURE,
+  SESSION_COOKIE,
+  SESSION_IDLE_MS,
+  SESSION_TTL_MS,
+} from "@/lib/config";
 import { prisma } from "@/lib/db";
 
 /**
@@ -68,7 +73,10 @@ export function setSessionCookie(response: NextResponse, token: string, expiresA
     name: SESSION_COOKIE,
     value: token,
     httpOnly: true,
-    sameSite: "lax",
+    // Strict statt Lax: Nebula hat keinen Einstieg von aussen, den eine
+    // fremde Seite anstossen duerfte. Der Preis ist, dass ein Klick von
+    // einer anderen Seite auf die Anmeldung fuehrt – ein Neuladen genuegt.
+    sameSite: "strict",
     secure: COOKIES_SECURE,
     path: "/",
     expires: expiresAt,
@@ -80,7 +88,10 @@ export function clearSessionCookie(response: NextResponse) {
     name: SESSION_COOKIE,
     value: "",
     httpOnly: true,
-    sameSite: "lax",
+    // Strict statt Lax: Nebula hat keinen Einstieg von aussen, den eine
+    // fremde Seite anstossen duerfte. Der Preis ist, dass ein Klick von
+    // einer anderen Seite auf die Anmeldung fuehrt – ein Neuladen genuegt.
+    sameSite: "strict",
     secure: COOKIES_SECURE,
     path: "/",
     maxAge: 0,
@@ -109,11 +120,27 @@ export async function getSessionUser(): Promise<SessionUser | null> {
     return null;
   }
 
+  // Leerlaufgrenze. Vorher wurde lastSeenAt zwar gefuehrt, aber nie
+  // ausgewertet – ein abgegriffener Cookie galt damit bis zum absoluten
+  // Ablauf, auch wenn das Konto wochenlang unberuehrt war.
+  const untaetig = Date.now() - session.lastSeenAt.getTime();
+  if (SESSION_IDLE_MS > 0 && untaetig > SESSION_IDLE_MS) {
+    await prisma.session.delete({ where: { id: session.id } }).catch(() => undefined);
+    return null;
+  }
+
   if (!session.user.isActive) return null;
 
-  // Hoechstens einmal pro Stunde schreiben, damit nicht jede Anfrage die
-  // Datenbank anfasst.
-  if (Date.now() - session.lastSeenAt.getTime() > 60 * 60 * 1000) {
+  /**
+   * lastSeenAt nachfuehren, aber nicht bei jeder Anfrage schreiben.
+   *
+   * Das Intervall muss deutlich unter der Leerlaufgrenze liegen, sonst
+   * verkuerzt die Schreibbremse sie: bei stuendlichem Schreiben und einer
+   * Grenze von einer Stunde waere die Sitzung schon nach Sekunden faellig.
+   * Ein Zwanzigstel der Frist, hoechstens fuenf Minuten.
+   */
+  const intervall = SESSION_IDLE_MS > 0 ? Math.min(SESSION_IDLE_MS / 20, 5 * 60 * 1000) : 60 * 60 * 1000;
+  if (untaetig > intervall) {
     void prisma.session
       .update({ where: { id: session.id }, data: { lastSeenAt: new Date() } })
       .catch(() => undefined);

src/lib/changelog.ts

@@ -41,6 +41,222 @@ export const KIND_META: Record<ChangeKind, { label: string; className: string }>
 };
 
 export const CHANGELOG: Release[] = [
+  {
+    version: "1.10.1",
+    date: "2026-08-18",
+    headline: "Sichtbar, welche Aufgabe ein Issue hat — und nachlesbar, was ein Token dafür braucht.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Auf dem Aufgabenbrett eines Projekts trägt eine Karte die Nummer ihres " +
+          "verknüpften Git-Issues. Bisher stand die Verknüpfung nur im Bearbeiten-Dialog " +
+          "und in der projektübergreifenden Übersicht — welche Aufgabe schon ein Issue " +
+          "hat, war im Vorbeigehen nicht zu sehen.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Rechte einer Git-Verbindung stehen jetzt Aufruf für Aufruf in der README: " +
+          "je System eine Tabelle aus Endpunkt, Zweck und benötigtem Recht. Getrennt nach " +
+          "reinem Abgleich und zusätzlicher Issue-Anbindung, damit erkennbar ist, was sich " +
+          "weglassen lässt. Bei GitLab ist belegt, dass es unterhalb von „api“ keinen " +
+          "Schreibzugriff auf Issues gibt.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Der Hinweis unter dem Token-Feld nannte die Rechte für Actions nicht, obwohl " +
+          "der CI-Zustand bei GitHub genau daran hängt. Wer sich daran hielt, sah keinen " +
+          "Build-Status.",
+      },
+    ],
+  },
+  {
+    version: "1.10.0",
+    date: "2026-08-18",
+    headline: "Rückblick, Zeitleiste und eine Suche, die auch Aufgaben findet.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Wochenrückblick über alle Projekte: Kennzahlen der Woche und darunter die " +
+          "Vorgänge nach Tagen gebündelt. Blättern in frühere Wochen inbegriffen. " +
+          "Erreichbar über die Schnellsuche und einen Verweis vom Dashboard.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Globale Zeitleiste: derselbe Verlauf, aber fortlaufend und ohne Wochengrenze, " +
+          "mit Nachladen älterer Einträge. Geblättert wird per Cursor — bei mehreren " +
+          "Einträgen im selben Augenblick verliert oder verdoppelt das keine Zeilen.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Das Aufgabendashboard hat ein Suchfeld über Titel, Beschreibung, Labels und " +
+          "Projektname. Wer sucht, sucht dabei auch in Erledigtem — sonst findet man die " +
+          "Aufgabe von letzter Woche nicht wieder.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Volltextsuche kannte bisher nur Notizen und findet jetzt auch Aufgaben — " +
+          "mit denselben deutschen Stammformen: „Rechnung“ findet „Rechnungen“. Treffer " +
+          "erscheinen im Projektbrett und in der Schnellsuche.",
+      },
+    ],
+  },
+  {
+    version: "1.9.0",
+    date: "2026-08-17",
+    headline: "Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Der Abgleich prüft jetzt den Zustand verknüpfter Issues: was in Git geschlossen " +
+          "wurde, wird in Nebula abgehakt. Bisher konnte das nur der Webhook — war keiner " +
+          "eingerichtet, blieb der Rückweg ganz aus.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Ein über Git geschlossenes Issue bewirkt jetzt dasselbe wie ein Haken in der " +
+          "Oberfläche: bei wiederkehrenden Aufgaben entsteht die nächste Fassung, und der " +
+          "Vorgang steht im Projektverlauf.",
+      },
+    ],
+  },
+  {
+    version: "1.8.0",
+    date: "2026-08-15",
+    headline: "Durchgang durch Anmeldung und Sitzungen nach OWASP.",
+    changes: [
+      {
+        kind: "besser",
+        text:
+          "Passwörter werden deutlich aufwendiger gehasht (scrypt mit N=2^17 statt 2^15) — " +
+          "das entspricht der Empfehlung des OWASP Password Storage Cheat Sheet. Bestehende " +
+          "Passwörter werden bei der nächsten Anmeldung still auf den neuen Stand gebracht.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Die Anmeldung verriet, welche Benutzernamen existieren: gesperrte, deaktivierte " +
+          "und reine Passkey-Konten antworteten anders als unbekannte — und das schon vor " +
+          "der Passwortprüfung. Jetzt gibt es die Auskunft erst, wenn das Passwort stimmt.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Sitzungen laufen nach acht Stunden ohne Nutzung ab, zusätzlich zur bestehenden " +
+          "Frist von 30 Tagen. Einstellbar über SESSION_IDLE_HOURS; 0 schaltet es ab.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Das Sitzungscookie trägt bei HTTPS den Präfix „__Host-“ und gilt nur noch " +
+          "SameSite=Strict. Beides muss einmalig neu angemeldet werden.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Passwortprüfung erkennt jetzt Wiederholungen, Zeichenfolgen und Passwörter, " +
+          "die den eigenen Benutzernamen enthalten.",
+      },
+    ],
+  },
+  {
+    version: "1.7.0",
+    date: "2026-08-15",
+    headline: "Aufgaben und Git-Issues finden zusammen.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Eine Aufgabe lässt sich als Issue im verknüpften Repository anlegen — per Knopf, " +
+          "nie nebenbei. Danach wandert der Zustand mit: erledigt schließt das Issue, ein " +
+          "Zurückziehen öffnet es wieder.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Webhooks. Ein Push aktualisiert den Stand sofort, statt bis zum nächsten " +
+          "Abgleich zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Einzurichten " +
+          "am Repository — URL und Geheimnis stehen dort bereit.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Auf dem Telefon verdeckte die Bildschirmtastatur den halben Dialog, weil er mit " +
+          "der vollen Fensterhöhe rechnete. Dialoge richten sich jetzt nach dem sichtbaren " +
+          "Bereich und rücken über die Tastatur.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Aufgaben lassen sich in der Übersicht direkt bearbeiten. Bisher führte von dort " +
+          "nur der Weg ins Projekt.",
+      },
+    ],
+  },
+  {
+    version: "1.6.0",
+    date: "2026-08-14",
+    headline: "Unterwegs erfassen — und eine Oberfläche, die aufs Telefon passt.",
+    changes: [
+      {
+        kind: "behoben",
+        text:
+          "Auf dem Telefon war das Dashboard breiter als der Bildschirm: die Steuerleiste " +
+          "konnte nicht umbrechen und schob den Knopf „Neues Projekt“ aus dem Bild. " +
+          "Dasselbe im Projektkopf, wo „Löschen“ außerhalb lag. Beide Zeilen brechen " +
+          "jetzt um.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Schnellerfassung: ein Blitzsymbol in der Kopfleiste, auf jeder Seite " +
+          "erreichbar. Ein Feld, Enter, fertig — als Idee entsteht ein Projekt, als " +
+          "Aufgabe eine Aufgabe im gewählten Projekt. Der Dialog bleibt danach offen, " +
+          "weil auf eine Idee meist gleich die nächste folgt.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Eine Aufgabenseite über alle Projekte hinweg, geordnet nach Fälligkeit: " +
+          "überfällig, heute, diese Woche, später, ohne Termin. Abhaken geht direkt " +
+          "aus der Liste.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Vierte Ansicht im Dashboard: eine kompakte Liste. Auf dem Telefon passen " +
+          "damit fünf Projekte auf einen Bildschirm statt auf vier.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Eingabefelder sind auf Berührungsgeräten 16 Pixel groß — darunter zoomt " +
+          "iOS Safari beim Hineintippen die Seite heran und kehrt nicht von selbst " +
+          "zurück. Knöpfe und der Fortschrittsregler sind mit dem Finger zu treffen.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Die Verweise in der Kopfleiste und „Neues Projekt“ sind auf schmalen " +
+          "Anzeigen reine Symbole und hießen für einen Screenreader gar nichts. " +
+          "Jetzt tragen sie eine Beschriftung.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Das Tag-Formular der Auswahlleiste war breiter als sein Menü und wurde " +
+          "beschnitten — auf jeder Bildschirmbreite.",
+      },
+    ],
+  },
   {
     version: "1.5.0",
     date: "2026-07-27",

src/lib/config.ts

@@ -73,18 +73,47 @@ export const WEBAUTHN_AVAILABLE =
 /** Cookies nur ueber TLS ausliefern, wenn die App per https laeuft. */
 export const COOKIES_SECURE = APP_URL_PARSED.protocol === "https:";
 
-/** Lebensdauer einer Sitzung. */
+/**
+ * Absolute Lebensdauer einer Sitzung – ab Anmeldung, nicht verlaengerbar.
+ * Nach dieser Frist ist Schluss, egal wie aktiv jemand war.
+ */
 export const SESSION_TTL_DAYS = Number(process.env.SESSION_TTL_DAYS ?? 30);
 export const SESSION_TTL_MS = SESSION_TTL_DAYS * 24 * 60 * 60 * 1000;
 
-export const SESSION_COOKIE = "nebula_session";
+/**
+ * Leerlauffrist: so lange darf eine Sitzung unbenutzt bleiben.
+ *
+ * ASVS 3.3.2 verlangt beides – eine absolute *und* eine Leerlaufgrenze.
+ * Vorher gab es nur die absolute, ein abgegriffener Cookie galt also bis zu
+ * 30 Tage, unabhaengig davon, ob das Konto benutzt wurde.
+ *
+ * Acht Stunden sind der Kompromiss: ein Arbeitstag am Stueck bleibt
+ * angemeldet, ueber Nacht laeuft die Sitzung ab. Wem das zu streng ist,
+ * setzt SESSION_IDLE_HOURS hoch; 0 schaltet die Leerlaufgrenze ab.
+ */
+export const SESSION_IDLE_HOURS = Number(process.env.SESSION_IDLE_HOURS ?? 8);
+export const SESSION_IDLE_MS =
+  SESSION_IDLE_HOURS > 0 ? SESSION_IDLE_HOURS * 60 * 60 * 1000 : 0;
+
+/**
+ * Name des Sitzungscookies.
+ *
+ * Mit dem Praefix "__Host-" erzwingt der Browser selbst, was wir ohnehin
+ * setzen: Secure, Pfad "/" und kein Domain-Attribut. Letzteres ist der
+ * eigentliche Gewinn – eine andere Subdomain kann den Cookie dann nicht
+ * ueberschreiben und damit keine Sitzung unterschieben.
+ *
+ * Nur bei https, denn der Praefix verlangt zwingend Secure; ohne TLS wuerde
+ * der Browser den Cookie schlicht verwerfen.
+ */
+export const SESSION_COOKIE = COOKIES_SECURE ? "__Host-nebula_session" : "nebula_session";
 
 /**
  * Cookie fuer die halbfertige Anmeldung zwischen Passwort und zweitem Faktor.
  * Kurzlebig – wer den Code nicht binnen fuenf Minuten eingibt, faengt von
  * vorne an.
  */
-export const MFA_COOKIE = "nebula_mfa";
+export const MFA_COOKIE = COOKIES_SECURE ? "__Host-nebula_mfa" : "nebula_mfa";
 export const MFA_TTL_MS = 5 * 60 * 1000;
 
 /** Wird beim Start einmal geloggt, damit Fehlkonfiguration frueh auffaellt. */

src/lib/git/gitea.ts

@@ -1,4 +1,4 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
 import {
   CALENDAR_PAGE_SIZE,
   calendarByPaging,
@@ -12,6 +12,7 @@ import type {
   CiState,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -44,6 +45,41 @@ export class GiteaClient implements GitClient {
     return headers;
   }
 
+  private repoBase(ref: RepoRef): string {
+    return `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+  }
+
+  async createIssue(
+    ref: RepoRef,
+    issue: { title: string; body?: string | null },
+  ): Promise<CreatedIssue> {
+    const angelegt = await sendJson<{ number: number; html_url?: string }>(
+      `${this.repoBase(ref)}/issues`,
+      "POST",
+      { title: issue.title, body: issue.body ?? "" },
+      { headers: this.headers() },
+    );
+    return { number: angelegt.number, url: angelegt.html_url ?? null };
+  }
+
+  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+    await sendJson(
+      `${this.repoBase(ref)}/issues/${number}`,
+      "PATCH",
+      { state: open ? "open" : "closed" },
+      { headers: this.headers() },
+    );
+  }
+
+  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+    const issue = await getJson<{ state?: string } | null>(
+      `${this.repoBase(ref)}/issues/${number}`,
+      { headers: this.headers(), allow404: true },
+    );
+    if (!issue?.state) return null;
+    return issue.state === "closed" ? "closed" : "open";
+  }
+
   async check(): Promise<ConnectionCheck> {
     try {
       const version = await getJsonSafe<{ version?: string }>(

src/lib/git/github.ts

@@ -1,4 +1,4 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
 import type {
   BranchInfo,
   CiInfo,
@@ -6,6 +6,7 @@ import type {
   CommitCalendar,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -43,6 +44,41 @@ export class GitHubClient implements GitClient {
     return headers;
   }
 
+  private repoBase(ref: RepoRef): string {
+    return `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+  }
+
+  async createIssue(
+    ref: RepoRef,
+    issue: { title: string; body?: string | null },
+  ): Promise<CreatedIssue> {
+    const angelegt = await sendJson<{ number: number; html_url?: string }>(
+      `${this.repoBase(ref)}/issues`,
+      "POST",
+      { title: issue.title, body: issue.body ?? "" },
+      { headers: this.headers() },
+    );
+    return { number: angelegt.number, url: angelegt.html_url ?? null };
+  }
+
+  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+    await sendJson(
+      `${this.repoBase(ref)}/issues/${number}`,
+      "PATCH",
+      { state: open ? "open" : "closed" },
+      { headers: this.headers() },
+    );
+  }
+
+  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+    const issue = await getJson<{ state?: string } | null>(
+      `${this.repoBase(ref)}/issues/${number}`,
+      { headers: this.headers(), allow404: true },
+    );
+    if (!issue?.state) return null;
+    return issue.state === "closed" ? "closed" : "open";
+  }
+
   async check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {

src/lib/git/gitlab.ts

@@ -1,4 +1,4 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
 import {
   CALENDAR_PAGE_SIZE,
   calendarByPaging,
@@ -12,6 +12,7 @@ import type {
   CiState,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -45,6 +46,40 @@ export class GitLabClient implements GitClient {
     return headers;
   }
 
+  async createIssue(
+    ref: RepoRef,
+    issue: { title: string; body?: string | null },
+  ): Promise<CreatedIssue> {
+    // GitLab nennt es "iid" – die projektinterne Nummer, die auch in der
+    // Oberflaeche steht. "id" waere die instanzweite und damit die falsche.
+    const angelegt = await sendJson<{ iid: number; web_url?: string }>(
+      `${this.apiBase}/projects/${this.projectPath(ref)}/issues`,
+      "POST",
+      { title: issue.title, description: issue.body ?? "" },
+      { headers: this.headers() },
+    );
+    return { number: angelegt.iid, url: angelegt.web_url ?? null };
+  }
+
+  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+    await sendJson(
+      `${this.apiBase}/projects/${this.projectPath(ref)}/issues/${number}`,
+      "PUT",
+      { state_event: open ? "reopen" : "close" },
+      { headers: this.headers() },
+    );
+  }
+
+  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+    const issue = await getJson<{ state?: string } | null>(
+      `${this.apiBase}/projects/${this.projectPath(ref)}/issues/${number}`,
+      { headers: this.headers(), allow404: true },
+    );
+    if (!issue?.state) return null;
+    // GitLab nennt den offenen Zustand "opened".
+    return issue.state === "closed" ? "closed" : "open";
+  }
+
   async check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {

src/lib/git/http.ts

@@ -98,6 +98,83 @@ export async function getJson<T>(
   }
 }
 
+/**
+ * Schreibender Aufruf – POST, PATCH oder PUT.
+ *
+ * Bewusst dieselbe Schleuse wie getJson: die Basis-URL stammt aus einem
+ * Formular, und ohne die Pruefung waere ein schreibender Aufruf der weitaus
+ * unangenehmere Weg nach innen. Redirects werden hier **nicht** verfolgt.
+ * Ein 307 auf eine interne Adresse wuerde den Rumpf mitnehmen, und der
+ * enthaelt bei uns immer den Token im Header – lieber ein Fehler als eine
+ * Anfrage, die woanders landet.
+ */
+export async function sendJson<T>(
+  url: string,
+  method: "POST" | "PATCH" | "PUT",
+  body: unknown,
+  options: FetchOptions = {},
+): Promise<T> {
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    options.timeoutMs ?? DEFAULT_TIMEOUT,
+  );
+
+  try {
+    await assertAllowedUrl(url);
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "Nebula-Dashboard",
+        ...options.headers,
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+      cache: "no-store",
+      redirect: "manual",
+    });
+
+    // Bei redirect: "manual" kommt der Umleitungsstatus durch, statt dass
+    // fetch ihm folgt. Das ist hier gewollt und ein Fehlerfall.
+    if (response.status >= 300 && response.status < 400) {
+      throw new GitApiError(
+        "Das Git-System hat umgeleitet. Schreibende Aufrufe folgen dem nicht – " +
+          "bitte die Basis-URL der Verbindung auf die endgueltige Adresse setzen.",
+        response.status,
+        url,
+      );
+    }
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new GitApiError(friendlyMessage(response.status, url, text), response.status, url);
+    }
+
+    const text = await response.text();
+    if (!text) return null as T;
+    return JSON.parse(text) as T;
+  } catch (error) {
+    if (error instanceof GitApiError) throw error;
+    if (error instanceof BlockedHostError) {
+      throw new GitApiError(error.message, 403, url);
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new GitApiError(
+        `Zeitueberschreitung nach ${options.timeoutMs ?? DEFAULT_TIMEOUT} ms`,
+        408,
+        url,
+      );
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new GitApiError(`Verbindung fehlgeschlagen: ${reason}`, 0, url);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 /** Wie getJson, gibt aber bei jedem Fehler den Fallback zurueck. */
 export async function getJsonSafe<T>(
   url: string,

src/lib/git/meta.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { PROVIDER_META, guessProvider } from "./meta";
+
+const PROVIDER = ["GITHUB", "GITLAB", "GITEA"] as const;
+
+describe("PROVIDER_META", () => {
+  it("kennt jedes unterstuetzte System", () => {
+    for (const provider of PROVIDER) {
+      expect(PROVIDER_META[provider], provider).toBeDefined();
+    }
+    // Und nichts darueber hinaus – ein Eintrag ohne Gegenstueck im Schema
+    // waere ein Ueberbleibsel.
+    expect(Object.keys(PROVIDER_META).sort()).toEqual([...PROVIDER].sort());
+  });
+
+  it("hat zu jedem System Beschriftung, Basis-URL und Dokuverweis", () => {
+    for (const provider of PROVIDER) {
+      const meta = PROVIDER_META[provider];
+      expect(meta.label.length, provider).toBeGreaterThan(0);
+      expect(meta.defaultBaseUrl, provider).toMatch(/^https:\/\//);
+      expect(meta.docsUrl, provider).toMatch(/^https:\/\//);
+    }
+  });
+
+  /**
+   * Der eigentliche Waechter.
+   *
+   * Der Hinweis am Eingabefeld war eine Zeit lang rein lesend formuliert,
+   * obwohl Nebula seit v1.7.0 Issues anlegt und schliesst – wer sich daran
+   * hielt, bekam einen 403. Jeder Provider in GitClient muss createIssue und
+   * setIssueState koennen; folglich muss auch jeder Hinweis sagen, was das
+   * an Rechten kostet.
+   */
+  it("sagt bei jedem System etwas ueber die Rechte fuer Issues", () => {
+    for (const provider of PROVIDER) {
+      expect(PROVIDER_META[provider].tokenHelp, provider).toMatch(/issue/i);
+    }
+  });
+
+  it("nennt einen konkreten Scope statt nur 'Leserechte'", () => {
+    // GitLab nennt Scopes in Anfuehrungszeichen, GitHub und Gitea
+    // Berechtigungsnamen – gemeinsam ist, dass etwas Nachschlagbares dasteht.
+    expect(PROVIDER_META.GITLAB.tokenHelp).toMatch(/read_api/);
+    expect(PROVIDER_META.GITEA.tokenHelp).toMatch(/read:repository/);
+    expect(PROVIDER_META.GITHUB.tokenHelp).toMatch(/Metadata/);
+  });
+});
+
+describe("guessProvider", () => {
+  it("erkennt die oeffentlichen Instanzen am Hostnamen", () => {
+    expect(guessProvider("github.com")).toBe("GITHUB");
+    expect(guessProvider("gitlab.com")).toBe("GITLAB");
+  });
+
+  it("faellt bei allem anderen auf Gitea zurueck", () => {
+    // Selbst gehostet ist hier der haeufigste Fall, und Gitea die
+    // wahrscheinlichste Wahl dafuer.
+    expect(guessProvider("git.wilde-server.de")).toBe("GITEA");
+  });
+});

src/lib/git/meta.ts

@@ -12,19 +12,25 @@ export const PROVIDER_META: Record<
     label: "GitHub",
     defaultBaseUrl: "https://github.com",
     tokenHelp:
-      "Fine-grained Token mit Lesezugriff auf Contents, Metadata, Issues und Pull Requests.",
+      "Fine-grained Token, alle nur lesend: Metadata, Contents, Issues, Pull requests " +
+      "und Actions. Nur wenn Aufgaben als Issue angelegt werden sollen, Issues " +
+      "zusaetzlich schreiben.",
     docsUrl: "https://github.com/settings/tokens",
   },
   GITLAB: {
     label: "GitLab",
     defaultBaseUrl: "https://gitlab.com",
-    tokenHelp: "Personal Access Token mit Scope 'read_api' (bzw. 'read_repository').",
+    tokenHelp:
+      "Scope 'read_api' genuegt fuer den Abgleich. Aufgaben als Issue anzulegen verlangt " +
+      "'api' – GitLab kennt keinen schmaleren Schreibzugriff.",
     docsUrl: "https://gitlab.com/-/user_settings/personal_access_tokens",
   },
   GITEA: {
     label: "Gitea / Forgejo",
     defaultBaseUrl: "https://git.example.com",
-    tokenHelp: "Access Token mit Leserechten auf repository, issue und user.",
+    tokenHelp:
+      "read:repository, read:issue und read:user. Nur wenn Aufgaben als Issue angelegt " +
+      "werden sollen, zusaetzlich write:issue.",
     docsUrl: "https://docs.gitea.com/development/api-usage",
   },
 };

src/lib/git/schreibzugriffe.test.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Waechter ueber eine Zusage in der Dokumentation.
+ *
+ * README und FEATURES sagen zu, dass Nebula an genau zwei Stellen nach
+ * draussen schreibt: ein Issue anlegen und seinen Zustand umsetzen. Auf
+ * dieser Zusage steht die Empfehlung, ein rein lesendes Token zu vergeben,
+ * solange die Issue-Anbindung nicht gebraucht wird.
+ *
+ * Kaeme ein dritter Schreibaufruf dazu, wuerde die Empfehlung still falsch:
+ * niemand bekaeme einen Fehler, nur ein 403 an einer Stelle, die laut
+ * Dokumentation gar nicht schreibt. Deshalb wird hier der Quelltext selbst
+ * abgeklopft – sendJson ist der einzige Weg aus lib/git heraus, der eine
+ * andere Methode als GET benutzt (siehe http.ts).
+ */
+const CLIENTS = ["gitea.ts", "github.ts", "gitlab.ts"] as const;
+
+/** Die Zeile ueber dem Methoden-Argument nennt den Endpunkt. */
+function schreibaufrufe(quelltext: string): string[] {
+  const zeilen = quelltext.split("\n");
+  const gefunden: string[] = [];
+  zeilen.forEach((zeile, i) => {
+    if (!/\bsendJson[<(]/.test(zeile)) return;
+    // sendJson(url, METHODE, …) – Endpunkt und Methode stehen darunter.
+    const block = zeilen.slice(i, i + 4).join(" ");
+    const methode = block.match(/"(POST|PATCH|PUT)"/)?.[1];
+    const pfad = block.match(/\/issues[^`"']*/)?.[0] ?? "?";
+    gefunden.push(`${methode ?? "?"} ${pfad}`);
+  });
+  return gefunden;
+}
+
+describe("Schreibzugriffe nach draussen", () => {
+  it("beschraenken sich auf Issues anlegen und Zustand setzen", () => {
+    for (const datei of CLIENTS) {
+      const quelltext = readFileSync(join(__dirname, datei), "utf8");
+      const aufrufe = schreibaufrufe(quelltext);
+
+      expect(aufrufe.length, `${datei}: Anzahl Schreibaufrufe`).toBe(2);
+      for (const aufruf of aufrufe) {
+        expect(aufruf, `${datei}: ${aufruf}`).toMatch(/^(POST|PATCH|PUT) \/issues/);
+      }
+      // Genau einer legt an, genau einer setzt um.
+      expect(aufrufe.filter((a) => a.startsWith("POST")).length, datei).toBe(1);
+      expect(aufrufe.filter((a) => /^(PATCH|PUT)/.test(a)).length, datei).toBe(1);
+    }
+  });
+
+  it("laufen ueber sendJson, nicht an http.ts vorbei", () => {
+    // Ein direkter fetch in einem Client haette weder SSRF-Schutz noch
+    // Zeitbegrenzung – und wuerde am Waechter oben vorbeilaufen.
+    for (const datei of CLIENTS) {
+      const quelltext = readFileSync(join(__dirname, datei), "utf8");
+      expect(quelltext, datei).not.toMatch(/\bfetch\s*\(/);
+    }
+  });
+});

src/lib/git/types.ts

@@ -167,10 +167,40 @@ export interface ProviderConfig {
   token: string | null;
 }
 
+/** Ein neu angelegtes Issue, so weit wir es zurueckschreiben. */
+export interface CreatedIssue {
+  number: number;
+  url: string | null;
+}
+
 export interface GitClient {
   readonly provider: ProviderKind;
   /** Prueft Erreichbarkeit und Token-Gueltigkeit. */
   check(): Promise<ConnectionCheck>;
+  /**
+   * Legt ein Issue an und liefert Nummer und Adresse zurueck.
+   *
+   * Der einzige schreibende Aufruf in dieser Schnittstelle. Er wird nie
+   * nebenbei ausgeloest, sondern immer von Hand angestossen – was nach
+   * aussen geht, soll jemand gewollt haben.
+   */
+  createIssue(ref: RepoRef, issue: { title: string; body?: string | null }): Promise<CreatedIssue>;
+  /**
+   * Schliesst ein Issue. Beim Zurueckziehen einer Aufgabe wird es wieder
+   * geoeffnet – daher der Schalter statt zweier Methoden.
+   */
+  setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void>;
+  /**
+   * Liest den Zustand eines einzelnen Issues.
+   *
+   * Gebraucht fuer den Abgleich: der Snapshot fuehrt nur die *offenen*
+   * Issues und ist ausserdem gedeckelt – aus dem Fehlen einer Nummer laesst
+   * sich deshalb nicht schliessen, dass sie geschlossen wurde. Sie koennte
+   * ebenso geloescht oder einfach jenseits des Deckels sein.
+   *
+   * null heisst: gibt es nicht (mehr).
+   */
+  getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null>;
   /** Repos, auf die der Token Zugriff hat (fuer die Auswahl beim Verknuepfen). */
   listRepos(query?: string): Promise<RepoListItem[]>;
   /** Vollstaendiger Stand eines Repositories. */

src/lib/projects.ts

@@ -65,17 +65,66 @@ export const connectionSafeSelect = Prisma.validator<Prisma.GitConnectionSelect>
   updatedAt: true,
 });
 
+/**
+ * Felder eines Repositories, die nach aussen duerfen.
+ *
+ * Ausdruecklich als Liste und nicht als "include": ein include liefert jedes
+ * Skalarfeld mit, auch neu hinzugekommene. Das Webhook-Geheimnis waere so
+ * still in jede Projektantwort und in jede Seite gewandert – verschluesselt
+ * zwar, aber nach aussen gehoert es trotzdem nicht. Dieselbe Ueberlegung wie
+ * bei connectionSafeSelect.
+ *
+ * Ob ein Webhook eingerichtet ist, sagt webhookLastAt nicht zuverlaessig
+ * (frisch eingerichtet ist es null). Diese Angabe holt die Projektseite
+ * deshalb getrennt – siehe webhookRepositoryIds.
+ */
+export const repositorySafeSelect = Prisma.validator<Prisma.RepositorySelect>()({
+  id: true,
+  projectId: true,
+  label: true,
+  repoUrl: true,
+  repoOwner: true,
+  repoName: true,
+  defaultBranch: true,
+  connectionId: true,
+  position: true,
+  lastSyncedAt: true,
+  syncError: true,
+  autoSync: true,
+  syncFailureCount: true,
+  notifiedSyncError: true,
+  notifiedCiState: true,
+  notifiedRelease: true,
+  webhookLastAt: true,
+  createdAt: true,
+  updatedAt: true,
+  connection: { select: connectionSafeSelect },
+  snapshot: true,
+});
+
 /**
  * Ein Repository mitsamt Verbindung und Stand. Die Reihenfolge ist ueberall
  * dieselbe: das fuehrende zuerst, denn auf der Karte ist nur fuer eines Platz.
  */
 export const repositoryInclude = Prisma.validator<Prisma.ProjectInclude>()({
   repositories: {
-    include: { connection: { select: connectionSafeSelect }, snapshot: true },
+    select: repositorySafeSelect,
     orderBy: [{ position: "asc" }, { createdAt: "asc" }],
   },
 });
 
+/**
+ * IDs der Repositories eines Projekts, fuer die ein Webhook hinterlegt ist.
+ * Getrennt geholt, damit das Geheimnis selbst nirgends mitgereicht wird.
+ */
+export async function webhookRepositoryIds(projectId: string): Promise<string[]> {
+  const treffer = await prisma.repository.findMany({
+    where: { projectId, webhookSecret: { not: null } },
+    select: { id: true },
+  });
+  return treffer.map((eintrag) => eintrag.id);
+}
+
 export const projectListInclude = Prisma.validator<Prisma.ProjectInclude>()({
   ...repositoryInclude,
   _count: { select: { notes: true, tasks: true } },

src/lib/review.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+import {
+  berlinMitternacht,
+  tagesschluessel,
+  wocheUm,
+  wochenName,
+  wochenTitel,
+  zaehleWoche,
+} from "./review";
+
+describe("tagesschluessel", () => {
+  it("rechnet in Berliner Kalendertagen, nicht in UTC", () => {
+    // 22:30 UTC ist in Berlin schon der Folgetag (Sommerzeit, UTC+2).
+    expect(tagesschluessel(new Date("2026-08-17T22:30:00Z"))).toBe("2026-08-18");
+    expect(tagesschluessel(new Date("2026-08-17T21:00:00Z"))).toBe("2026-08-17");
+  });
+});
+
+describe("berlinMitternacht", () => {
+  it("trifft den Sommerzeit-Beginn des Tages", () => {
+    // Sommerzeit: Berlin = UTC+2, Mitternacht dort ist 22:00 UTC am Vortag.
+    expect(berlinMitternacht("2026-08-17").toISOString()).toBe("2026-08-16T22:00:00.000Z");
+  });
+
+  it("trifft den Winterzeit-Beginn des Tages", () => {
+    // Winterzeit: UTC+1.
+    expect(berlinMitternacht("2026-01-12").toISOString()).toBe("2026-01-11T23:00:00.000Z");
+  });
+});
+
+describe("wocheUm", () => {
+  /** Ein Dienstag. */
+  const DIENSTAG = new Date("2026-08-18T09:00:00Z");
+
+  it("beginnt am Montag und endet am folgenden Montag", () => {
+    const woche = wocheUm(DIENSTAG);
+    expect(woche.tage[0]).toBe("2026-08-17");
+    expect(woche.tage[6]).toBe("2026-08-23");
+    expect(woche.tage).toHaveLength(7);
+    expect(woche.von.toISOString()).toBe("2026-08-16T22:00:00.000Z");
+    expect(woche.bis.toISOString()).toBe("2026-08-23T22:00:00.000Z");
+  });
+
+  it("zaehlt den Montag selbst zur laufenden Woche", () => {
+    const montag = new Date("2026-08-17T06:00:00Z");
+    expect(wocheUm(montag).tage[0]).toBe("2026-08-17");
+  });
+
+  it("zaehlt den Sonntagabend noch zur ablaufenden Woche", () => {
+    // 21:00 UTC am Sonntag ist in Berlin 23:00 – noch derselbe Tag.
+    const sonntagAbend = new Date("2026-08-23T21:00:00Z");
+    expect(wocheUm(sonntagAbend).tage[0]).toBe("2026-08-17");
+    // Zwei Stunden spaeter ist Montag und damit die naechste Woche.
+    const montagFrueh = new Date("2026-08-23T22:30:00Z");
+    expect(wocheUm(montagFrueh).tage[0]).toBe("2026-08-24");
+  });
+
+  it("blättert rückwärts", () => {
+    expect(wocheUm(DIENSTAG, -1).tage[0]).toBe("2026-08-10");
+    expect(wocheUm(DIENSTAG, -3).tage[0]).toBe("2026-07-27");
+  });
+
+  it("kommt über den Monats- und Jahreswechsel", () => {
+    const neujahr = new Date("2027-01-01T12:00:00Z"); // ein Freitag
+    const woche = wocheUm(neujahr);
+    expect(woche.tage[0]).toBe("2026-12-28");
+    expect(woche.tage[6]).toBe("2027-01-03");
+  });
+
+  it("bleibt über die Zeitumstellung hinweg sieben Tage lang", () => {
+    // Am 25.10.2026 wird auf Winterzeit zurueckgestellt – die Woche hat
+    // dann 169 Stunden. "von + 7 Tage" waere hier eine Stunde daneben.
+    const inDerWoche = new Date("2026-10-21T12:00:00Z");
+    const woche = wocheUm(inDerWoche);
+    expect(woche.tage[0]).toBe("2026-10-19");
+    expect(woche.tage[6]).toBe("2026-10-25");
+    const stunden = (woche.bis.getTime() - woche.von.getTime()) / 3_600_000;
+    expect(stunden).toBe(169);
+  });
+
+  it("liefert bei der Umstellung im Fruehjahr 167 Stunden", () => {
+    // Vorgestellt wird am letzten Sonntag im Maerz – 2026 ist das der 29.,
+    // er liegt also in der Woche ab Montag, dem 23.
+    const inDerWoche = new Date("2026-03-25T12:00:00Z");
+    const woche = wocheUm(inDerWoche);
+    expect(woche.tage[0]).toBe("2026-03-23");
+    expect(woche.tage[6]).toBe("2026-03-29");
+    const stunden = (woche.bis.getTime() - woche.von.getTime()) / 3_600_000;
+    expect(stunden).toBe(167);
+  });
+
+  it("hat in einer Woche ohne Umstellung genau 168 Stunden", () => {
+    const woche = wocheUm(new Date("2026-03-31T12:00:00Z"));
+    expect(woche.tage[0]).toBe("2026-03-30");
+    expect((woche.bis.getTime() - woche.von.getTime()) / 3_600_000).toBe(168);
+  });
+});
+
+describe("Beschriftung", () => {
+  const DIENSTAG = new Date("2026-08-18T09:00:00Z");
+
+  it("nennt die laufende und die vorige Woche beim Namen", () => {
+    expect(wochenName(wocheUm(DIENSTAG))).toBe("Diese Woche");
+    expect(wochenName(wocheUm(DIENSTAG, -1))).toBe("Vorige Woche");
+  });
+
+  it("nennt weiter zurueckliegende Wochen mit Zeitraum", () => {
+    expect(wochenName(wocheUm(DIENSTAG, -2))).toMatch(/\d/);
+  });
+
+  it("nennt den Monat nur einmal, wenn die Woche nicht darueber hinausgeht", () => {
+    expect(wochenTitel(wocheUm(DIENSTAG))).toBe("17.–23. August 2026");
+  });
+
+  it("nennt beide Monate, wenn die Woche sie ueberspannt", () => {
+    // 31.08. bis 06.09.2026.
+    const woche = wocheUm(new Date("2026-09-02T12:00:00Z"));
+    expect(wochenTitel(woche)).toBe("31. August–6. September 2026");
+  });
+});
+
+describe("zaehleWoche", () => {
+  const eintrag = (
+    kind: Parameters<typeof zaehleWoche>[0][number]["kind"],
+    projectId: string,
+    meta?: unknown,
+  ) => ({ kind, projectId, meta });
+
+  it("zaehlt Erledigtes am meta-Feld, nicht am Text", () => {
+    const zahlen = zaehleWoche([
+      eintrag("TASK_MOVED", "p1", { from: "TODO", to: "DONE" }),
+      // Verschoben, aber nicht erledigt – darf nicht mitzaehlen.
+      eintrag("TASK_MOVED", "p1", { from: "TODO", to: "DOING" }),
+    ]);
+    expect(zahlen.erledigt).toBe(1);
+  });
+
+  it("zaehlt einen Eintrag ohne meta nicht als erledigt", () => {
+    // Aeltere Eintraege koennen kein "to" haben. Lieber untertreiben als
+    // eine Zahl behaupten, die aus dem Anzeigetext geraten waere.
+    expect(zaehleWoche([eintrag("TASK_MOVED", "p1")]).erledigt).toBe(0);
+    expect(zaehleWoche([eintrag("TASK_MOVED", "p1", "unsinn")]).erledigt).toBe(0);
+  });
+
+  it("zaehlt neue Aufgaben aus beiden Quellen", () => {
+    const zahlen = zaehleWoche([
+      eintrag("TASK_ADDED", "p1"),
+      eintrag("TASKS_IMPORTED", "p2"),
+    ]);
+    expect(zahlen.neueAufgaben).toBe(2);
+  });
+
+  it("zaehlt beruehrte Projekte ohne Dubletten", () => {
+    const zahlen = zaehleWoche([
+      eintrag("NOTE_ADDED", "p1"),
+      eintrag("NOTE_ADDED", "p1"),
+      eintrag("REPO_COMMITS", "p2"),
+    ]);
+    expect(zahlen.projekte).toBe(2);
+    expect(zahlen.notizen).toBe(2);
+    expect(zahlen.gesamt).toBe(3);
+  });
+
+  it("kommt mit einer leeren Woche zurecht", () => {
+    expect(zaehleWoche([])).toEqual({
+      gesamt: 0,
+      projekte: 0,
+      erledigt: 0,
+      neueAufgaben: 0,
+      notizen: 0,
+    });
+  });
+});

src/lib/review.ts

@@ -0,0 +1,203 @@
+import type { ActivityKind } from "@prisma/client";
+
+/**
+ * Wochenrueckblick: welche Woche, und was zaehlt darin.
+ *
+ * Die Wochenrechnung steht hier als reine Funktion und nicht in der Seite –
+ * Wochengrenzen sind der Teil, der still falsch wird, und so laesst er sich
+ * pruefen.
+ */
+
+/** Wochenbeginn ist Montag, wie in Deutschland ueblich (ISO 8601). */
+export const WOCHENBEGINN = 1;
+
+/**
+ * Kalendertag in fester Zeitzone.
+ *
+ * Dieselbe Ueberlegung wie bei den Faelligkeiten in lib/tasks: im Container
+ * laeuft die Anwendung nach UTC. Um 23:30 Berliner Zeit waere dort noch der
+ * Vortag, und ein Eintrag von Sonntagabend fiele in die falsche Woche.
+ */
+const TAG_FORMAT = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Europe/Berlin",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+});
+
+/** "2026-08-17" in Berliner Zeit. */
+export function tagesschluessel(wert: Date): string {
+  return TAG_FORMAT.format(wert);
+}
+
+/** Wochentag in Berliner Zeit, 0 = Sonntag. */
+function wochentag(wert: Date): number {
+  const [jahr, monat, tag] = tagesschluessel(wert).split("-").map(Number);
+  return new Date(Date.UTC(jahr, monat - 1, tag)).getUTCDay();
+}
+
+export interface Woche {
+  /** Beginn des Montags, als Zeitpunkt fuer die Abfrage. */
+  von: Date;
+  /** Beginn des folgenden Montags – ausschliesslich. */
+  bis: Date;
+  /** 0 = laufende Woche, -1 = vorige, … */
+  versatz: number;
+  /** Die sieben Kalendertage der Woche, Montag zuerst. */
+  tage: string[];
+}
+
+/**
+ * Grenzen der Woche, in der `jetzt` liegt – um `versatz` Wochen verschoben.
+ *
+ * Gerechnet wird ueber die Kalendertage in Berliner Zeit und dann in UTC
+ * zurueckgerechnet. Der Umweg ist noetig, weil zwischen zwei Montagen eine
+ * Zeitumstellung liegen kann: "sieben mal 24 Stunden" waere dann um eine
+ * Stunde daneben.
+ */
+export function wocheUm(jetzt: Date, versatz = 0): Woche {
+  const [jahr, monat, tag] = tagesschluessel(jetzt).split("-").map(Number);
+  const heuteUtc = Date.UTC(jahr, monat - 1, tag);
+
+  // Rueckwaerts bis zum Montag.
+  const abstandZumMontag = (wochentag(jetzt) - WOCHENBEGINN + 7) % 7;
+  const montag = new Date(heuteUtc - (abstandZumMontag - versatz * 7) * 86_400_000);
+
+  const tage: string[] = [];
+  for (let i = 0; i < 7; i += 1) {
+    tage.push(new Date(montag.getTime() + i * 86_400_000).toISOString().slice(0, 10));
+  }
+
+  const von = berlinMitternacht(tage[0]);
+  return {
+    von,
+    // Ende ist die Mitternacht *nach* dem Sonntag – nicht "von + 7 Tage":
+    // liegt eine Zeitumstellung dazwischen, ist die Woche 167 oder 169
+    // Stunden lang.
+    bis: berlinMitternacht(naechsterTag(tage[6])),
+    versatz,
+    tage,
+  };
+}
+
+/** Ein Kalendertag weiter, rein auf der Zeichenkette gerechnet. */
+function naechsterTag(tag: string): string {
+  const [j, m, t] = tag.split("-").map(Number);
+  return new Date(Date.UTC(j, m - 1, t) + 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * Um wie viel geht die Berliner Uhr zu diesem Zeitpunkt der UTC voraus?
+ *
+ * Ermittelt statt fest verdrahtet, weil zwischen Sommer- und Winterzeit eine
+ * Stunde Unterschied liegt und ein Rueckblick ueber die Umstellung hinweg
+ * sonst um eine Stunde verrutscht.
+ */
+function zonenversatzMs(zeitpunkt: Date): number {
+  // sv-SE liefert "2026-08-17 14:30:00" – nah genug an ISO, um es nach dem
+  // Austausch des Leerzeichens wieder einlesen zu koennen.
+  const berlin = new Intl.DateTimeFormat("sv-SE", {
+    timeZone: "Europe/Berlin",
+    dateStyle: "short",
+    timeStyle: "medium",
+  }).format(zeitpunkt);
+  return Date.parse(`${berlin.replace(" ", "T")}Z`) - zeitpunkt.getTime();
+}
+
+/** Der Zeitpunkt, an dem in Berlin dieser Kalendertag beginnt. */
+export function berlinMitternacht(tag: string): Date {
+  const basis = new Date(`${tag}T00:00:00Z`);
+  // Die Umstellung findet nachts um zwei statt, nie um Mitternacht – der
+  // Versatz an dieser Stelle ist also eindeutig.
+  return new Date(basis.getTime() - zonenversatzMs(basis));
+}
+
+export interface Kennzahlen {
+  gesamt: number;
+  projekte: number;
+  erledigt: number;
+  neueAufgaben: number;
+  notizen: number;
+}
+
+/** Was ein Verlaufseintrag fuer die Zaehlung hergeben muss. */
+export interface ZaehlbarerEintrag {
+  kind: ActivityKind;
+  projectId: string;
+  meta?: unknown;
+}
+
+/**
+ * Kennzahlen einer Woche.
+ *
+ * "Erledigt" kommt aus dem `meta`-Feld (`to: "DONE"`) und nicht aus dem
+ * Anzeigetext. Der Text ist zum Lesen da und aendert sich mit der
+ * Formulierung – eine Zaehlung, die daran haengt, wird beim naechsten
+ * umformulierten Einzeiler still falsch.
+ *
+ * Fuer aeltere Eintraege ohne `to` bleibt ein Rueckfall auf den Text: der
+ * Verlauf haelt bis zu 200 Eintraege je Projekt, darunter also durchaus
+ * welche von vor dieser Aenderung.
+ */
+export function zaehleWoche(eintraege: ZaehlbarerEintrag[]): Kennzahlen {
+  let erledigt = 0;
+  let neueAufgaben = 0;
+  let notizen = 0;
+  const projekte = new Set<string>();
+
+  for (const eintrag of eintraege) {
+    projekte.add(eintrag.projectId);
+
+    if (eintrag.kind === "TASK_ADDED" || eintrag.kind === "TASKS_IMPORTED") {
+      neueAufgaben += 1;
+    } else if (eintrag.kind === "NOTE_ADDED") {
+      notizen += 1;
+    } else if (eintrag.kind === "TASK_MOVED" && istErledigt(eintrag)) {
+      erledigt += 1;
+    }
+  }
+
+  return { gesamt: eintraege.length, projekte: projekte.size, erledigt, neueAufgaben, notizen };
+}
+
+function istErledigt(eintrag: ZaehlbarerEintrag): boolean {
+  const meta = eintrag.meta;
+  if (meta && typeof meta === "object" && "to" in meta) {
+    return (meta as { to?: unknown }).to === "DONE";
+  }
+  return false;
+}
+
+const MONAT_FORMAT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  month: "long",
+});
+
+/**
+ * Beschriftung einer Woche: "17.–23. August 2026", ueber einen
+ * Monatswechsel hinweg "31. August–6. September 2026".
+ *
+ * Der Punkt hinter der Tageszahl kommt von Hand: Intl liefert bei
+ * `day: "numeric"` nur die Ziffer, und mit `day: "2-digit"` staende dort
+ * "07." statt "7.".
+ */
+export function wochenTitel(woche: Woche): string {
+  const teile = (tag: string) => {
+    const [j, m, t] = tag.split("-").map(Number);
+    return { tag: t, monat: MONAT_FORMAT.format(new Date(Date.UTC(j, m - 1, t, 12))), jahr: j };
+  };
+
+  const von = teile(woche.tage[0]);
+  const bis = teile(woche.tage[6]);
+  const gleicherMonat = von.monat === bis.monat && von.jahr === bis.jahr;
+
+  const links = gleicherMonat ? `${von.tag}.` : `${von.tag}. ${von.monat}`;
+  return `${links}–${bis.tag}. ${bis.monat} ${bis.jahr}`;
+}
+
+/** "Diese Woche", "Vorige Woche", sonst der Zeitraum. */
+export function wochenName(woche: Woche): string {
+  if (woche.versatz === 0) return "Diese Woche";
+  if (woche.versatz === -1) return "Vorige Woche";
+  return wochenTitel(woche);
+}

src/lib/sync/index.ts

@@ -5,6 +5,7 @@ import { clientForConnection, createClient, parseRepoUrl } from "@/lib/git";
 import type { GitClient } from "@/lib/git/types";
 import { notifyAfterSync } from "@/lib/notify";
 import { repoTitle } from "@/lib/repositories";
+import { reconcileLinkedIssues } from "@/lib/tasks/issues";
 import type { RepoSnapshotData } from "@/lib/git/types";
 
 export interface SyncResult {
@@ -62,11 +63,31 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
     // README hineingeschrieben werden koennen.
     await maybeRefreshCalendar(repository.id, client, ref);
     await maybeRefreshReadme(repository.id, client, ref);
+
+    /**
+     * Verknuepfte Aufgaben nachziehen: was in Git geschlossen wurde, wird
+     * hier abgehakt. Der Webhook macht das sofort – ist keiner eingerichtet
+     * oder faellt er aus, greift der Abgleich.
+     *
+     * Die offenen Issues aus dem gerade geholten Snapshot gehen mit hinein:
+     * fuer jede Nummer, die dort steht, ist die Nachfrage gespart.
+     */
+    const abgehakt = await reconcileLinkedIssues(
+      repository.id,
+      client,
+      ref,
+      data.issues.map((issue) => issue.number),
+    );
+
     // Nach dem Speichern, damit die Meldung den neuen Stand sieht.
     await notifyAfterSync(repository.id);
     return {
       ok: true,
-      message: `Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.`,
+      message:
+        `Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.` +
+        (abgehakt > 0
+          ? ` ${abgehakt} Aufgabe(n) abgehakt, weil das Issue geschlossen wurde.`
+          : ""),
       fetchedAt: new Date().toISOString(),
     };
   } catch (error) {

src/lib/tasks.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, it } from "vitest";
 import {
+  DUE_BUCKET_META,
+  DUE_BUCKET_ORDER,
   TASK_STATUS_META,
   TASK_STATUS_ORDER,
+  dueBucket,
   nextDueDate,
   progressFromTasks,
 } from "./tasks";
@@ -88,3 +91,48 @@ describe("nextDueDate", () => {
     expect(Number.isNaN(next.getTime())).toBe(false);
   });
 });
+
+describe("dueBucket", () => {
+  /** 14.08.2026, 17:30 Berliner Zeit – bewusst spaeter Nachmittag. */
+  const JETZT = new Date("2026-08-14T15:30:00Z");
+
+  it("ordnet eine Aufgabe ohne Termin nach hinten", () => {
+    expect(dueBucket(null, JETZT)).toBe("someday");
+  });
+
+  it("zaehlt den heutigen Tag als heute, auch wenn die Uhrzeit vorbei ist", () => {
+    // Der Punkt der Funktion: gerechnet wird auf Kalendertage. Um 9 Uhr
+    // faellig und jetzt ist es halb sechs – die Aufgabe steht trotzdem
+    // unter "Heute" und nicht unter "Ueberfaellig".
+    expect(dueBucket(new Date("2026-08-14T07:00:00Z"), JETZT)).toBe("today");
+  });
+
+  it("erkennt den Vortag als ueberfaellig", () => {
+    expect(dueBucket(new Date("2026-08-13T21:00:00Z"), JETZT)).toBe("overdue");
+  });
+
+  it("fasst die kommenden sieben Tage als diese Woche", () => {
+    expect(dueBucket(new Date("2026-08-15T06:00:00Z"), JETZT)).toBe("week");
+    expect(dueBucket(new Date("2026-08-21T06:00:00Z"), JETZT)).toBe("week");
+  });
+
+  it("schiebt alles danach nach spaeter", () => {
+    expect(dueBucket(new Date("2026-08-22T06:00:00Z"), JETZT)).toBe("later");
+  });
+
+  it("richtet sich nach Berliner Kalendertagen, nicht nach UTC", () => {
+    // 21:30 UTC ist in Berlin schon 23:30 desselben Tages – im Container
+    // laeuft die Anwendung aber nach UTC. Ohne feste Zeitzone kippte die
+    // Einteilung hier um einen Tag.
+    const spaetAbends = new Date("2026-08-15T21:30:00Z");
+    expect(dueBucket(new Date("2026-08-15T10:00:00Z"), spaetAbends)).toBe("today");
+    expect(dueBucket(new Date("2026-08-16T10:00:00Z"), spaetAbends)).toBe("week");
+  });
+
+  it("hat zu jedem Fach eine Beschriftung und eine Farbe", () => {
+    for (const bucket of DUE_BUCKET_ORDER) {
+      expect(DUE_BUCKET_META[bucket].label).toBeTruthy();
+      expect(DUE_BUCKET_META[bucket].color).toMatch(/^#[0-9a-f]{6}$/i);
+    }
+  });
+});

src/lib/tasks.ts

@@ -161,6 +161,68 @@ export async function spawnRecurrence(taskId: string) {
   });
 }
 
+// ── Faelligkeit in der Gesamtuebersicht ──────────────────────
+
+/**
+ * Faecher der Aufgabenuebersicht. Anders als im Projektbrett ordnet dort
+ * nicht die Spalte, sondern der Termin: projektuebergreifend ist "was ist
+ * ueberfaellig" die Frage, nicht "was steht in welcher Spalte".
+ */
+export const DUE_BUCKET_ORDER = ["overdue", "today", "week", "later", "someday"] as const;
+
+export type DueBucket = (typeof DUE_BUCKET_ORDER)[number];
+
+export const DUE_BUCKET_META: Record<DueBucket, { label: string; color: string }> = {
+  overdue: { label: "Überfällig", color: "#fb7185" },
+  today: { label: "Heute", color: "#fbbf24" },
+  week: { label: "Diese Woche", color: "#a78bfa" },
+  later: { label: "Später", color: "#38bdf8" },
+  someday: { label: "Ohne Termin", color: "#8a98b0" },
+};
+
+/**
+ * Kalendertag in fester Zeitzone, als fortlaufende Tagesnummer.
+ *
+ * Die Serverzeit taugt dafuer nicht: im Container laeuft die Anwendung nach
+ * UTC. Um 23:30 Berliner Zeit ist dort noch der Vortag, und eine heute
+ * faellige Aufgabe stuende unter "Ueberfaellig". Dieselbe Zeitzone benutzt
+ * auch die Datumsausgabe in lib/utils.
+ */
+const TAG_FORMAT = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Europe/Berlin",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+});
+
+function tagesnummer(wert: Date): number {
+  // en-CA liefert "2026-08-14" – und damit etwas, das sich ohne weiteres
+  // Zerlegen sortieren und rechnen laesst.
+  const [jahr, monat, tag] = TAG_FORMAT.format(wert).split("-").map(Number);
+  return Date.UTC(jahr, monat - 1, tag) / 86_400_000;
+}
+
+/**
+ * In welches Fach eine Aufgabe faellt.
+ *
+ * Gerechnet wird auf Kalendertage, nicht auf Stunden: eine Aufgabe, die
+ * heute um 9 Uhr faellig war, ist um 17 Uhr nicht "ueberfaellig", sondern
+ * immer noch "heute". Sonst wanderte die halbe Liste im Lauf des Tages
+ * nach oben.
+ *
+ * Bewusst als reine Funktion mit uebergebenem "jetzt" – das macht sie
+ * pruefbar.
+ */
+export function dueBucket(dueDate: Date | null, now: Date = new Date()): DueBucket {
+  if (!dueDate) return "someday";
+
+  const abstand = tagesnummer(dueDate) - tagesnummer(now);
+  if (abstand < 0) return "overdue";
+  if (abstand === 0) return "today";
+  if (abstand <= 7) return "week";
+  return "later";
+}
+
 /** Naechste freie Position am Ende einer Spalte. */
 export async function nextPosition(
   projectId: string,

src/lib/tasks/issues.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { issueShouldBeOpen, statusForIssueState } from "./issues";
+
+describe("issueShouldBeOpen", () => {
+  it("haelt das Issue offen, solange die Aufgabe nicht erledigt ist", () => {
+    expect(issueShouldBeOpen("TODO")).toBe(true);
+    expect(issueShouldBeOpen("DOING")).toBe(true);
+    expect(issueShouldBeOpen("BLOCKED")).toBe(true);
+  });
+
+  it("schliesst es erst bei ERLEDIGT", () => {
+    expect(issueShouldBeOpen("DONE")).toBe(false);
+  });
+});
+
+describe("statusForIssueState", () => {
+  it("macht aus einem geschlossenen Issue eine erledigte Aufgabe", () => {
+    expect(statusForIssueState(false, "TODO")).toBe("DONE");
+    expect(statusForIssueState(false, "DOING")).toBe("DONE");
+  });
+
+  it("holt eine erledigte Aufgabe zurueck nach OFFEN", () => {
+    expect(statusForIssueState(true, "DONE")).toBe("TODO");
+  });
+
+  it("laesst den feineren Zustand stehen, wenn das Issue ohnehin offen ist", () => {
+    // Ein "opened"-Ereignis zu einer Aufgabe, die schon in Arbeit ist, darf
+    // sie nicht auf OFFEN zuruecksetzen – IN ARBEIT ist mehr Information.
+    expect(statusForIssueState(true, "DOING")).toBe("DOING");
+    expect(statusForIssueState(true, "BLOCKED")).toBe("BLOCKED");
+    expect(statusForIssueState(true, "TODO")).toBe("TODO");
+  });
+
+  it("bildet den Rundlauf ab, so verlustbehaftet wie er ist", () => {
+    // IN ARBEIT geht nach draussen als "offen". Kommt es zurueck, bleibt es
+    // IN ARBEIT – der Zustand ueberlebt also, solange niemand das Issue
+    // schliesst. Nach dem Schliessen und Wiederoeffnen ist er weg, und das
+    // ist die bewusst hingenommene Grenze.
+    const hin = issueShouldBeOpen("DOING");
+    expect(statusForIssueState(hin, "DOING")).toBe("DOING");
+    expect(statusForIssueState(true, statusForIssueState(false, "DOING"))).toBe("TODO");
+  });
+});

src/lib/tasks/issues.ts

@@ -0,0 +1,200 @@
+import type { TaskStatus } from "@prisma/client";
+import { recordActivity, shorten } from "@/lib/activity";
+import { prisma } from "@/lib/db";
+import { clientForConnection } from "@/lib/git";
+import type { GitClient, RepoRef } from "@/lib/git/types";
+import { nextPosition, refreshDerivedProgress, spawnRecurrence } from "@/lib/tasks";
+
+/**
+ * Die Bruecke zwischen Nebula-Aufgabe und Git-Issue.
+ *
+ * Die Zustaende passen nicht aufeinander und das bleibt so: Nebula kennt
+ * OFFEN, IN ARBEIT, BLOCKIERT und ERLEDIGT, ein Issue nur offen oder
+ * geschlossen. Nach aussen geht deshalb nur die Grenze zwischen "erledigt"
+ * und "nicht erledigt"; ein Rundlauf verliert IN ARBEIT und BLOCKIERT.
+ *
+ * Die Alternative waeren Labels wie "nebula:doing" – die wuerden den
+ * Issue-Tracker aber mit Zustaenden fuellen, die dort niemand pflegt. Die
+ * feine Abstufung bleibt in Nebula.
+ */
+
+/** Ist der Aufgabenzustand einer, bei dem das Issue offen sein soll? */
+export function issueShouldBeOpen(status: TaskStatus): boolean {
+  return status !== "DONE";
+}
+
+/** Der Aufgabenzustand, der zu einem Issue-Zustand passt. */
+export function statusForIssueState(open: boolean, current: TaskStatus): TaskStatus {
+  if (open) {
+    // Ein wieder geoeffnetes Issue macht aus ERLEDIGT wieder OFFEN. Stand
+    // die Aufgabe ohnehin nicht auf ERLEDIGT, bleibt ihr feinerer Zustand
+    // stehen – IN ARBEIT ist mehr Information als OFFEN.
+    return current === "DONE" ? "TODO" : current;
+  }
+  return "DONE";
+}
+
+/**
+ * Traegt den Zustand einer Aufgabe an ihrem Issue nach.
+ *
+ * Bewusst fehlertolerant: schlaegt der Aufruf fehl, ist die Aufgabe in
+ * Nebula trotzdem umgezogen. Ein nicht erreichbares Git-System darf das
+ * Abhaken nicht verhindern – der naechste Wechsel versucht es erneut.
+ *
+ * Gibt zurueck, ob es geklappt hat; null heisst "nichts zu tun".
+ */
+export async function mirrorStatusToIssue(
+  taskId: string,
+  status: TaskStatus,
+): Promise<boolean | null> {
+  const task = await prisma.task.findUnique({
+    where: { id: taskId },
+    select: { sourceIssue: true, sourceRepositoryId: true },
+  });
+  if (!task?.sourceIssue || !task.sourceRepositoryId) return null;
+
+  const repository = await prisma.repository.findUnique({
+    where: { id: task.sourceRepositoryId },
+    include: { connection: true },
+  });
+  if (!repository?.connection || !repository.repoOwner || !repository.repoName) return null;
+
+  try {
+    const client = clientForConnection(repository.connection);
+    await client.setIssueState(
+      { owner: repository.repoOwner, name: repository.repoName },
+      task.sourceIssue,
+      issueShouldBeOpen(status),
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Hakt eine Aufgabe ab, weil ihr Issue geschlossen wurde.
+ *
+ * Bewusst an einer Stelle fuer beide Wege – Webhook und Abgleich. Vorher
+ * setzte der Webhook nur den Status und liess dabei aus, was die Oberflaeche
+ * tut: die naechste Fassung einer wiederkehrenden Aufgabe anlegen und den
+ * Vorgang in den Verlauf schreiben.
+ *
+ * Gibt false zurueck, wenn nichts zu tun war (Aufgabe fehlt oder ist schon
+ * erledigt) – der Aufrufer kann daran zaehlen, was er bewirkt hat.
+ */
+export async function completeTaskFromIssue(
+  taskId: string,
+  herkunft: "webhook" | "abgleich",
+): Promise<boolean> {
+  const task = await prisma.task.findUnique({
+    where: { id: taskId },
+    select: { id: true, title: true, status: true, projectId: true, sourceIssue: true },
+  });
+  if (!task || task.status === "DONE") return false;
+
+  await prisma.task.update({
+    where: { id: task.id },
+    data: {
+      status: "DONE",
+      doneAt: new Date(),
+      position: await nextPosition(task.projectId, "DONE"),
+    },
+  });
+
+  // Wie beim Abhaken von Hand: eine wiederkehrende Aufgabe erzeugt ihre
+  // naechste Fassung.
+  const folge = await spawnRecurrence(task.id);
+  await refreshDerivedProgress(task.projectId);
+
+  await recordActivity({
+    projectId: task.projectId,
+    // Kein userId: das hat nicht ein Mensch in Nebula getan, sondern das
+    // Git-System gemeldet.
+    kind: "TASK_MOVED",
+    summary:
+      `Issue #${task.sourceIssue} geschlossen → „${shorten(task.title, 40)}“ erledigt` +
+      (herkunft === "abgleich" ? " (beim Abgleich bemerkt)" : "") +
+      (folge ? ", nächste angelegt" : ""),
+    // "from"/"to" wie beim Verschieben von Hand – der Wochenrueckblick
+    // zaehlt daran ab, was erledigt wurde, statt den Text zu durchsuchen.
+    meta: {
+      taskId: task.id,
+      issue: task.sourceIssue,
+      source: herkunft,
+      from: task.status,
+      to: "DONE",
+    },
+  });
+
+  return true;
+}
+
+/** Wie viele Issues ein Abgleich hoechstens einzeln nachfragt. */
+const MAX_NACHFRAGEN = 25;
+
+/**
+ * Gleicht beim Abgleich die verknuepften Issues ab: was in Git geschlossen
+ * ist, wird in Nebula abgehakt.
+ *
+ * Warum zusaetzlich zum Webhook: der Webhook wirkt sofort, setzt aber voraus,
+ * dass die Instanz von aussen erreichbar ist und der Haken eingetragen wurde.
+ * Ist er das nicht – oder faellt er einmal aus –, bliebe der Rueckweg sonst
+ * ganz aus. Hier kommt er verzoegert, aber verlaesslich.
+ *
+ * **Nur abhaken, nie zuruecknehmen.** Der Abgleich sieht Zustaende, keine
+ * Ereignisse. Ein offenes Issue kann auch bedeuten, dass das Schliessen von
+ * Nebula aus fehlgeschlagen ist – dann wuerde ein symmetrischer Abgleich eine
+ * bewusst erledigte Aufgabe wieder aufmachen. Das Zuruecknehmen bleibt dem
+ * Webhook vorbehalten, der ein echtes "reopened" sieht.
+ *
+ * Fehler werden geschluckt: ein nicht erreichbares Issue darf den Abgleich
+ * des Repositories nicht scheitern lassen.
+ */
+export async function reconcileLinkedIssues(
+  repositoryId: string,
+  client: GitClient,
+  ref: RepoRef,
+  /** Nummern, die der Snapshot gerade als offen gemeldet hat. */
+  offeneNummern: number[] = [],
+): Promise<number> {
+  const offen = new Set(offeneNummern);
+
+  const kandidaten = await prisma.task.findMany({
+    where: {
+      sourceRepositoryId: repositoryId,
+      sourceIssue: { not: null },
+      status: { not: "DONE" },
+    },
+    select: { id: true, sourceIssue: true },
+    orderBy: { createdAt: "asc" },
+  });
+
+  let abgehakt = 0;
+  let nachfragen = 0;
+
+  for (const task of kandidaten) {
+    const nummer = task.sourceIssue;
+    if (nummer === null) continue;
+
+    // Steht die Nummer in der Liste der offenen Issues, ist nichts zu tun –
+    // und der Aufruf gespart. Umgekehrt gilt das nicht: die Liste ist
+    // gedeckelt, aus dem Fehlen folgt also nichts.
+    if (offen.has(nummer)) continue;
+
+    if (nachfragen >= MAX_NACHFRAGEN) break;
+    nachfragen += 1;
+
+    try {
+      const zustand = await client.getIssueState(ref, nummer);
+      // null heisst "gibt es nicht mehr" – geloescht ist nicht erledigt,
+      // also bleibt die Aufgabe stehen.
+      if (zustand !== "closed") continue;
+      if (await completeTaskFromIssue(task.id, "abgleich")) abgehakt += 1;
+    } catch {
+      // Nichts erreichbar, nichts geaendert – der naechste Lauf versucht es.
+    }
+  }
+
+  return abgehakt;
+}

src/lib/timeline.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { SEITE, SEITE_MAX, cursorAus, seitenBedingung, seitenGroesse } from "./timeline";
+
+const ID = "cmstxnrzs00011cx4nd5tiqbt";
+
+describe("cursorAus", () => {
+  it("liest Zeitpunkt und ID", () => {
+    const cursor = cursorAus("2026-08-17T22:30:00.000Z", ID);
+    expect(cursor?.id).toBe(ID);
+    expect(cursor?.createdAt.toISOString()).toBe("2026-08-17T22:30:00.000Z");
+  });
+
+  it("faengt ohne Cursor von vorn an", () => {
+    expect(cursorAus(null, null)).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", null)).toBeNull();
+    expect(cursorAus(null, ID)).toBeNull();
+  });
+
+  it("weist Unbrauchbares ab, statt es in die Abfrage zu geben", () => {
+    expect(cursorAus("kein datum", ID)).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", "kurz")).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", "'; DROP TABLE x --")).toBeNull();
+  });
+});
+
+describe("seitenBedingung", () => {
+  it("filtert immer auf den Besitzer", () => {
+    expect(seitenBedingung("u1", null)).toEqual({ project: { ownerId: "u1" } });
+  });
+
+  it("behaelt den Besitzer auch mit Cursor", () => {
+    const wo = seitenBedingung("u1", { createdAt: new Date("2026-08-17T22:30:00Z"), id: ID });
+    expect(wo.project).toEqual({ ownerId: "u1" });
+  });
+
+  it("fasst gleichzeitige Eintraege ueber die ID auseinander", () => {
+    // Der eigentliche Zweck: beim Uebernehmen von Issues entstehen mehrere
+    // Zeilen mit identischem createdAt. Ohne den zweiten Zweig wuerde die
+    // naechste Seite sie ueberspringen oder wiederholen.
+    const zeitpunkt = new Date("2026-08-17T22:30:00Z");
+    const wo = seitenBedingung("u1", { createdAt: zeitpunkt, id: ID });
+    expect(wo.OR).toEqual([
+      { createdAt: { lt: zeitpunkt } },
+      { createdAt: zeitpunkt, id: { lt: ID } },
+    ]);
+  });
+});
+
+describe("seitenGroesse", () => {
+  it("nimmt die Vorgabe, wenn nichts angefragt wurde", () => {
+    expect(seitenGroesse(null)).toBe(SEITE);
+    expect(seitenGroesse("unsinn")).toBe(SEITE);
+  });
+
+  it("deckelt nach oben und unten", () => {
+    expect(seitenGroesse("1000")).toBe(SEITE_MAX);
+    expect(seitenGroesse("0")).toBe(1);
+    expect(seitenGroesse("-5")).toBe(1);
+  });
+
+  it("nimmt einen gueltigen Wert an", () => {
+    expect(seitenGroesse("25")).toBe(25);
+  });
+});

src/lib/timeline.ts

@@ -0,0 +1,77 @@
+import type { Prisma } from "@prisma/client";
+
+/**
+ * Fortlaufender Verlauf ueber alle Projekte.
+ *
+ * Geblaettert wird per Cursor, nicht per `skip`. Der Verlauf schreibt
+ * mehrere Eintraege im selben Augenblick – beim Uebernehmen von Issues etwa
+ * entstehen zehn Zeilen mit identischem `createdAt`. Ein Offset ueber eine
+ * solche Grenze hinweg ueberspringt Zeilen oder zeigt sie zweimal, und zwar
+ * lautlos. Der Cursor aus (createdAt, id) ist dagegen eindeutig.
+ */
+
+/** Wie viele Eintraege eine Seite hat. */
+export const SEITE = 40;
+/** Deckel gegen einen Aufrufer, der sich alles auf einmal holen will. */
+export const SEITE_MAX = 100;
+
+export interface Cursor {
+  /** Zeitpunkt des letzten gezeigten Eintrags. */
+  createdAt: Date;
+  /** Seine ID – entscheidet bei gleichem Zeitpunkt. */
+  id: string;
+}
+
+/**
+ * Liest einen Cursor aus Abfrageparametern.
+ *
+ * Gibt null zurueck, wenn nichts oder Unbrauchbares ankommt – dann faengt
+ * die Seite eben von vorn an. Ein Fehler waere hier die schlechtere Antwort:
+ * ein abgeschnittener Verweis soll die Seite nicht sperren.
+ */
+export function cursorAus(vor: string | null, id: string | null): Cursor | null {
+  if (!vor || !id) return null;
+  const zeitpunkt = new Date(vor);
+  if (Number.isNaN(zeitpunkt.getTime())) return null;
+  // Die ID ist eine cuid; alles andere weisen wir ab, statt es in die
+  // Abfrage zu geben.
+  if (!/^[a-z0-9]{20,32}$/i.test(id)) return null;
+  return { createdAt: zeitpunkt, id };
+}
+
+/**
+ * Die where-Bedingung fuer eine Seite.
+ *
+ * Besitzer zuerst – wie ueberall im Projekt, damit fremde Datensaetze gar
+ * nicht erst getroffen werden. Der Verlauf selbst kennt keinen Besitzer, die
+ * Bedingung laeuft deshalb ueber das Projekt.
+ *
+ * Der Cursor bedeutet "aelter als der letzte gezeigte Eintrag": entweder
+ * frueher, oder gleichzeitig und mit kleinerer ID. Genau so sortiert auch
+ * die Abfrage, weshalb beides zusammenpasst.
+ */
+export function seitenBedingung(ownerId: string, cursor: Cursor | null): Prisma.ActivityWhereInput {
+  const basis: Prisma.ActivityWhereInput = { project: { ownerId } };
+  if (!cursor) return basis;
+
+  return {
+    ...basis,
+    OR: [
+      { createdAt: { lt: cursor.createdAt } },
+      { createdAt: cursor.createdAt, id: { lt: cursor.id } },
+    ],
+  };
+}
+
+/** Sortierung, die zur Cursor-Bedingung passt. Beide muessen gleich sein. */
+export const SEITEN_ORDNUNG: Prisma.ActivityOrderByWithRelationInput[] = [
+  { createdAt: "desc" },
+  { id: "desc" },
+];
+
+/** Begrenzt eine gewuenschte Seitengroesse auf das Erlaubte. */
+export function seitenGroesse(roh: string | null): number {
+  const angefragt = roh === null ? Number.NaN : Number(roh);
+  if (!Number.isFinite(angefragt)) return SEITE;
+  return Math.min(Math.max(Math.trunc(angefragt), 1), SEITE_MAX);
+}

src/lib/webhooks/verify.test.ts

@@ -0,0 +1,137 @@
+import { createHmac } from "node:crypto";
+import { describe, expect, it } from "vitest";
+import { parseEvent, verifySignature } from "./verify";
+
+const GEHEIM = "ein-geheimnis-das-lang-genug-ist";
+const RUMPF = JSON.stringify({ action: "closed", issue: { number: 12 } });
+
+function signiere(secret: string, body: string): string {
+  return createHmac("sha256", secret).update(body, "utf8").digest("hex");
+}
+
+function kopf(eintraege: Record<string, string>): Headers {
+  return new Headers(eintraege);
+}
+
+describe("verifySignature – GitHub", () => {
+  it("nimmt die richtige Signatur an", () => {
+    const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
+    expect(verifySignature("GITHUB", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
+  });
+
+  it("weist eine fremde Signatur ab", () => {
+    const headers = kopf({ "x-hub-signature-256": `sha256=${signiere("anderes", RUMPF)}` });
+    expect(verifySignature("GITHUB", GEHEIM, RUMPF, headers)).toEqual({
+      ok: false,
+      reason: "mismatch",
+    });
+  });
+
+  it("weist ab, wenn der Rumpf veraendert wurde", () => {
+    // Das ist der eigentliche Zweck: die Signatur haengt am Inhalt.
+    const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
+    const veraendert = JSON.stringify({ action: "closed", issue: { number: 99 } });
+    expect(verifySignature("GITHUB", GEHEIM, veraendert, headers).ok).toBe(false);
+  });
+
+  it("weist ab, wenn gar keine Signatur mitkommt", () => {
+    expect(verifySignature("GITHUB", GEHEIM, RUMPF, kopf({}))).toEqual({
+      ok: false,
+      reason: "missing",
+    });
+  });
+
+  it("laesst sich nicht mit dem blossen Praefix taeuschen", () => {
+    expect(verifySignature("GITHUB", GEHEIM, RUMPF, kopf({ "x-hub-signature-256": "sha256=" })).ok).toBe(
+      false,
+    );
+  });
+});
+
+describe("verifySignature – Gitea", () => {
+  it("nimmt die Signatur ohne Praefix an", () => {
+    const headers = kopf({ "x-gitea-signature": signiere(GEHEIM, RUMPF) });
+    expect(verifySignature("GITEA", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
+  });
+
+  it("nimmt ersatzweise das GitHub-Format an", () => {
+    // Aeltere Gitea-Fassungen senden nur X-Hub-Signature-256.
+    const headers = kopf({ "x-hub-signature-256": `sha256=${signiere(GEHEIM, RUMPF)}` });
+    expect(verifySignature("GITEA", GEHEIM, RUMPF, headers)).toEqual({ ok: true });
+  });
+
+  it("weist eine falsche Signatur ab", () => {
+    const headers = kopf({ "x-gitea-signature": signiere("anderes", RUMPF) });
+    expect(verifySignature("GITEA", GEHEIM, RUMPF, headers).ok).toBe(false);
+  });
+});
+
+describe("verifySignature – GitLab", () => {
+  it("vergleicht den Token im Klartext", () => {
+    expect(verifySignature("GITLAB", GEHEIM, RUMPF, kopf({ "x-gitlab-token": GEHEIM }))).toEqual({
+      ok: true,
+    });
+  });
+
+  it("weist einen falschen Token ab", () => {
+    expect(
+      verifySignature("GITLAB", GEHEIM, RUMPF, kopf({ "x-gitlab-token": "falsch" })).ok,
+    ).toBe(false);
+  });
+
+  it("weist ab, wenn der Token fehlt", () => {
+    expect(verifySignature("GITLAB", GEHEIM, RUMPF, kopf({}))).toEqual({
+      ok: false,
+      reason: "missing",
+    });
+  });
+});
+
+describe("parseEvent", () => {
+  it("erkennt einen Push", () => {
+    expect(parseEvent("GITHUB", "push", {})).toEqual({ kind: "push" });
+  });
+
+  it("erkennt ein geschlossenes Issue bei GitHub und Gitea", () => {
+    const nutzlast = { action: "closed", issue: { number: 12 } };
+    expect(parseEvent("GITHUB", "issues", nutzlast)).toEqual({
+      kind: "issue",
+      number: 12,
+      open: false,
+    });
+    expect(parseEvent("GITEA", "issues", nutzlast)).toEqual({
+      kind: "issue",
+      number: 12,
+      open: false,
+    });
+  });
+
+  it("erkennt ein wieder geoeffnetes Issue", () => {
+    expect(parseEvent("GITHUB", "issues", { action: "reopened", issue: { number: 7 } })).toEqual({
+      kind: "issue",
+      number: 7,
+      open: true,
+    });
+  });
+
+  it("nimmt bei GitLab die projektinterne Nummer", () => {
+    // "iid" ist die Nummer aus der Oberflaeche; "id" waere instanzweit.
+    const ereignis = parseEvent("GITLAB", "Issue Hook", {
+      object_kind: "issue",
+      object_attributes: { iid: 5, state: "closed" },
+    });
+    expect(ereignis).toEqual({ kind: "issue", number: 5, open: false });
+  });
+
+  it("laesst Unbekanntes liegen, statt zu scheitern", () => {
+    expect(parseEvent("GITHUB", "issue_comment", {}).kind).toBe("ignored");
+    expect(parseEvent("GITHUB", "issues", { action: "labeled", issue: { number: 1 } }).kind).toBe(
+      "ignored",
+    );
+    expect(parseEvent("GITHUB", null, null).kind).toBe("ignored");
+  });
+
+  it("laesst ein Issue ohne Nummer liegen", () => {
+    expect(parseEvent("GITHUB", "issues", { action: "closed", issue: {} }).kind).toBe("ignored");
+  });
+});

src/lib/webhooks/verify.ts

@@ -0,0 +1,139 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import type { GitProvider } from "@prisma/client";
+
+/**
+ * Pruefung eingehender Webhooks.
+ *
+ * Der Endpunkt ist die einzige Stelle der Anwendung, die ohne Anmeldung
+ * schreibend wirkt – deshalb steht die Pruefung hier fuer sich, ohne
+ * Datenbank und ohne Netz, und ist damit vollstaendig testbar.
+ *
+ * Die drei Systeme machen es unterschiedlich:
+ *
+ *   GitHub  X-Hub-Signature-256: "sha256=<hex>", HMAC-SHA256 ueber den Rumpf
+ *   Gitea   X-Gitea-Signature:   "<hex>" ohne Praefix, sonst gleich
+ *   GitLab  X-Gitlab-Token:      das Geheimnis im Klartext, keine Signatur
+ *
+ * GitLabs Verfahren ist schwaecher – es beweist nur, dass der Absender das
+ * Geheimnis kennt, nicht dass der Rumpf unveraendert ist. Mehr gibt die
+ * Plattform nicht her; verglichen wird trotzdem zeitkonstant.
+ */
+
+export type VerifyResult =
+  | { ok: true }
+  | { ok: false; reason: "missing" | "mismatch" | "unsupported" };
+
+/** Vergleich ohne Laufzeitunterschied – ein Zeichenvergleich waere angreifbar. */
+function equals(a: string, b: string): boolean {
+  const links = Buffer.from(a, "utf8");
+  const rechts = Buffer.from(b, "utf8");
+  // timingSafeEqual verlangt gleiche Laenge und wirft sonst. Die Laenge
+  // selbst ist kein Geheimnis, der fruehe Ausstieg also unbedenklich.
+  if (links.length !== rechts.length) return false;
+  return timingSafeEqual(links, rechts);
+}
+
+function hmacHex(secret: string, body: string): string {
+  return createHmac("sha256", secret).update(body, "utf8").digest("hex");
+}
+
+/**
+ * Prueft die Signatur eines eingehenden Aufrufs.
+ *
+ * `body` muss der **rohe** Rumpf sein, genau wie er ankam. Ein durch
+ * JSON.parse und JSON.stringify gedrehter Rumpf hat eine andere Signatur –
+ * andere Reihenfolge, anderes Escaping, kein Leerraum.
+ */
+export function verifySignature(
+  provider: GitProvider,
+  secret: string,
+  body: string,
+  headers: Headers,
+): VerifyResult {
+  switch (provider) {
+    case "GITHUB": {
+      const gesendet = headers.get("x-hub-signature-256");
+      if (!gesendet) return { ok: false, reason: "missing" };
+      const erwartet = `sha256=${hmacHex(secret, body)}`;
+      return equals(gesendet, erwartet) ? { ok: true } : { ok: false, reason: "mismatch" };
+    }
+
+    case "GITEA": {
+      // Gitea schickt die Signatur ohne Praefix. Aeltere Fassungen senden
+      // zusaetzlich X-Hub-Signature-256 im GitHub-Format – beides gilt.
+      const gitea = headers.get("x-gitea-signature");
+      if (gitea) {
+        return equals(gitea, hmacHex(secret, body))
+          ? { ok: true }
+          : { ok: false, reason: "mismatch" };
+      }
+      const hub = headers.get("x-hub-signature-256");
+      if (hub) {
+        return equals(hub, `sha256=${hmacHex(secret, body)}`)
+          ? { ok: true }
+          : { ok: false, reason: "mismatch" };
+      }
+      return { ok: false, reason: "missing" };
+    }
+
+    case "GITLAB": {
+      const token = headers.get("x-gitlab-token");
+      if (!token) return { ok: false, reason: "missing" };
+      return equals(token, secret) ? { ok: true } : { ok: false, reason: "mismatch" };
+    }
+
+    default:
+      return { ok: false, reason: "unsupported" };
+  }
+}
+
+/** Welches Ereignis kam an – auf einen gemeinsamen Nenner gebracht. */
+export type WebhookEvent =
+  | { kind: "push" }
+  | { kind: "issue"; number: number; open: boolean }
+  | { kind: "ignored"; name: string };
+
+interface IssuePayload {
+  action?: string;
+  issue?: { number?: number; iid?: number; state?: string };
+  object_attributes?: { iid?: number; action?: string; state?: string };
+  object_kind?: string;
+}
+
+/**
+ * Uebersetzt den Rumpf in ein Ereignis, das die Anwendung kennt.
+ *
+ * Bewusst grob: Nebula interessiert nur, ob ein Push kam (dann lohnt ein
+ * Abgleich) und ob ein Issue geschlossen oder wieder geoeffnet wurde (dann
+ * wandert die Aufgabe mit). Alles andere wird benannt und liegen gelassen.
+ */
+export function parseEvent(
+  provider: GitProvider,
+  eventName: string | null,
+  payload: unknown,
+): WebhookEvent {
+  const daten = (payload ?? {}) as IssuePayload;
+  const name = (eventName ?? daten.object_kind ?? "").toLowerCase();
+
+  if (name === "push" || name === "push hook") return { kind: "push" };
+
+  if (provider === "GITLAB") {
+    if (name !== "issue" && name !== "issue hook") return { kind: "ignored", name };
+    const attrs = daten.object_attributes;
+    const nummer = attrs?.iid;
+    if (typeof nummer !== "number") return { kind: "ignored", name };
+    // GitLab meldet den Zustand als "opened" oder "closed".
+    const offen = attrs?.state !== "closed";
+    return { kind: "issue", number: nummer, open: offen };
+  }
+
+  // GitHub und Gitea nennen das Ereignis "issues" und legen die Tat in
+  // "action" ab. Umbenennungen und Kommentare interessieren hier nicht.
+  if (name !== "issues") return { kind: "ignored", name };
+  const nummer = daten.issue?.number;
+  if (typeof nummer !== "number") return { kind: "ignored", name };
+  if (daten.action !== "closed" && daten.action !== "reopened" && daten.action !== "opened") {
+    return { kind: "ignored", name: `issues.${daten.action ?? "?"}` };
+  }
+  return { kind: "issue", number: nummer, open: daten.action !== "closed" };
+}

src/middleware.ts

@@ -15,11 +15,27 @@ import { NextResponse, type NextRequest } from "next/server";
  */
 
 const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
-const SESSION_COOKIE = "nebula_session";
+
+/**
+ * Beide moeglichen Namen des Sitzungscookies.
+ *
+ * Bei https traegt er den Praefix "__Host-", sonst nicht (der Praefix
+ * verlangt zwingend Secure). Welcher gilt, entscheidet lib/config anhand
+ * der APP_URL – hier im Edge-Runtime wird schlicht auf beide geschaut. Es
+ * geht ohnehin nur um die grobe Vorpruefung; verbindlich entscheidet
+ * requireUserPage bzw. requireUserApi.
+ */
+const SESSION_COOKIES = ["__Host-nebula_session", "nebula_session"];
 
 /** Ohne Anmeldung erreichbar. */
 const PUBLIC_PATHS = ["/login", "/setup", "/register"];
-const PUBLIC_API_PREFIXES = ["/api/auth/"];
+/**
+ * Eingehende Webhooks bringen kein Cookie mit – sie kommen von GitHub,
+ * GitLab oder Gitea. Ausgewiesen wird sich dort mit einer Signatur ueber den
+ * Rumpf, geprueft im Endpunkt selbst (lib/webhooks/verify). Ohne gueltiges
+ * Geheimnis passiert nichts.
+ */
+const PUBLIC_API_PREFIXES = ["/api/auth/", "/api/webhooks/"];
 /**
  * Der Docker-Healthcheck hat kein Cookie. Manifest und Symbole braucht der
  * Browser, bevor sich jemand angemeldet hat – wuerden sie zur Anmeldeseite
@@ -91,7 +107,12 @@ export function middleware(request: NextRequest) {
   const isDev = process.env.NODE_ENV === "development";
 
   // ── 1. CSRF ────────────────────────────────────────────────
-  if (!SAFE_METHODS.has(request.method) && !isSameOrigin(request)) {
+  // Webhooks kommen von einem fremden Server und koennen keinen passenden
+  // Origin mitbringen. Die Herkunftspruefung schuetzt gegen den Browser
+  // eines angemeldeten Nutzers – hier gibt es keinen, und ausgewiesen wird
+  // sich stattdessen mit der Signatur ueber den Rumpf.
+  const istWebhook = pathname.startsWith("/api/webhooks/");
+  if (!istWebhook && !SAFE_METHODS.has(request.method) && !isSameOrigin(request)) {
     return NextResponse.json(
       { error: "Anfrage von fremdem Ursprung abgelehnt." },
       { status: 403 },
@@ -99,7 +120,7 @@ export function middleware(request: NextRequest) {
   }
 
   // ── 2. Zugangsschranke ─────────────────────────────────────
-  const hasSession = Boolean(request.cookies.get(SESSION_COOKIE)?.value);
+  const hasSession = SESSION_COOKIES.some((name) => Boolean(request.cookies.get(name)?.value));
   if (!hasSession && !isPublicPath(pathname)) {
     if (pathname.startsWith("/api/")) {
       return NextResponse.json({ error: "Nicht angemeldet." }, { status: 401 });

src/types/index.ts

@@ -4,12 +4,14 @@ import type {
   Note,
   Project,
   ProjectStatus,
+  Recurrence,
   RepoSnapshot,
   Repository,
   Task,
   TaskStatus,
 } from "@prisma/client";
 import type { CommitCalendar } from "@/lib/git/calendar";
+import type { DueBucket } from "@/lib/tasks";
 import type {
   BranchInfo,
   CiInfo,
@@ -38,8 +40,14 @@ export interface ConnectionWithCount extends ConnectionSafe {
   _count?: { repositories: number };
 }
 
-/** Ein Repository samt Verbindung und zuletzt geholtem Stand. */
-export interface RepositoryWithSnapshot extends Repository {
+/**
+ * Ein Repository samt Verbindung und zuletzt geholtem Stand.
+ *
+ * Ohne webhookSecret: das Geheimnis verlaesst den Server nicht – siehe
+ * repositorySafeSelect. Ob einer eingerichtet ist, reicht die Projektseite
+ * getrennt durch.
+ */
+export interface RepositoryWithSnapshot extends Omit<Repository, "webhookSecret"> {
   connection: ConnectionSafe | null;
   snapshot: RepoSnapshot | null;
 }
@@ -70,6 +78,46 @@ export interface ProjectDetail extends Project {
   _count: { notes: number; tasks: number };
 }
 
+/**
+ * Eine Aufgabe in der projektuebergreifenden Uebersicht.
+ *
+ * Bewusst kein `extends Task`: die Seite braucht das Projekt dazu, das Fach
+ * fuer die Faelligkeit kommt vom Server, und Datumsangaben gehen als
+ * Zeichenkette an den Browser – ein Date ueberlebt die Serialisierung nicht.
+ */
+export interface TaskOverviewItem {
+  id: string;
+  title: string;
+  description: string | null;
+  status: TaskStatus;
+  dueDate: string | null;
+  labels: string[];
+  recurrence: Recurrence | null;
+  /** Gesetzt, wenn die Aufgabe an einem Git-Issue haengt. */
+  sourceIssue: number | null;
+  sourceUrl: string | null;
+  bucket: DueBucket;
+  project: { id: string; name: string; accent: string; status: ProjectStatus };
+}
+
+/** Ein Verlaufseintrag im Wochenrueckblick – mit Projekt, ueber Projekte hinweg. */
+export interface ReviewEntry {
+  id: string;
+  kind: ActivityKind;
+  summary: string;
+  /** ISO – ein Date ueberlebt den Weg zum Browser nicht. */
+  createdAt: string;
+  project: { id: string; name: string; accent: string };
+  user: { username: string; displayName: string | null } | null;
+}
+
+/** Ein Kalendertag der Woche samt seiner Eintraege. */
+export interface ReviewDay {
+  /** "2026-08-17", in Berliner Zeit bestimmt. */
+  tag: string;
+  eintraege: ReviewEntry[];
+}
+
 export interface RepoListEntry {
   fullPath: string;
   owner: string;