feat(git): Webhooks fuer Push und Issues, v1.7.0

Ein Push aktualisiert den Stand sofort, statt bis zum naechsten Durchlauf
des Zeitgebers zu warten; ein geschlossenes Issue hakt seine Aufgabe ab.
Der Zeitplan bleibt als Rueckfalllosung.

Der Endpunkt ist der einzige ohne Anmeldung, der schreibt – entsprechend
eng gefasst:

- Ausgewiesen wird sich mit einer Signatur ueber den Rumpf. GitHub und
  Gitea rechnen HMAC-SHA256, GitLab schickt nur den Token im Klartext;
  dessen Verfahren ist schwaecher, mehr gibt die Plattform nicht her.
  Verglichen wird durchweg zeitkonstant.
- Geprueft wird gegen den **rohen** Rumpf. Durch JSON.parse und
  JSON.stringify gedreht kaeme eine andere Zeichenfolge heraus und die
  Signatur passte nie.
- Der Rumpf ist nie Quelle fuer Inhalte. Wer das Geheimnis kennt, kann eine
  Aufgabe auf- oder zumachen und einen Abgleich ausloesen – keine
  beliebigen Daten einschleusen.
- Ratenbegrenzung je Repository, Deckel auf die Rumpfgroesse, und ein
  unbekanntes Repository antwortet wie ein nicht eingerichtetes: 404,
  damit die ID nicht bestaetigt wird.
- Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler
  brachte das Git-System zum Wiederholen und irgendwann zum Abschalten.

Das Geheimnis liegt verschluesselt am Repository, wie die Zugangstoken, und
ist genau einmal zu sehen. Damit es nicht doch nach draussen wandert, laedt
repositoryInclude die Repositories nicht mehr per include, sondern ueber
eine ausdrueckliche Feldliste: ein include haette das neue Feld still in
jede Projektantwort und jede Seite mitgenommen. Ob ein Haken eingerichtet
ist, holt die Projektseite getrennt.

Die Migration legt zwei nullbare Spalten an, mehr nicht; der Gegenlauf von
migrate diff kommt leer heraus.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.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)
+# Host-Port-Mapping fuer den App-Container (--profile full). Nur auf dem
-APP_PORT="3000"
+# 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
+# Host-Port der Datenbank. Wirkt NUR zusammen mit docker-compose.dev.yml
-POSTGRES_PORT="5432"
+# (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).

CLAUDE.md

@@ -4,12 +4,13 @@ Dashboard für Vibe-Coding-Projekte. Next.js 15 (App Router), TypeScript,
 Tailwind 4, Prisma, PostgreSQL. Oberfläche und Texte sind **deutsch**.
 
 Funktionsumfang: [FEATURES.md](FEATURES.md) · Geplantes: [ROADMAP.md](ROADMAP.md) ·
-Betrieb: [README.md](README.md)
+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
@@ -102,6 +103,13 @@ 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.
 
+**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
+Dialogzustand ist eine eigene Prüfung — geschlossene Dialoge stehen nicht im
+DOM. Der Kontrast gedämpfter Texte ist der Punkt, der hier schon einmal
+gerissen wurde; die aufgehellten Stufen stehen in `globals.css` im `@theme`.
+
 Wer den Standalone-Bau von Hand startet (`node .next/standalone/server.js`),
 muss vorher `.next/static` und `public` danebenkopieren — sonst lädt kein
 JavaScript, die Seite bleibt serverseitig gerendert, und Formulare senden

DEPLOYMENT.md

@@ -0,0 +1,412 @@
+# Nebula auf einem Server betreiben
+
+Schritt für Schritt: von der leeren Maschine bis zur laufenden Instanz hinter
+TLS — und wie Updates danach ablaufen.
+
+Für Installation zum Ausprobieren und die Entwicklungsvarianten siehe
+[README.md](README.md). Hier geht es um den Dauerbetrieb.
+
+---
+
+## Was du brauchst
+
+| | |
+| --- | --- |
+| 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 |
+| TLS | Pflicht, wenn du Passkeys willst — siehe Schritt 6 |
+
+> **Warum TLS Pflicht ist:** Passkeys verlangen einen sicheren Kontext.
+> Über `http://` an einer LAN-IP funktionieren sie nicht. Passwort und
+> Zwei-Faktor gehen auch ohne, aber dann läuft dein Passwort im Klartext
+> übers Netz — betreibe Nebula nicht ohne TLS.
+
+---
+
+## 1 · Docker installieren
+
+```bash
+curl -fsSL https://get.docker.com | sh
+sudo usermod -aG docker "$USER"
+newgrp docker            # oder ab- und wieder anmelden
+
+docker --version && docker compose version
+```
+
+## 2 · Nebula holen
+
+```bash
+sudo mkdir -p /opt/nebula && sudo chown "$USER" /opt/nebula
+git clone https://git.example.com/dein-name/nebula.git /opt/nebula
+cd /opt/nebula
+```
+
+## 3 · Konfigurieren
+
+```bash
+./scripts/setup.sh        # legt .env an, würfelt ein APP_SECRET, setzt Rechte 600
+```
+
+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
+cp .env.example .env
+chmod 600 .env
+openssl rand -base64 32        # den Wert als APP_SECRET eintragen
+```
+
+Dann die `.env` öffnen und mindestens diese drei Werte anpassen:
+
+```env
+# Die Adresse, unter der du Nebula im Browser aufrufst.
+# Bestimmt die WebAuthn-rpID — passt sie nicht, scheitern Passkeys.
+APP_URL="https://nebula.deine-domain.de"
+
+# Verschlüsselt die Git-Tokens. Lang, zufällig, niemals teilen.
+APP_SECRET="…dein-langer-zufallswert…"
+
+# Das Datenbankpasswort. Die Voreinstellung „nebula" ist für Entwicklung.
+POSTGRES_PASSWORD="…noch-ein-langer-zufallswert…"
+```
+
+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.
+>
+> **`APP_URL` später zu ändern** macht bestehende **Passkeys ungültig**, weil
+> sie an die rpID gebunden sind. Passwörter funktionieren weiter.
+
+### Welche Ports überhaupt hinausgehen
+
+Nach einer regulären Installation ist es **genau einer**:
+
+| 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
+```
+
+```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
+
+```bash
+docker compose --profile full up -d --build
+```
+
+Der erste Bau dauert ein paar Minuten. Der Container spielt beim Start
+selbst die Migrationen ein und wartet dabei auf die Datenbank.
+
+```bash
+docker compose --profile full logs -f app     # mitlesen, Strg+C beendet nur das Lesen
+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
+vorübergehend über einen SSH-Tunnel:
+
+```bash
+ssh -L 3000:127.0.0.1:3000 benutzer@server
+# dann lokal http://localhost:3000/setup öffnen
+```
+
+Dort legst du das Administratorkonto an und wählst die Betriebsart.
+**Danach ist `/setup` dauerhaft gesperrt.**
+
+Anschließend gleich unter *Mein Konto*:
+
+1. **Passkey hinzufügen** — geht erst, wenn TLS steht
+2. **Zwei-Faktor einrichten** und die Wiederherstellungscodes wegschreiben
+
+## 6 · Reverse Proxy mit TLS
+
+Nebula bringt keinen eigenen TLS-Abschluss mit. Beispiel mit **Caddy**, das
+Zertifikate von selbst besorgt und erneuert:
+
+```caddyfile
+# /etc/caddy/Caddyfile
+nebula.deine-domain.de {
+    reverse_proxy 127.0.0.1:3000
+}
+```
+
+```bash
+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>
+
+```nginx
+server {
+    listen 443 ssl http2;
+    server_name nebula.deine-domain.de;
+
+    ssl_certificate     /etc/letsencrypt/live/nebula.deine-domain.de/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/nebula.deine-domain.de/privkey.pem;
+
+    location / {
+        proxy_pass http://127.0.0.1:3000;
+        proxy_set_header Host              $host;
+        proxy_set_header X-Real-IP         $remote_addr;
+        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+Zertifikat mit `certbot --nginx -d nebula.deine-domain.de`.
+</details>
+
+> Steht `APP_URL` auf `https://…`, setzt Nebula das `Secure`-Flag auf die
+> Sitzungscookies. Läuft der Proxy auf `https`, die `APP_URL` aber noch auf
+> `http`, funktioniert die Anmeldung — nur ohne dieses Flag. Also beides
+> gleichziehen.
+
+## 7 · Firewall
+
+```bash
+sudo ufw allow 22/tcp
+sudo ufw allow 80,443/tcp
+sudo ufw enable
+```
+
+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
+
+`scripts/backup.sh` legt einen `pg_dump` unter `backups/` ab. Täglich per
+Cron:
+
+```bash
+crontab -e
+```
+
+```cron
+# Jede Nacht um 3:15 sichern, 30 Tage aufheben
+15 3 * * * cd /opt/nebula && ./scripts/backup.sh >> /var/log/nebula-backup.log 2>&1
+30 3 * * * find /opt/nebula/backups -name '*.sql.gz' -mtime +30 -delete
+```
+
+Zurückspielen:
+
+```bash
+./scripts/restore.sh backups/nebula-2026-07-27-03-15-00.sql.gz
+```
+
+> Die Sicherungen liegen auf **demselben Server**. Das hilft gegen einen
+> verpatzten Import, nicht gegen einen Plattenausfall. Zieh sie regelmäßig
+> woandershin — `rsync`, `restic`, was du ohnehin nutzt.
+
+---
+
+## Updates
+
+Dafür gibt es `scripts/update.sh`. Es macht alles in der richtigen
+Reihenfolge und bricht ab, sobald ein Schritt scheitert:
+
+```bash
+cd /opt/nebula
+./scripts/update.sh
+```
+
+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 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 --no-pull        # nur neu bauen, ohne git pull
+```
+
+### Wenn doch etwas schiefgeht
+
+```bash
+# Zurück auf den vorigen Stand (die Kennung nennt das Skript beim Abbruch)
+git checkout <kennung>
+./scripts/update.sh --no-pull --yes
+
+# Nur wenn eine Migration die Daten beschädigt hat:
+./scripts/restore.sh backups/<die-sicherung-von-vorhin>.sql.gz
+```
+
+> **Migrationen werden nicht zurückgerollt.** Eine Migration, die eine Spalte
+> entfernt, ist nicht umkehrbar — deshalb sichert das Skript vorher. Steht
+> ein Update mit Datenmigration an, lies vorher den Änderungsverlauf
+> (Versionsnummer in der Fußzeile).
+
+---
+
+## Betrieb
+
+### Zustand ansehen
+
+```bash
+docker compose --profile full ps
+docker compose --profile full logs -f app
+curl -s localhost:3000/api/health
+```
+
+### Neu starten
+
+```bash
+docker compose --profile full restart app
+```
+
+### Speicher- und Plattenverbrauch
+
+```bash
+docker stats --no-stream nebula-app nebula-db
+docker system df
+docker image prune -f          # alte Abbilder nach mehreren Updates
+```
+
+### Automatischer Abgleich
+
+Standardmäßig **aus**. Einzuschalten unter *Admin-Einstellungen →
+Automatischer Abgleich*: Abstand, Repositories je Durchlauf, ob fertige
+Projekte ausgelassen werden. Der Zeitgeber läuft im Serverprozess selbst —
+kein zusätzlicher Container, kein Cron.
+
+Wer lieber von außen taktet, lässt ihn aus und ruft
+`POST /api/admin/sync/run` auf.
+
+---
+
+## Härtung, die schon eingebaut ist
+
+Damit du weißt, worum du dich **nicht** kümmern musst:
+
+- Der Container läuft als **unprivilegierter Benutzer** (`nextjs`, UID 1001),
+  nicht als root.
+- **Content-Security-Policy** mit Nonce, `strict-dynamic` und ohne
+  `unsafe-inline` für Skripte.
+- **CSRF-Prüfung** über `Sec-Fetch-Site`/`Origin` bei jedem schreibenden
+  Zugriff.
+- **SSRF-Schutz** bei allen ausgehenden Aufrufen: jede Adresse wird
+  aufgelöst und gegen Loopback, Link-Local und Metadaten-Endpunkte geprüft,
+  Weiterleitungen eingeschlossen.
+- **Ratenbegrenzung** auf Anmeldung, ausgehende Abrufe und schreibende
+  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.
+- Der **Bildoptimierer** von Next ist abgeschaltet: Nebula benutzt ihn nicht,
+  und `/_next/image` wäre sonst eine Angriffsfläche ohne Gegenwert.
+
+### Was du beisteuern musst
+
+- **TLS** über den Reverse Proxy
+- **`APP_SECRET`** lang und zufällig
+- **Datenbankport** nicht nach außen öffnen
+- **Sicherungen** wegschaffen
+- **Systemupdates**: `unattended-upgrades` für das Betriebssystem,
+  `./scripts/update.sh` für Nebula
+
+---
+
+## Mehrbenutzerbetrieb
+
+Nebula kann beides. Im Einzelbetrieb gibt es genau ein Konto und keine
+Registrierung. Umschalten unter *Admin-Einstellungen*.
+
+Wichtig zu wissen: **Projekte sind zwischen Konten hart getrennt.** Auch ein
+Administrator sieht fremde Projekte nicht — er verwaltet Konten, keine
+Inhalte. Wer gemeinsam an einem Projekt arbeiten will, ist mit Nebula falsch
+beraten; das ist [bewusst nicht](ROADMAP.md) vorgesehen.
+
+Die Selbstregistrierung ist standardmäßig aus. Lass sie aus, wenn die
+Instanz aus dem Internet erreichbar ist und du nicht willst, dass sich
+Fremde Konten anlegen.

FEATURES.md

@@ -109,13 +109,31 @@ 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**.
+- **Vier Ansichten**: freies Raster, **kompakte Liste**, 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
@@ -138,6 +156,50 @@ Bedienung über Tastatur: Pfeile wählen, `Enter` öffnet, `Esc` schließt. Die
 wird beim ersten Öffnen geholt und dann behalten — sie bei jedem Tastendruck neu zu laden
 wäre Verschwendung.
 
+### Projektvorlagen
+
+Ein Projekt, das sich bewährt hat, lässt sich im Projektkopf über **Als Vorlage sichern**
+festhalten: Status, Priorität, Farbe, Tags, Notizen und offene Aufgaben. Beim Anlegen eines
+neuen Projekts steht die Vorlage oben im Dialog zur Auswahl.
+
+Bewusst benutzereigen statt fest eingebaut — welche Tags und welche Startaufgaben sinnvoll
+sind, weiß nur, wer damit arbeitet. Eine mitgelieferte Liste wäre geraten.
+
+- **Erledigte Aufgaben kommen nicht mit.** Eine Vorlage beschreibt, was zu tun ist, nicht
+  was einmal getan wurde.
+- **Repositories gehen nicht mit.** Eine Vorlage, die jedes neue Projekt an dasselbe
+  Repository hängt, wäre eine Falle.
+- Die Stammdaten füllt der Dialog **sichtbar** in die Felder, damit sie vor dem Speichern
+  noch änderbar sind; bereits Getipptes wird nicht überschrieben. Notizen und Aufgaben legt
+  erst der Server an — im Dialog ließen sie sich nicht darstellen.
+- Vorlagen überleben das Löschen ihres Ursprungsprojekts.
+
+### Mehrfachauswahl
+
+Ein Kästchen auf jeder Karte — es erscheint erst beim Überfahren, damit nicht auf jeder
+Karte dauerhaft eines steht. Sobald etwas ausgewählt ist, fährt unten eine Leiste ein:
+**Status setzen**, **Tags ergänzen oder entfernen**, **als Favorit markieren**, **löschen**.
+
+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
@@ -147,8 +209,15 @@ erst danach gespeichert; scheitert das Speichern, springt die Karte zurück.
   normaler Link.
 - Das Ziehen startet erst nach ein paar Pixeln Bewegung, damit Klicks weiter funktionieren.
   Auf Touchgeräten nach kurzem Halten.
-- Die Reihenfolge innerhalb einer Spalte folgt der gewählten Sortierung. Frei sortieren
+- **Freie Reihenfolge innerhalb einer Spalte.** Die Position wird am Projekt gespeichert,
-  ginge nur mit einer gespeicherten Position — bewusst nicht gebaut.
+  wie beim Aufgabenbrett. Deshalb ist die Sortierung im Kopf in dieser Ansicht abgeschaltet
+  — sie stehen zu lassen, ohne dass sie wirkt, wäre irreführend.
+- Reines Umsortieren fasst das Änderungsdatum **nicht** an. Sonst schöbe ein Aufräumen im
+  Brett sämtliche Projekte in der Sortierung „Zuletzt geändert“ nach oben.
+- Neue, importierte und per Status verschobene Projekte landen am Ende ihrer Spalte.
+- **Ansicht, Sortierung und Archivschalter überdauern das Neuladen** (im Browser
+  gespeichert, nicht am Konto). Der Suchbegriff bleibt bewusst außen vor — eine Suche von
+  gestern beim Öffnen wiederherzustellen wäre eher verwirrend als hilfreich.
 
 ### Projektkarte auf einen Blick
 
@@ -173,6 +242,23 @@ Blockiert · Erledigt**.
 - Erledigtes wird durchgestrichen; der Zeitpunkt wird festgehalten und beim Zurückziehen
   wieder gelöscht.
 
+### Wiederkehrende Aufgaben
+
+Täglich, wöchentlich, alle zwei Wochen oder monatlich. Wandert die Aufgabe nach
+**Erledigt** — im Dialog oder durch Ziehen —, entsteht die nächste von selbst. Die
+erledigte bleibt stehen, sonst ginge die Historie verloren.
+
+- **Gerechnet wird vom Fälligkeitsdatum, nicht vom Abhaken.** Eine wöchentliche Aufgabe
+  bleibt auf ihrem Montag, auch wenn sie einmal erst am Mittwoch erledigt wurde.
+- Lange Liegengebliebenes rutscht so weit vor, bis der Termin in der Zukunft liegt — eine
+  Aufgabe, die schon bei ihrer Entstehung überfällig ist, hilft niemandem.
+- Beim Monatsintervall bleibt der Tag im Monat erhalten. Der 31. Januar wird zum
+  28. Februar, nicht zum 3. März.
+- Nur der **Übergang** nach Erledigt löst aus. Eine bereits erledigte Aufgabe erneut zu
+  speichern erzeugt keine zweite Fassung.
+- Bewusst grob gehalten: feinere Regeln („jeden zweiten Dienstag im Monat") braucht ein
+  Projektdashboard nicht und wären ohne Kalenderansicht kaum nachvollziehbar.
+
 ### Aus Git-Issues übernehmen
 
 Im Git-Panel, Reiter *Issues*: ein Klick macht aus den offenen Issues Aufgaben — Titel,
@@ -204,6 +290,46 @@ 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).
+
+---
+
 ## 3. Notizen
 
 - **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
@@ -248,6 +374,29 @@ App und Infrastruktur. Sie gehören trotzdem in **eine** Karte.
 Der Projektdialog bearbeitet weiterhin nur das führende Repository; weitere verwaltet das
 Git-Panel. Beim Anlegen eines Projekts entsteht aus den Git-Feldern das erste.
 
+### 4.0a README-Vorschau
+
+Das README des führenden Repositories steht auf der Projektseite — man muss nicht ins Git
+wechseln, nur um zu sehen, worum ein halbvergessenes Projekt eigentlich ging. Lange
+READMEs sind eingeklappt, ein Knopf zeigt alles.
+
+- Geholt wird **höchstens einmal am Tag**, wie die Heatmap. GitHub hat einen eigenen
+  Endpunkt, der jede Schreibweise findet; bei GitLab und Gitea braucht es zwei Aufrufe
+  (Wurzelverzeichnis auflisten, dann die Datei holen).
+- Erkannt werden `README.md` und die üblichen Varianten, Groß- und Kleinschreibung egal.
+  Markdown hat Vorrang — nur das lässt sich wirklich darstellen.
+- Bei 60 000 Zeichen wird an einer **Zeilengrenze** abgeschnitten, damit kein halber
+  Codeblock stehen bleibt.
+- **Relative Links** werden gegen das Verzeichnis der Datei im Repository aufgelöst, sonst
+  liefen sie ins Leere.
+- **Bilder werden nicht geladen.** Die Content-Security-Policy erlaubt `img-src` nur von
+  der eigenen Instanz; sie dafür zu öffnen hieße, jedem fremden README das Nachladen
+  beliebiger Bilder zu gestatten — also auch Zählpixeln. Für Abzeichen und
+  Bildschirmfotos, die in einer Vorschau ohnehin Beiwerk sind, ist das kein guter Tausch.
+  Stattdessen steht ein anklickbarer Verweis mit dem Alternativtext.
+- Der Inhalt stammt aus einem fremden Repository und läuft deshalb durch dieselbe
+  Bereinigung wie Notizen (`rehype-sanitize`).
+
 ### 4.1 Unterstützte Systeme
 
 | System | API | Authentifizierung | Besonderheit |
@@ -285,6 +434,7 @@ Firmen-Gitea nebeneinander.
 | Tags | bis zu 25, mit SHA, Nachricht und Datum |
 | Commits | die letzten 15 zur Anzeige; geholt werden 100 für die Aktivitätskurve |
 | **Commit-Aktivität** | Balkenreihe der letzten Tage, auf Karte und Projektseite |
+| **Commit-Heatmap** | Ein Feld je Tag über bis zu ein Jahr, auf der Projektseite |
 | Releases | bis zu 10, inklusive Pre-Release- und Draft-Kennzeichnung |
 | Sprachen | Verteilung als Balken mit Prozentwerten |
 
@@ -311,9 +461,19 @@ bewusste Entscheidung sein. Einschalten in den Admin-Einstellungen.
 | Einstellung | Bedeutung |
 | --- | --- |
 | Abstand | 15 Minuten bis täglich |
-| Projekte je Durchlauf | 1–100, Voreinstellung 25 |
+| Repositories je Durchlauf | 1–100, Voreinstellung 25 |
 | Fertige und archivierte auslassen | Dort ändert sich selten noch etwas |
 
+Gezählt und begrenzt wird je **Repository**, nicht je Projekt: sonst zöge ein Projekt mit
+fünf Repos fünfmal so viele Anfragen nach sich, wie sein Platz im Kontingent hergibt.
+
+Die Daten für die **Heatmap** kommen getrennt und höchstens einmal am Tag — an einem
+Jahresüberblick ändert sich von Stunde zu Stunde nichts Sichtbares. Bei GitHub genügt dafür
+ein Aufruf der Jahresstatistik; GitLab und Gitea kennen keine, dort werden bis zu fünf
+Seiten Commits geholt. Reicht das nicht ein Jahr zurück, **beginnt die Heatmap beim
+ältesten bekannten Commit** und sagt es dazu — leere Felder für Zeiträume zu zeichnen, über
+die nichts bekannt ist, wäre eine Lüge.
+
 Wie der Durchlauf arbeitet:
 
 - Der Zeitgeber läuft im Serverprozess selbst (`instrumentation.ts`), prüft minütlich, ob
@@ -343,6 +503,78 @@ 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** über Webhooks, siehe unten.
+
+**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
@@ -457,10 +689,24 @@ letzten Zustellung stehen an der Karte.
 - **Animationen**: gestaffelt einblendende Karten, Hover-Lift mit Farbverlaufsrand,
   animierte Fortschrittsbalken.
 - **Responsiv** von Handy bis Ultrawide (bis zu vier Kartenspalten).
-- **Barrierearm**: durchgehende ARIA-Labels, Escape schließt Dialoge, sichtbarer
+- **Barrierefrei nach WCAG 2.1 AA**, und zwar geprüft statt behauptet: axe-core läuft über
-  Fokusring, `prefers-reduced-motion` schaltet Animationen ab.
+  zehn Seitenzustände einschließlich der Dialoge und meldet keine Verstöße. Durchgehende
+  ARIA-Labels, Escape schließt Dialoge, sichtbarer Fokusring, `prefers-reduced-motion`
+  schaltet Animationen ab.
+  Bei der ersten Durchsicht fielen 26 Kontrastverstöße auf: gedämpfter Text erreichte auf
+  dem sehr dunklen Untergrund nur 3,8 statt 4,5 zu 1. Statt an hundert Stellen die Klasse
+  zu tauschen, sind die beiden gedämpften Stufen im Theme aufgehellt — der Abstand
+  zwischen ihnen bleibt sichtbar.
 - **Deutschsprachig**, Datums- und Zahlenformate in `de-DE` mit fester Zeitzone
   Europe/Berlin, damit Server- und Browser-Darstellung übereinstimmen.
+- **Als App installierbar.** Ein Web-Manifest mit eigenen Symbolen — auf dem Handy
+  „Zum Startbildschirm hinzufügen“, danach läuft Nebula ohne Adressleiste. Die
+  maskierbare Fassung hat mehr Rand, weil Android Symbole je nach Gerät rund, eckig
+  oder als Tropfen zuschneidet.
+- **Änderungsverlauf** hinter der Versionsnummer in der Fußzeile: was neu ist, was besser
+  wurde und welche Fehler behoben sind. Die Liste steht in `src/lib/changelog.ts` und ist
+  die einzige Quelle — ein Test hält sie und `package.json` zusammen, weil genau diese
+  beiden Angaben hier schon einmal auseinandergelaufen sind.
 
 ---
 
@@ -479,7 +725,8 @@ letzten Zustellung stehen an der Karte.
 | `AppSettings` | Betriebsart und Registrierung (eine Zeile) |
 | `Project` | Projektstammdaten, Status, Fortschritt, Besitzer |
 | `Repository` | Repositories eines Projekts inkl. Abgleichstand (n:1 zu Projekt) |
-| `Task` | Aufgaben mit Spalte, Position, Fälligkeit, Labels und Issue-Herkunft |
+| `Task` | Aufgaben mit Spalte, Position, Fälligkeit, Labels, Wiederholung und Issue-Herkunft |
+| `ProjectTemplate` | Vorlagen je Konto: Stammdaten, Tags, Notizen und Aufgaben |
 | `Activity` | Verlauf je Projekt, neueste zuerst, auf 200 Einträge begrenzt |
 | `NotificationTarget` | Zustellwege je Konto, mit verschlüsseltem Geheimnis |
 | `Note` | Notizen (n:1 zu Projekt, Cascade-Delete) |

README.md

@@ -31,7 +31,8 @@ Alle Daten liegen in **deiner lokalen PostgreSQL**. Es gibt keinen Cloud-Dienst
 Access Tokens werden verschlüsselt abgelegt.
 
 Eine vollständige Auflistung aller Funktionen steht in **[FEATURES.md](FEATURES.md)**,
-geplante Erweiterungen in **[ROADMAP.md](ROADMAP.md)**.
+geplante Erweiterungen in **[ROADMAP.md](ROADMAP.md)**. Für den Dauerbetrieb auf einem
+Server — TLS, Firewall, Sicherungen und Updates — gibt es **[DEPLOYMENT.md](DEPLOYMENT.md)**.
 
 ---
 
@@ -51,7 +52,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
@@ -119,10 +120,10 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
 | `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
 | `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` |
+| `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`) | `8080` |
+| `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` |
@@ -306,7 +307,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` |
 
@@ -341,6 +342,9 @@ ausschließlich Daten des angemeldeten Kontos.
 | `GET` | `/api/projects/export` | Alle eigenen Projekte als JSON |
 | `GET` | `/api/projects/:id/export` | Ein Projekt (`?format=md` für Markdown) |
 | `POST` | `/api/projects/import` | Import, mit `dryRun` für die Vorschau |
+| `GET` `POST` | `/api/templates` | Projektvorlagen auflisten / anlegen |
+| `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` `POST` | `/api/notifications` | Benachrichtigungsziele |
@@ -348,6 +352,8 @@ ausschließlich Daten des angemeldeten Kontos.
 | `POST` | `/api/notifications/:id/test` | Testnachricht senden |
 | `GET` `PATCH` `DELETE` | `/api/projects/:id` | Projekt lesen / ändern / löschen |
 | `POST` | `/api/projects/:id/sync` | Alle Repositories des Projekts abgleichen |
+| `PATCH` | `/api/projects/reorder` | Neue Reihenfolge im Brett |
+| `POST` | `/api/projects/bulk` | Status, Tags oder Löschen für mehrere |
 | `GET` | `/api/projects/:id/activity` | Verlauf des Projekts (`?limit=`) |
 | `GET` `POST` | `/api/projects/:id/repositories` | Repositories des Projekts |
 | `PATCH` `DELETE` | `/api/repositories/:id` | Repository ändern / vom Projekt lösen |
@@ -410,7 +416,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" |

ROADMAP.md

@@ -11,68 +11,98 @@ Was bereits steht, listet [FEATURES.md](FEATURES.md).
 
 ## 1 · Als Nächstes empfohlen
 
-### 1.1 Webhooks statt Polling `M`
+### 1.0 Rest aus v1.6.0: persönliche API-Token `M`
 
-Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
+Schnellerfassung und die projektübergreifende Aufgabenseite sind mit v1.6.0
-zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
+ausgeliefert. Offen bleibt der dritte Teil — siehe 1.3. Er gehört sachlich
-Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
+dazu: erfassen am Telefon, überblicken an einer Stelle, ansprechen per
-erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
+Shortcut.
+
+Bewusst nicht mitgeliefert wurde ein **Index für die übergreifende
+Aufgabenabfrage**. `Task` hat kein `ownerId`, die Trennung läuft über
+`project: { ownerId }`, und `[projectId, status, position]` greift dafür
+nicht. Bei einigen hundert Aufgaben fällt das nicht auf; wird die Seite
+träge, ist ein Index auf `dueDate` der erste Griff — und dann eine
+Migration wert.
 
 ---
 
-## 2 · Danach
+### 1.2 Läuft es noch? `M`
 
-### 2.1 Commit-Aktivität als Heatmap `S`
+Eine Health-Check-URL je Projekt, die der Zeitgeber regelmäßig anpingt.
+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.
 
-Die Sparkline gibt es auf Karte und Projektseite. Eine Heatmap über ein Jahr
+### 1.3 Persönliche API-Token `M`
-wäre die nächste Ausbaustufe — dafür braucht es allerdings mehr als eine
-Seite Commits, also Paginierung oder die Statistik-Endpunkte.
 
-### 2.2 Kanban mit freier Reihenfolge `M`
+Derzeit geht die API nur mit Sitzungscookie. Ein Token je Konto würde
-
+`curl`-Aufrufe und Handy-Shortcuts erlauben — Idee aus dem Terminal anlegen,
-Heute folgt die Reihenfolge innerhalb einer Spalte der gewählten Sortierung.
+ohne den Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den
-Frei sortieren hieße, eine Position je Projekt zu speichern.
+Sitzungen.
 
 ---
 
-## 3 · Größere Brocken
+### 1.4 Aufgaben ↔ Issues: was noch fehlt `S`
 
-### 3.1 Passwort-Zurücksetzen per E-Mail `M`
+Mit v1.7.0 stehen beide Richtungen: „als Issue anlegen“ und der Rückweg über
+Webhooks. Offen geblieben ist Kleinkram:
+
+- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
+  Projekt aus Frontend und Backend fehlt die Wahl.
+- **Beim Übernehmen aus Issues** wird der Rückweg nicht automatisch
+  eingerichtet — der Webhook ist getrennt zu setzen.
+
+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.
+
+---
+
+## 2 · Größere Brocken
+
+### 2.1 Passwort-Zurücksetzen per E-Mail `M`
 
 Heute setzt ein Administrator das Passwort neu. Selbstbedienung braucht SMTP
 und damit eine weitere Konfiguration — lohnt erst im Mehrbenutzerbetrieb.
 
-### 3.4 Mehrsprachigkeit `L`
+### 2.2 Mehrsprachigkeit `L`
 
 Die Oberfläche ist durchgängig deutsch verdrahtet. Englisch dazu wäre eine
 Voraussetzung, falls du das Projekt veröffentlichen willst.
 
 ---
 
-## 4 · Kleinigkeiten
+## 3 · 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 |
-| Mehrfachauswahl im Board | `S` | Status oder Tags für mehrere auf einmal |
+| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt — fällt weitgehend mit 1.4 ab |
-| Wiederkehrende Aufgaben | `M` | Etwa „jeden Montag Abhängigkeiten prüfen" |
+| Tastaturkürzel-Übersicht mit `?` | `S` | Es gibt inzwischen genug davon |
-| Projektvorlagen | `S` | Neues Projekt mit vorgefüllten Tags und Notizen |
 | Hell/Dunkel umschaltbar | `M` | Aktuell nur dunkel |
 | Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
-| PWA-Manifest | `S` | Auf dem Handy als App installierbar |
-| Barrierefreiheits-Durchsicht | `M` | Fokusreihenfolge, Screenreader, Kontraste |
-| `prisma.config.ts` | `S` | Beseitigt die Deprecation-Warnung vor Prisma 7. Achtung: danach lädt Prisma die `.env` nicht mehr von selbst |
 | Audit-Log für Adminaktionen | `M` | Nachvollziehbar, wer Konten geändert hat |
 
 ---
 
-## 5 · Bewusst nicht
+## 4 · Bewusst nicht
 
 Damit klar ist, was **nicht** kommt und warum:
 
 - **Geteilte Projekte zwischen Konten.** Die Trennung ist derzeit hart und
   einfach zu prüfen. Freigaben bringen eine Rechteverwaltung mit sich — nur
   sinnvoll, wenn wirklich mehrere Leute zusammenarbeiten.
+- **Veraltete Abhängigkeiten prüfen.** Klingt verlockend, aber Renovate und
+  Dependabot machen das besser, und es wären viele Aufrufe an fremde
+  Registries — für eine Zahl, die im Repo selbst schon steht.
+- **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.
 - **Zeiterfassung, Rechnungen, Kundenverwaltung.** Andere Baustelle.
@@ -101,6 +131,13 @@ Damit klar ist, was **nicht** kommt und warum:
 | **v0.8.0** Stillstehende Projekte melden, Schwelle im Adminbereich | ✓ |
 | **v0.9.0** Schnellsuche per `Strg+K`, Aufgaben aus Git-Issues | ✓ |
 | **v1.0.0** Aktivitätsverlauf je Projekt, Zwei-Faktor per TOTP, mehrere Repositories je Projekt | ✓ |
+| **v1.1.0** Freie Reihenfolge im Brett, Mehrfachauswahl, installierbar als App, Änderungsverlauf | ✓ |
+| **v1.2.0** Commit-Heatmap über ein Jahr, Projektvorlagen | ✓ |
+| **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 | ✓ |
 
 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:
+#  1) Alles im Container (Server wie Entwicklung):
-#       docker compose up -d db
+#       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:
+#  3) Server ohne jede Portfreigabe, hinter einem Reverse Proxy im
-#       docker compose --profile full up -d --build
+#     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:
+    # Absichtlich keine Portfreigabe: die Anwendung erreicht die Datenbank im
-      - "${POSTGRES_PORT:-5432}:5432"
+    # 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

@@ -279,6 +279,375 @@ test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
   expect(zumSchluss.repositories[0].repoName).toBe("swr");
 });
 
+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);
+
+  const angelegt = [];
+  for (const name of ["Brett A", "Brett B", "Brett C"]) {
+    const response = await request.post("/api/projects", { data: { name, status: "IDEA" } });
+    angelegt.push((await response.json()).project);
+  }
+  // Neue Projekte haengen sich hinten an ihre Spalte an – fortlaufend, nicht
+  // alle auf denselben Platz. Absolut zaehlen laesst sich nicht: in der
+  // Spalte stehen schon Projekte aus frueheren Tests.
+  const [a, b, c] = angelegt.map((p) => p.position);
+  expect([b, c]).toEqual([a + 1, a + 2]);
+
+  const ids = angelegt.map((p) => p.id);
+  const vorher = angelegt[0].updatedAt;
+
+  // Umdrehen und dabei eines in eine andere Spalte schieben.
+  const gedreht = [ids[2], ids[1]];
+  const reorder = await request.patch("/api/projects/reorder", {
+    data: { columns: { IDEA: gedreht, IN_DEVELOPMENT: [ids[0]] } },
+  });
+  expect(reorder.ok()).toBeTruthy();
+
+  const alle = (await (await request.get("/api/projects")).json()).projects;
+  const finde = (id: string) => alle.find((p: { id: string }) => p.id === id);
+  expect(finde(ids[2]).position).toBe(0);
+  expect(finde(ids[1]).position).toBe(1);
+  expect(finde(ids[0]).status).toBe("IN_DEVELOPMENT");
+
+  // Reines Umsortieren darf das Aenderungsdatum nicht anfassen – sonst
+  // schoebe ein Aufraeumen im Brett alles in "Zuletzt geaendert" nach oben.
+  expect(new Date(finde(ids[1]).updatedAt).getTime()).toBe(
+    new Date(angelegt[1].updatedAt).getTime(),
+  );
+  // Das verschobene dagegen hat sich wirklich geaendert.
+  expect(new Date(finde(ids[0]).updatedAt).getTime()).toBeGreaterThan(
+    new Date(vorher).getTime(),
+  );
+
+  // Mehrfachauswahl: Tags ergaenzen und wieder entfernen.
+  const ergaenzt = await request.post("/api/projects/bulk", {
+    data: { ids, action: "tags", tags: ["Sammel", "test"], tagMode: "add" },
+  });
+  expect((await ergaenzt.json()).changed).toBe(3);
+  const mitTags = (await (await request.get("/api/projects")).json()).projects;
+  // Kleingeschrieben abgelegt, wie ueberall.
+  expect(mitTags.find((p: { id: string }) => p.id === ids[0]).tags).toContain("sammel");
+
+  const entfernt = await request.post("/api/projects/bulk", {
+    data: { ids, action: "tags", tags: ["sammel"], tagMode: "remove" },
+  });
+  expect((await entfernt.json()).changed).toBe(3);
+
+  // Status fuer mehrere: die Verschobenen landen hintereinander, nicht
+  // uebereinander auf derselben Position.
+  const verschoben = await request.post("/api/projects/bulk", {
+    data: { ids, action: "status", status: "PLANNING" },
+  });
+  expect((await verschoben.json()).changed).toBe(3);
+  const geplant = (await (await request.get("/api/projects?status=PLANNING")).json()).projects;
+  const positionen = geplant.map((p: { position: number }) => p.position).sort();
+  expect(new Set(positionen).size).toBe(positionen.length);
+
+  // Wer schon so steht, wird nicht noch einmal angefasst.
+  const nochmal = await request.post("/api/projects/bulk", {
+    data: { ids, action: "status", status: "PLANNING" },
+  });
+  expect((await nochmal.json()).changed).toBe(0);
+
+  // Fremde IDs fallen still unter den Tisch, statt etwas anzurichten.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  const untergeschoben = await fremd.post("/api/projects/bulk", {
+    data: { ids, action: "delete" },
+  });
+  expect((await untergeschoben.json()).changed).toBe(0);
+  const uebrig = (await (await request.get("/api/projects")).json()).projects;
+  expect(uebrig.filter((p: { id: string }) => ids.includes(p.id))).toHaveLength(3);
+
+  const fremdSortieren = await fremd.patch("/api/projects/reorder", {
+    data: { columns: { DONE: ids } },
+  });
+  expect((await fremdSortieren.json()).updated).toBe(0);
+  await fremd.dispose();
+
+  // Und zum Schluss die eigenen wirklich loeschen.
+  const geloescht = await request.post("/api/projects/bulk", {
+    data: { ids, action: "delete" },
+  });
+  expect((await geloescht.json()).changed).toBe(3);
+});
+
+test("Wiederkehrende Aufgaben legen die naechste Fassung an", async ({ request }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Wiederkehrend" } })).json()
+  ).project;
+
+  const woechentlich = (
+    await (
+      await request.post(`/api/projects/${projekt.id}/tasks`, {
+        data: {
+          title: "Abhaengigkeiten pruefen",
+          dueDate: "2026-07-06T12:00:00",
+          recurrence: "WEEKLY",
+          labels: ["wartung"],
+        },
+      })
+    ).json()
+  ).task;
+
+  // Ein Zwischenschritt loest noch nichts aus.
+  await request.patch(`/api/tasks/${woechentlich.id}`, { data: { status: "DOING" } });
+  let alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(alle).toHaveLength(1);
+
+  // Erst der Uebergang nach ERLEDIGT.
+  const erledigt = await request.patch(`/api/tasks/${woechentlich.id}`, {
+    data: { status: "DONE" },
+  });
+  expect((await erledigt.json()).next).not.toBeNull();
+
+  alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(alle).toHaveLength(2);
+
+  const folge = alle.find((task: { id: string }) => task.id !== woechentlich.id);
+  expect(folge.status).toBe("TODO");
+  expect(folge.title).toBe("Abhaengigkeiten pruefen");
+  expect(folge.labels).toEqual(["wartung"]);
+  expect(folge.recurrence).toBe("WEEKLY");
+  expect(folge.recurredFrom).toBe(woechentlich.id);
+  // Der Termin liegt in der Zukunft und auf demselben Wochentag.
+  expect(new Date(folge.dueDate).getTime()).toBeGreaterThan(Date.now());
+  expect(new Date(folge.dueDate).getUTCDay()).toBe(1);
+
+  // Erneut speichern erzeugt keine dritte.
+  await request.patch(`/api/tasks/${woechentlich.id}`, { data: { title: "Umbenannt" } });
+  alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(alle).toHaveLength(2);
+
+  // Der zweite Weg: durch Ziehen in die Spalte ERLEDIGT.
+  const gezogen = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
+    data: { columns: { DONE: [folge.id] } },
+  });
+  expect(gezogen.ok()).toBeTruthy();
+
+  alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(alle).toHaveLength(3);
+  expect(alle.filter((task: { status: string }) => task.status === "TODO")).toHaveLength(1);
+
+  // Eine einmalige Aufgabe bleibt einmalig.
+  const einmalig = (
+    await (
+      await request.post(`/api/projects/${projekt.id}/tasks`, { data: { title: "Nur einmal" } })
+    ).json()
+  ).task;
+  await request.patch(`/api/tasks/${einmalig.id}`, { data: { status: "DONE" } });
+  alle = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(alle).toHaveLength(4);
+});
+
+test("Projektvorlagen: aus Projekt sichern und anwenden", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Ein Projekt herrichten, das als Vorlage taugt.
+  const quelle = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Vorlagenquelle", status: "PLANNING", priority: 3, tags: ["web", "docker"] },
+      })
+    ).json()
+  ).project;
+
+  await request.post(`/api/projects/${quelle.id}/notes`, {
+    data: { content: "Checkliste vor dem Start." },
+  });
+  const erledigt = (
+    await (
+      await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "Schon fertig" } })
+    ).json()
+  ).task;
+  await request.patch(`/api/tasks/${erledigt.id}`, { data: { status: "DONE" } });
+  await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "Repo anlegen" } });
+  await request.post(`/api/projects/${quelle.id}/tasks`, { data: { title: "CI einrichten" } });
+
+  const gesichert = await request.post("/api/templates/from-project", {
+    data: { projectId: quelle.id, name: "Web-App", description: "Mit Docker und CI" },
+  });
+  expect(gesichert.status()).toBe(201);
+  const vorlage = (await gesichert.json()).template;
+
+  expect(vorlage.tags).toEqual(["web", "docker"]);
+  expect(vorlage.status).toBe("PLANNING");
+  expect(vorlage.notes).toHaveLength(1);
+  // Erledigte Aufgaben kommen nicht mit: eine Vorlage beschreibt, was zu tun ist.
+  expect(vorlage.tasks).toHaveLength(2);
+  expect(vorlage.tasks.map((task: { title: string }) => task.title)).not.toContain("Schon fertig");
+
+  // Derselbe Name ein zweites Mal wird abgewiesen.
+  const doppelt = await request.post("/api/templates/from-project", {
+    data: { projectId: quelle.id, name: "Web-App" },
+  });
+  expect(doppelt.status()).toBe(409);
+
+  // Anwenden: Notizen und Aufgaben entstehen mit dem Projekt.
+  const neu = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Aus Vorlage", status: "IDEA", templateId: vorlage.id },
+      })
+    ).json()
+  ).project;
+
+  const geladen = (await (await request.get(`/api/projects/${neu.id}`)).json()).project;
+  expect(geladen.notes).toHaveLength(1);
+  expect(geladen.tasks).toHaveLength(2);
+  // Die Reihenfolge der Vorlage bleibt erhalten.
+  expect(geladen.tasks.map((task: { title: string }) => task.title)).toEqual([
+    "Repo anlegen",
+    "CI einrichten",
+  ]);
+  // Der ausdrueckliche Status gewinnt gegen den der Vorlage.
+  expect(geladen.status).toBe("IDEA");
+
+  // Der Verlauf haelt die Herkunft fest.
+  const verlauf = (await (await request.get(`/api/projects/${neu.id}/activity`)).json()).activities;
+  expect(verlauf.some((entry: { summary: string }) => entry.summary.includes("Web-App"))).toBe(true);
+
+  // Eine fremde Vorlage laesst sich nicht unterschieben.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await (await fremd.get("/api/templates")).json()).templates).toHaveLength(0);
+  const untergeschoben = await fremd.post("/api/projects", {
+    data: { name: "Klau", templateId: vorlage.id },
+  });
+  expect(untergeschoben.status()).toBe(404);
+  expect((await fremd.delete(`/api/templates/${vorlage.id}`)).status()).toBe(404);
+  await fremd.dispose();
+
+  // Und die Vorlage ueberlebt das Loeschen ihres Ursprungsprojekts.
+  await request.delete(`/api/projects/${quelle.id}`);
+  const nochDa = (await (await request.get("/api/templates")).json()).templates;
+  expect(nochDa).toHaveLength(1);
+
+  expect((await request.delete(`/api/templates/${vorlage.id}`)).ok()).toBeTruthy();
+});
+
+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
+  // nirgends – der Endpunkt darf ohne Anmeldung nicht antworten.
+  const anonym = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+    maxRedirects: 0,
+  });
+  const antwort = await anonym.get("/_next/image?url=%2Ficon-192.png&w=64&q=75");
+  expect(antwort.status(), "kein 200 ohne Anmeldung").not.toBe(200);
+  await anonym.dispose();
+});
+
 test("Export enthaelt keine Geheimnisse, Import beachtet die Strategie", async ({ request }) => {
   await login(request, ADMIN);
 

e2e/ui.spec.ts

@@ -72,9 +72,17 @@ test("Aufgaben anlegen und per Ziehen verschieben", async ({ page }) => {
   // dnd-kit wertet die Bewegung in einem eigenen Frame aus. Ohne diese
   // Pause faende das Loslassen noch kein Ziel und die Karte spraenge zurueck.
   await page.waitForTimeout(250);
+
+  // Auf die Antwort warten, bevor neu geladen wird. Sonst bricht das Neuladen
+  // den noch laufenden Aufruf ab, und der Test schlaegt gelegentlich fehl,
+  // obwohl die Anwendung in Ordnung ist – genau so ist es passiert.
+  const gespeichert = page.waitForResponse(
+    (response) => response.url().includes("/tasks/reorder") && response.request().method() === "PATCH",
+  );
   await page.mouse.up();
 
   await expect(inArbeit.getByText("Erste Aufgabe")).toBeVisible();
+  expect((await gespeichert).ok()).toBeTruthy();
 
   // Und der Server hat es auch so gespeichert.
   await page.reload();
@@ -98,6 +106,123 @@ 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("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   await page.keyboard.press("Control+k");
   await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
@@ -119,6 +244,73 @@ test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeHidden();
 });
 
+test("Mehrfachauswahl aendert mehrere Projekte auf einmal", async ({ page }) => {
+  const kaestchen = page.locator('input[aria-label$="auswaehlen"]');
+  const anzahl = await kaestchen.count();
+  expect(anzahl).toBeGreaterThan(0);
+
+  // Ohne Auswahl gibt es keine Leiste – sie soll nicht dauerhaft im Weg sein.
+  await expect(page.getByText(/ausgewählt/)).toBeHidden();
+
+  await kaestchen.first().check();
+  await expect(page.getByText("1 ausgewählt")).toBeVisible();
+
+  await page.getByRole("button", { name: "Tags", exact: true }).click();
+  await page.fill("#bulk-tags", "sammeltest");
+  await page.getByRole("button", { name: "Hinzufügen" }).click();
+
+  await expect(page.getByText("#sammeltest").first()).toBeVisible();
+  // Nach getaner Arbeit ist die Auswahl aufgehoben.
+  await expect(page.getByText(/ausgewählt/)).toBeHidden();
+});
+
+test("Die Versionsnummer oeffnet den Aenderungsverlauf", async ({ page }) => {
+  await page.getByRole("button", { name: /^v\d+\.\d+\.\d+$/ }).click();
+
+  // Ueber die Rolle, nicht ueber den Text: das Wort steht auch in einem der
+  // Eintraege, und ein blosser Textvergleich waere mehrdeutig.
+  const dialog = page.getByRole("dialog", { name: "Änderungsverlauf" });
+  await expect(dialog).toBeVisible();
+  // Die laufende Fassung ist als solche gekennzeichnet.
+  await expect(dialog.getByText("installiert")).toBeVisible();
+  // Und es steht wirklich etwas drin.
+  await expect(dialog.getByRole("heading", { level: 3 }).first()).toBeVisible();
+  await expect(dialog.getByText("Neu").first()).toBeVisible();
+
+  await page.keyboard.press("Escape");
+  await expect(dialog).toBeHidden();
+});
+
+test("Das Manifest liegt bereit, auch ohne Anmeldung", async ({ page, playwright }) => {
+  const anonym = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+
+  // Ohne diesen Weg an der Zugangsschranke vorbei liesse sich die Anwendung
+  // nicht installieren: der Browser holt das Manifest, bevor jemand angemeldet ist.
+  const antwort = await anonym.get("/manifest.webmanifest");
+  expect(antwort.ok()).toBeTruthy();
+
+  const manifest = await antwort.json();
+  expect(manifest.name).toContain("Nebula");
+  expect(manifest.display).toBe("standalone");
+  expect(manifest.icons.some((icon: { purpose: string }) => icon.purpose === "maskable")).toBe(true);
+
+  for (const icon of manifest.icons) {
+    const bild = await anonym.get(icon.src);
+    expect(bild.ok(), icon.src).toBeTruthy();
+    expect(bild.headers()["content-type"]).toContain("image/png");
+  }
+
+  await anonym.dispose();
+
+  // Die Seite muss ein Symbol verweisen. Fehlt es, sucht der Browser
+  // /favicon.ico – das es hier nicht gibt, und die Konsole fuellt sich mit
+  // 404ern. Genau das ist beim Ergaenzen des Apple-Symbols passiert.
+  await page.goto("/");
+  await expect(page.locator('link[rel="icon"]').first()).toHaveAttribute("href", /icon/);
+});
+
 test("Abmelden fuehrt zurueck zur Anmeldung", async ({ page }) => {
   await page.getByRole("button", { name: /Benutzermenue/ }).click();
   await page.getByRole("menuitem", { name: "Abmelden" }).click();

next.config.ts

@@ -9,6 +9,21 @@ const nextConfig: NextConfig = {
   poweredByHeader: false,
   // Prisma darf nicht gebundlet werden, sonst findet der Client seine Engine nicht.
   serverExternalPackages: ["@prisma/client", "prisma"],
+  images: {
+    /**
+     * Der Bildoptimierer ist abgeschaltet.
+     *
+     * Nebula benutzt next/image nirgends – die paar Symbole sind SVG und
+     * PNG in fester Groesse. Der Endpunkt /_next/image waere aber trotzdem
+     * da, und zwar ohne Anmeldung: die Middleware nimmt ihn aus, weil dort
+     * sonst nur Rechenzeit verbraucht wuerde.
+     *
+     * Er reicht jedes Bild durch sharp und damit durch libvips, fuer das es
+     * regelmaessig Schwachstellen gibt (aktuell CVE-2026-33327 und drei
+     * weitere). Eine Angriffsflaeche ohne Gegenwert – also weg damit.
+     */
+    unoptimized: true,
+  },
 };
 
 export default nextConfig;

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "nebula",
-  "version": "0.9.0",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "nebula",
-      "version": "0.9.0",
+      "version": "1.2.0",
       "hasInstallScript": true,
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",
@@ -34,6 +34,8 @@
         "@types/qrcode": "^1.5.6",
         "@types/react": "^19.1.5",
         "@types/react-dom": "^19.1.5",
+        "axe-core": "^4.12.1",
+        "dotenv": "^17.4.2",
         "prisma": "^6.8.2",
         "tailwindcss": "^4.1.7",
         "tsx": "^4.19.4",
@@ -2535,6 +2537,16 @@
         "node": ">=12"
       }
     },
+    "node_modules/axe-core": {
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.12.1.tgz",
+      "integrity": "sha512-s7iGf5GaVMxEG0ENN9x+xTr7GFZCb1ZP/1uATUpCEK2X78nDB3RwbtFCo9pGAf9ru+VwoQ464DkaLEeRM08wJA==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/bail": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
@@ -2574,6 +2586,19 @@
         }
       }
     },
+    "node_modules/c12/node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "devOptional": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
     "node_modules/camelcase": {
       "version": "5.3.1",
       "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
@@ -2866,10 +2891,10 @@
       "license": "MIT"
     },
     "node_modules/dotenv": {
-      "version": "16.6.1",
+      "version": "17.4.2",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.2.tgz",
-      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "integrity": "sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==",
-      "devOptional": true,
+      "dev": true,
       "license": "BSD-2-Clause",
       "engines": {
         "node": ">=12"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nebula",
-  "version": "1.0.0",
+  "version": "1.7.0",
   "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",
@@ -30,9 +30,6 @@
     "test:e2e:ui": "playwright test --ui",
     "test:all": "npm test && npm run test:e2e"
   },
-  "prisma": {
-    "seed": "tsx prisma/seed.ts"
-  },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
@@ -59,6 +56,8 @@
     "@types/qrcode": "^1.5.6",
     "@types/react": "^19.1.5",
     "@types/react-dom": "^19.1.5",
+    "axe-core": "^4.12.1",
+    "dotenv": "^17.4.2",
     "prisma": "^6.8.2",
     "tailwindcss": "^4.1.7",
     "tsx": "^4.19.4",

prisma.config.ts

@@ -0,0 +1,24 @@
+import { config as loadEnv } from "dotenv";
+import { defineConfig } from "prisma/config";
+
+/**
+ * Konfiguration der Prisma-CLI.
+ *
+ * Loest den Abschnitt `prisma` in der package.json ab, der mit Prisma 7
+ * wegfaellt.
+ *
+ * **Der Aufruf von dotenv ist nicht optional.** Sobald diese Datei
+ * existiert, liest Prisma die .env nicht mehr von selbst ein – ohne die
+ * folgenden Zeilen stuende `migrate deploy` plotzlich ohne DATABASE_URL da,
+ * und zwar mit einer Fehlermeldung, die nicht darauf hindeutet. Erst .env,
+ * dann .env.local: eine oertliche Abweichung soll gewinnen.
+ */
+loadEnv({ path: ".env", quiet: true });
+loadEnv({ path: ".env.local", override: true, quiet: true });
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  migrations: {
+    seed: "tsx prisma/seed.ts",
+  },
+});

prisma/migrations/20260726240000_project_position/migration.sql

@@ -0,0 +1,20 @@
+-- Freie Reihenfolge im Projektbrett.
+--
+-- Der Bestand bekommt seine Position aus der bisherigen Anzeige: je Konto und
+-- Spalte nach Aenderungsdatum absteigend. Ohne diesen Schritt staenden alle
+-- auf 0 und das Brett zeigte eine willkuerliche Reihenfolge, die sich bei
+-- jedem Laden anders ergeben koennte.
+
+ALTER TABLE "Project" ADD COLUMN "position" INTEGER NOT NULL DEFAULT 0;
+
+UPDATE "Project" AS p
+SET "position" = nummeriert.rang - 1
+FROM (
+    SELECT "id", ROW_NUMBER() OVER (
+        PARTITION BY "ownerId", "status" ORDER BY "updatedAt" DESC, "id"
+    ) AS rang
+    FROM "Project"
+) AS nummeriert
+WHERE nummeriert."id" = p."id";
+
+CREATE INDEX "Project_ownerId_status_position_idx" ON "Project"("ownerId", "status", "position");

prisma/migrations/20260726250000_commit_calendar/migration.sql

@@ -0,0 +1,3 @@
+-- AlterTable
+ALTER TABLE "RepoSnapshot" ADD COLUMN     "commitCalendar" JSONB NOT NULL DEFAULT '{}',
+ADD COLUMN     "commitCalendarAt" TIMESTAMP(3);

prisma/migrations/20260726260000_project_templates/migration.sql

@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "ProjectTemplate" (
+    "id" TEXT NOT NULL,
+    "ownerId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT,
+    "summary" TEXT,
+    "projectDescription" TEXT,
+    "status" "ProjectStatus" NOT NULL DEFAULT 'IDEA',
+    "priority" INTEGER NOT NULL DEFAULT 2,
+    "accent" TEXT NOT NULL DEFAULT 'violet',
+    "tags" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "progressFromTasks" BOOLEAN NOT NULL DEFAULT false,
+    "notes" JSONB NOT NULL DEFAULT '[]',
+    "tasks" JSONB NOT NULL DEFAULT '[]',
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "ProjectTemplate_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "ProjectTemplate_ownerId_idx" ON "ProjectTemplate"("ownerId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ProjectTemplate_ownerId_name_key" ON "ProjectTemplate"("ownerId", "name");
+
+-- AddForeignKey
+ALTER TABLE "ProjectTemplate" ADD CONSTRAINT "ProjectTemplate_ownerId_fkey" FOREIGN KEY ("ownerId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20260726270000_task_recurrence/migration.sql

@@ -0,0 +1,6 @@
+-- CreateEnum
+CREATE TYPE "Recurrence" AS ENUM ('DAILY', 'WEEKLY', 'BIWEEKLY', 'MONTHLY');
+
+-- AlterTable
+ALTER TABLE "Task" ADD COLUMN     "recurredFrom" TEXT,
+ADD COLUMN     "recurrence" "Recurrence";

prisma/migrations/20260726280000_repo_readme/migration.sql

@@ -0,0 +1,5 @@
+-- AlterTable
+ALTER TABLE "RepoSnapshot" ADD COLUMN     "readme" TEXT,
+ADD COLUMN     "readmeAt" TIMESTAMP(3),
+ADD COLUMN     "readmeBaseUrl" TEXT,
+ADD COLUMN     "readmePath" TEXT;

prisma/migrations/20260727000000_totp_replay/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "totpLastCounter" INTEGER;

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/schema.prisma

@@ -71,6 +71,16 @@ enum ActivityKind {
   SYNC_FAILED
 }
 
+/// Wie oft sich eine Aufgabe wiederholt. Bewusst grob: feinere Regeln
+/// (jeden zweiten Dienstag im Monat) braucht ein Projektdashboard nicht,
+/// und sie waeren ohne Kalenderansicht kaum nachvollziehbar.
+enum Recurrence {
+  DAILY
+  WEEKLY
+  BIWEEKLY
+  MONTHLY
+}
+
 /// Spalten des Aufgabenbretts innerhalb eines Projekts.
 enum TaskStatus {
   TODO
@@ -118,6 +128,10 @@ model User {
   /// sperrt sich aus, wer die Einrichtung abbricht.
   totpSecretCipher String?
   totpEnabledAt    DateTime?
+  /// Zuletzt eingeloestes Zeitfenster. RFC 6238 verlangt, denselben Code
+  /// kein zweites Mal anzunehmen – ohne diesen Merker liesse sich ein
+  /// abgefangener Code die restliche Gueltigkeit ueber wiederverwenden.
+  totpLastCounter  Int?
 
   sessions    Session[]
   credentials Credential[]
@@ -127,6 +141,7 @@ model User {
   activities    Activity[]
   recoveryCodes RecoveryCode[]
   pendingLogins PendingLogin[]
+  templates     ProjectTemplate[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -315,6 +330,9 @@ model Project {
   accent      String        @default("violet")
   tags        String[]      @default([])
   favorite    Boolean       @default(false)
+  /// Rang innerhalb der Statusspalte im Brett. Nur dort wirksam – die
+  /// uebrigen Ansichten folgen der gewaehlten Sortierung.
+  position    Int           @default(0)
 
   /// Besitzer. Nullable wie bei GitConnection, damit Bestandsdaten beim
   /// Einrichten des ersten Kontos uebernommen werden koennen.
@@ -343,6 +361,7 @@ model Project {
   @@index([status])
   @@index([updatedAt])
   @@index([ownerId])
+  @@index([ownerId, status, position])
 }
 
 /// Ein Repository eines Projekts. Ein Vorhaben besteht oft aus mehreren –
@@ -388,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())
@@ -445,6 +474,15 @@ model Task {
   /// Zeitpunkt, zu dem die Aufgabe nach DONE gewandert ist.
   doneAt      DateTime?
 
+  /// Wiederholt sich die Aufgabe? Wandert sie nach ERLEDIGT, entsteht die
+  /// naechste Fassung mit fortgeschriebenem Faelligkeitsdatum. Die erledigte
+  /// bleibt stehen – sonst ginge die Historie verloren.
+  recurrence  Recurrence?
+  /// Aus welcher Aufgabe diese hervorgegangen ist. Nur zur Nachvollziehbarkeit;
+  /// bewusst ohne Fremdschluessel, damit das Loeschen der Vorgaengerin die
+  /// Nachfolgerin nicht mitnimmt.
+  recurredFrom String?
+
   /// Stammt die Aufgabe aus einem Git-Issue? Nummer, Repository und Link
   /// merken, damit dasselbe Issue nicht zweimal uebernommen wird.
   sourceIssue Int?
@@ -462,6 +500,41 @@ model Task {
   @@index([projectId, status, position])
 }
 
+/// Eine Vorlage fuer neue Projekte: Stammdaten, Tags, Notizen und Aufgaben.
+///
+/// Bewusst benutzereigen und nicht fest eingebaut. Welche Tags und welche
+/// Startaufgaben sinnvoll sind, weiss nur, wer damit arbeitet – eine
+/// mitgelieferte Liste waere geraten.
+model ProjectTemplate {
+  id      String @id @default(cuid())
+  ownerId String
+  owner   User   @relation(fields: [ownerId], references: [id], onDelete: Cascade)
+
+  name        String
+  /// Wozu die Vorlage gut ist – erscheint in der Auswahl.
+  description String?
+
+  // ── Was die Vorlage in das neue Projekt schreibt ───────────
+  summary            String?
+  projectDescription String?
+  status             ProjectStatus @default(IDEA)
+  priority           Int           @default(2)
+  accent             String        @default("violet")
+  tags               String[]      @default([])
+  progressFromTasks  Boolean       @default(false)
+
+  /// [{ title, content, pinned }]
+  notes Json @default("[]")
+  /// [{ title, description, status, labels }]
+  tasks Json @default("[]")
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([ownerId, name])
+  @@index([ownerId])
+}
+
 /// Ein Eintrag im Verlauf eines Projekts: was ist wann passiert.
 model Activity {
   id        String       @id @default(cuid())
@@ -546,6 +619,23 @@ model RepoSnapshot {
   /// Commits je Tag der letzten 30 Tage, aeltester zuerst.
   commitActivity Json @default("[]")
 
+  /// Commits je Tag ueber bis zu ein Jahr – die Heatmap.
+  /// { from, to, days: { "2026-07-26": 3 }, source, truncated }
+  /// Getrennt vom uebrigen Stand, weil das Holen zusaetzliche Aufrufe kostet
+  /// und deshalb hoechstens einmal am Tag geschieht.
+  commitCalendar   Json      @default("{}")
+  commitCalendarAt DateTime?
+
+  /// Das README des Repositories, roh als Markdown. Wie der Kalender
+  /// hoechstens einmal am Tag geholt – es aendert sich selten, und der
+  /// Abgleich laeuft im Zweifel stuendlich.
+  readme        String?
+  /// Dateiname, wie er im Repository steht ("README.md", "readme.rst" …).
+  readmePath    String?
+  /// Wogegen relative Links im README aufzuloesen sind.
+  readmeBaseUrl String?
+  readmeAt      DateTime?
+
   // ── Letzter CI-Lauf auf dem Default-Branch ─────────────────
   /// success | failure | running | pending | cancelled
   ciState      String?

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

@@ -0,0 +1,194 @@
+#!/usr/bin/env bash
+# ─────────────────────────────────────────────────────────────
+#  Nebula auf einem Server aktualisieren.
+#
+#  Holt den neuen Stand, sichert die Datenbank, baut das Abbild, spielt die
+#  Migrationen ein und startet neu. Bricht ab, sobald ein Schritt scheitert –
+#  und sagt dann, wie zurueckzukommen ist.
+#
+#  Aufruf:   ./scripts/update.sh
+#            ./scripts/update.sh --no-pull      (nur neu bauen und starten)
+#            ./scripts/update.sh --ref v1.4.0   (auf einen Stand festlegen)
+#            ./scripts/update.sh --yes          (ohne Rueckfrage)
+#
+#  Rueckgabe 0 heisst: die neue Fassung laeuft und antwortet gesund.
+# ─────────────────────────────────────────────────────────────
+set -euo pipefail
+
+root="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$root"
+
+pull=1
+ref=""
+zusage=0
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --no-pull) pull=0 ;;
+    --ref) ref="${2:-}"; shift ;;
+    --yes|-y) zusage=1 ;;
+    -h|--help) sed -n '3,15p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    *) echo "Unbekannte Option: $1" >&2; exit 2 ;;
+  esac
+  shift
+done
+
+# ── Farben, aber nur wenn ein Terminal zusieht ───────────────
+if [ -t 1 ]; then
+  rot=$'\033[31m'; gruen=$'\033[32m'; gelb=$'\033[33m'; fett=$'\033[1m'; aus=$'\033[0m'
+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"; }
+abbruch() { printf '\n%s✗ %s%s\n' "$rot" "$1" "$aus" >&2; exit 1; }
+
+# ── Voraussetzungen ──────────────────────────────────────────
+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 './scripts/setup.sh' ausfuehren."
+[ -f "$root/docker-compose.yml" ] || abbruch "Kein docker-compose.yml in $root."
+ok "docker, compose und .env vorhanden"
+
+# APP_SECRET muss gesetzt sein – sonst liegen die Git-Tokens faktisch offen.
+if grep -qE '^\s*APP_SECRET\s*=\s*("?)(nebula-dev-secret[^"]*|)\1\s*$' "$root/.env"; then
+  abbruch "APP_SECRET ist leer oder noch der Entwicklungswert. Bitte in der .env setzen."
+fi
+ok "APP_SECRET gesetzt"
+
+vorher="$(git rev-parse --short HEAD 2>/dev/null || echo "unbekannt")"
+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"
+
+  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
+  if [ -n "$ref" ]; then
+    git checkout --quiet "$ref"
+    ok "Auf $ref gewechselt"
+  else
+    zweig="$(git rev-parse --abbrev-ref HEAD)"
+    git pull --ff-only --quiet origin "$zweig"
+    ok "$zweig aktualisiert"
+  fi
+
+  nachher="$(git rev-parse --short HEAD)"
+  version_nachher="$(paket_version)"
+
+  if [ "$vorher" = "$nachher" ]; then
+    warnung "Kein neuer Stand – es wird trotzdem neu gebaut."
+  else
+    printf '  Neu:     v%s (%s)\n' "$version_nachher" "$nachher"
+    printf '\n  Was dazukam:\n'
+    git --no-pager log --oneline --no-decorate "$vorher..$nachher" 2>/dev/null | sed 's/^/    /' || true
+  fi
+else
+  warnung "Ohne --pull: der vorhandene Stand wird neu gebaut."
+fi
+
+# ── Rueckfrage ───────────────────────────────────────────────
+if [ "$zusage" -eq 0 ] && [ -t 0 ]; then
+  printf '\n%sWeiter? Die Datenbank wird vorher gesichert. [j/N] %s' "$fett" "$aus"
+  read -r antwort
+  case "$antwort" in [jJyY]*) ;; *) abbruch "Abgebrochen." ;; esac
+fi
+
+# ── Datenbank sichern ────────────────────────────────────────
+schritt "Datenbank sichern"
+
+# Die Datenbank muss laufen, sonst gibt es nichts zu sichern.
+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"
+  # 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."
+fi
+
+# ── Bauen ────────────────────────────────────────────────────
+schritt "Abbild bauen"
+# Erst bauen, dann umschalten: ein Fehlschlag laesst die alte Fassung laufen.
+docker compose --profile full build app || abbruch "Der Bau ist gescheitert. Die laufende Fassung ist unveraendert."
+ok "Abbild gebaut"
+
+# ── Starten ──────────────────────────────────────────────────
+schritt "Starten"
+# Die Migrationen laufen im entrypoint.sh, bevor der Server hochkommt.
+docker compose --profile full up -d || abbruch "Der Start ist gescheitert."
+ok "Container gestartet"
+
+# ── Gesundheitspruefung ──────────────────────────────────────
+schritt "Gesundheitspruefung"
+
+# 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 _ 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
+  printf '\n%sLetzte Zeilen aus dem Log:%s\n' "$fett" "$aus"
+  docker compose --profile full logs --tail 40 app || true
+  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 "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
+
+# ── Fertig ───────────────────────────────────────────────────
+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/totp/route.ts

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { requireUserApi } from "@/lib/auth/guard";
 import { verifyPassword } from "@/lib/auth/password";
 import { countUnusedRecoveryCodes, issueRecoveryCodes } from "@/lib/auth/recovery";
-import { generateTotpSecret, groupSecret, otpauthUri, verifyTotp } from "@/lib/auth/totp";
+import { generateTotpSecret, groupSecret, matchTotp, otpauthUri } from "@/lib/auth/totp";
 import { APP_NAME } from "@/lib/config";
 import { encryptSecret, tryDecryptSecret } from "@/lib/crypto";
 import { prisma } from "@/lib/db";
@@ -109,7 +109,8 @@ export async function PUT(request: Request) {
     return jsonError("Es liegt kein Schluessel vor. Bitte die Einrichtung neu starten.", 409);
   }
 
-  if (!verifyTotp(secret, parsed.data.code)) {
+  const fenster = matchTotp(secret, parsed.data.code);
+  if (fenster === null) {
     return jsonError(
       "Der Code stimmt nicht. Geht die Uhr des Geraets richtig?",
       401,
@@ -118,7 +119,9 @@ export async function PUT(request: Request) {
 
   await prisma.user.update({
     where: { id: auth.user.id },
-    data: { totpEnabledAt: new Date() },
+    // Das Fenster gleich mitverbrennen: der Code, der eben aktiviert hat,
+    // soll nicht Sekunden spaeter noch zum Anmelden taugen.
+    data: { totpEnabledAt: new Date(), totpLastCounter: fenster },
   });
 
   return NextResponse.json({
@@ -157,7 +160,7 @@ export async function DELETE(request: Request) {
   await prisma.$transaction([
     prisma.user.update({
       where: { id: auth.user.id },
-      data: { totpSecretCipher: null, totpEnabledAt: null },
+      data: { totpSecretCipher: null, totpEnabledAt: null, totpLastCounter: null },
     }),
     prisma.recoveryCode.deleteMany({ where: { userId: auth.user.id } }),
     prisma.pendingLogin.deleteMany({ where: { userId: auth.user.id } }),

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

@@ -8,8 +8,9 @@ import {
 } from "@/lib/auth/mfa";
 import { redeemRecoveryCode } from "@/lib/auth/recovery";
 import { createSession, setSessionCookie } from "@/lib/auth/session";
-import { verifyTotp } from "@/lib/auth/totp";
+import { matchTotp } from "@/lib/auth/totp";
 import { noteSuccessfulLogin } from "@/lib/auth/users";
+import { prisma } from "@/lib/db";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
 
@@ -63,9 +64,19 @@ export async function POST(request: Request) {
   // Wiederherstellungscode. Beide Wege zu probieren waere unnoetig – die
   // Formate ueberschneiden sich nicht.
   const istZiffern = /^[\d\s]+$/.test(eingabe);
-  const erfolg = istZiffern
+
-    ? Boolean(pending.user.totpSecret) && verifyTotp(pending.user.totpSecret!, eingabe)
+  // Bei den Ziffern zaehlt zusaetzlich, dass das Zeitfenster neuer ist als
-    : await redeemRecoveryCode(pending.user.id, eingabe);
+  // das zuletzt eingeloeste. Sonst liesse sich ein abgefangener Code die
+  // restliche Gueltigkeitsdauer ueber wiederverwenden – RFC 6238, 5.2.
+  const fenster =
+    istZiffern && pending.user.totpSecret
+      ? matchTotp(pending.user.totpSecret, eingabe)
+      : null;
+  const frisch =
+    fenster !== null &&
+    (pending.user.totpLastCounter === null || fenster > pending.user.totpLastCounter);
+
+  const erfolg = istZiffern ? frisch : await redeemRecoveryCode(pending.user.id, eingabe);
 
   if (!erfolg) {
     const weiterMoeglich = await noteMfaFailure(pending.id);
@@ -83,6 +94,14 @@ export async function POST(request: Request) {
   await discardPendingLogin(pending.id);
   await noteSuccessfulLogin(pending.user.id);
 
+  // Das eingeloeste Fenster merken, damit derselbe Code verbrannt ist.
+  if (fenster !== null) {
+    await prisma.user.update({
+      where: { id: pending.user.id },
+      data: { totpLastCounter: fenster },
+    });
+  }
+
   const session = await createSession(pending.user.id, {
     userAgent: request.headers.get("user-agent"),
     ip,

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

@@ -3,7 +3,12 @@ import { NextResponse } from "next/server";
 import { describeFields, describeStatus, recordActivities, shorten } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
-import { projectDetailInclude, projectListInclude, uniqueSlug } from "@/lib/projects";
+import {
+  nextProjectPosition,
+  projectDetailInclude,
+  projectListInclude,
+  uniqueSlug,
+} from "@/lib/projects";
 import { applyLeadingRepo, type RepoInput } from "@/lib/repositories";
 import { jsonError, readJsonBody } from "@/lib/security/request";
 import { refreshDerivedProgress } from "@/lib/tasks";
@@ -82,6 +87,13 @@ export async function PATCH(request: Request, { params }: Params) {
     if (data[key] !== undefined) update[key] = data[key];
   }
 
+  // Beim Statuswechsel ans Ende der neuen Spalte – sonst behielte das Projekt
+  // seinen alten Rang und saesse mitten in einer Spalte, in der es eben erst
+  // angekommen ist.
+  if (data.status !== undefined && data.status !== existing.status) {
+    update.position = await nextProjectPosition(auth.user.id, data.status);
+  }
+
   await prisma.project.update({ where: { id }, data: update });
 
   // Die Git-Felder gehen an das fuehrende Repository. Sie hier weiterhin

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

@@ -3,7 +3,7 @@ import type { Prisma, TaskStatus } from "@prisma/client";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { jsonError, readJsonBody } from "@/lib/security/request";
-import { ownedProject, refreshDerivedProgress } from "@/lib/tasks";
+import { ownedProject, refreshDerivedProgress, spawnRecurrence } from "@/lib/tasks";
 import { formatZodError, taskReorderSchema } from "@/lib/validation";
 
 export const dynamic = "force-dynamic";
@@ -52,11 +52,14 @@ export async function PATCH(request: Request, { params }: Params) {
 
   const now = new Date();
   const updates: Prisma.PrismaPromise<unknown>[] = [];
+  /** Wer eben erst nach ERLEDIGT gewandert ist – nicht, wer dort schon lag. */
+  const frischErledigt: string[] = [];
 
   for (const [status, ids] of Object.entries(columns) as Array<[TaskStatus, string[]]>) {
     ids.forEach((taskId, index) => {
       if (!ownedIds.has(taskId)) return;
       const before = previousStatus.get(taskId);
+      if (status === "DONE" && before !== "DONE") frischErledigt.push(taskId);
       updates.push(
         prisma.task.update({
           where: { id: taskId },
@@ -77,6 +80,14 @@ export async function PATCH(request: Request, { params }: Params) {
 
   if (updates.length > 0) {
     await prisma.$transaction(updates);
+
+    // Wiederkehrende Aufgaben, die eben nach ERLEDIGT gezogen wurden,
+    // bekommen ihre naechste Fassung. Erst nach der Transaktion: vorher
+    // stuende doneAt noch nicht, aus dem der Folgetermin gerechnet wird.
+    for (const taskId of frischErledigt) {
+      await spawnRecurrence(taskId);
+    }
+
     await refreshDerivedProgress(id);
   }
 

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

@@ -46,7 +46,7 @@ export async function POST(request: Request, { params }: Params) {
     );
   }
 
-  const { title, description, status, dueDate, labels } = parsed.data;
+  const { title, description, status, dueDate, labels, recurrence } = parsed.data;
 
   const task = await prisma.task.create({
     data: {
@@ -58,6 +58,7 @@ export async function POST(request: Request, { params }: Params) {
       position: await nextPosition(id, status),
       dueDate: dueDate ? new Date(dueDate) : null,
       labels,
+      recurrence: recurrence ?? null,
       doneAt: status === "DONE" ? new Date() : null,
     },
   });

src/app/api/projects/bulk/route.ts

@@ -0,0 +1,150 @@
+import { NextResponse } from "next/server";
+import type { Prisma, ProjectStatus } from "@prisma/client";
+import { describeStatus, recordActivities } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, readJsonBody, tooManyRequests } from "@/lib/security/request";
+import { formatZodError, projectBulkSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Dieselbe Aenderung fuer mehrere Projekte auf einmal.
+ *
+ * Der Weg ueber einen eigenen Endpunkt statt vieler einzelner PATCHes hat
+ * zwei Gruende: es ist eine Transaktion statt zwanzig Rundgaengen, und der
+ * Verlauf bekommt je Projekt genau einen Eintrag statt eines Schwalls.
+ */
+export async function POST(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const limited = rateLimit(
+    `mutate:${clientIp(request)}`,
+    LIMITS.mutation.limit,
+    LIMITS.mutation.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = projectBulkSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const { ids, action } = parsed.data;
+
+  // Die Besitzerbedingung steht zuerst: fremde IDs werden hier gar nicht
+  // erst eingesammelt und fallen damit still unter den Tisch.
+  const owned = await prisma.project.findMany({
+    where: { ownerId: auth.user.id, id: { in: ids } },
+    select: { id: true, status: true, tags: true, favorite: true, updatedAt: true },
+  });
+
+  if (owned.length === 0) {
+    return NextResponse.json({ changed: 0, ignored: ids.length });
+  }
+
+  const eigene = owned.map((project) => project.id);
+  const entries: Parameters<typeof recordActivities>[0] = [];
+
+  if (action === "delete") {
+    const result = await prisma.project.deleteMany({
+      where: { ownerId: auth.user.id, id: { in: eigene } },
+    });
+    return NextResponse.json({ changed: result.count, ignored: ids.length - result.count });
+  }
+
+  const updates: Prisma.PrismaPromise<unknown>[] = [];
+
+  // Einmal vorab bestimmen und hochzaehlen. Je Projekt neu abzufragen ergaebe
+  // immer dieselbe Zahl – die Transaktion ist ja noch nicht geschrieben, und
+  // alle Verschobenen landeten uebereinander auf derselben Position.
+  let position =
+    action === "status" ? await nextPosition(auth.user.id, parsed.data.status!) : 0;
+
+  for (const project of owned) {
+    if (action === "status") {
+      const ziel = parsed.data.status!;
+      if (project.status === ziel) continue;
+      updates.push(
+        prisma.project.update({
+          where: { id: project.id },
+          // Ans Ende der Zielspalte, wie beim einzelnen Verschieben auch.
+          data: { status: ziel, position: position++ },
+        }),
+      );
+      entries.push({
+        projectId: project.id,
+        userId: auth.user.id,
+        kind: "STATUS_CHANGED",
+        summary: describeStatus(project.status, ziel),
+        meta: { from: project.status, to: ziel, bulk: true },
+      });
+      continue;
+    }
+
+    if (action === "favorite") {
+      const ziel = parsed.data.favorite!;
+      if (project.favorite === ziel) continue;
+      updates.push(
+        prisma.project.update({
+          where: { id: project.id },
+          // Ein Stern ist keine inhaltliche Aenderung.
+          data: { favorite: ziel, updatedAt: project.updatedAt },
+        }),
+      );
+      continue;
+    }
+
+    // action === "tags"
+    const gewuenscht = parsed.data.tags!.map((tag) => tag.toLowerCase());
+    const naechste =
+      parsed.data.tagMode === "add"
+        ? Array.from(new Set([...project.tags, ...gewuenscht])).slice(0, 12)
+        : project.tags.filter((tag) => !gewuenscht.includes(tag));
+
+    if (naechste.length === project.tags.length &&
+        naechste.every((tag, index) => tag === project.tags[index])) {
+      continue;
+    }
+
+    updates.push(
+      prisma.project.update({ where: { id: project.id }, data: { tags: naechste } }),
+    );
+    entries.push({
+      projectId: project.id,
+      userId: auth.user.id,
+      kind: "PROJECT_UPDATED",
+      summary: "Tags geändert",
+      meta: { tags: naechste, bulk: true },
+    });
+  }
+
+  if (updates.length > 0) {
+    await prisma.$transaction(updates);
+    await recordActivities(entries);
+  }
+
+  return NextResponse.json({
+    changed: updates.length,
+    // Nicht geaendert, weil schon so, oder weil die ID nicht dem Konto gehoert.
+    ignored: ids.length - updates.length,
+  });
+}
+
+/** Naechste freie Position am Ende einer Statusspalte. */
+async function nextPosition(ownerId: string, status: ProjectStatus) {
+  const last = await prisma.project.findFirst({
+    where: { ownerId, status },
+    orderBy: { position: "desc" },
+    select: { position: true },
+  });
+  return (last?.position ?? -1) + 1;
+}

src/app/api/projects/import/route.ts

@@ -8,7 +8,7 @@ import {
   repositoriesOf,
   type ExportedRepository,
 } from "@/lib/export/format";
-import { uniqueSlug } from "@/lib/projects";
+import { nextProjectPosition, uniqueSlug } from "@/lib/projects";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import {
   IMPORT_MAX_BODY_BYTES,
@@ -164,6 +164,8 @@ export async function POST(request: Request) {
     }
 
     const data = {
+      // Hinten an die Statusspalte des Bretts, in der Reihenfolge der Datei.
+      position: await nextProjectPosition(auth.user.id, incoming.status),
       name: incoming.name,
       summary: incoming.summary ?? null,
       description: incoming.description ?? null,

src/app/api/projects/reorder/route.ts

@@ -0,0 +1,102 @@
+import { NextResponse } from "next/server";
+import type { Prisma, ProjectStatus } from "@prisma/client";
+import { describeStatus, recordActivities } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, readJsonBody, tooManyRequests } from "@/lib/security/request";
+import { formatZodError, projectReorderSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Neue Reihenfolge im Brett nach dem Ziehen.
+ *
+ * Wie beim Aufgabenbrett wird je betroffener Spalte die vollstaendige Liste
+ * uebergeben. Status und Position ergeben sich daraus eindeutig; ein
+ * verlorener Aufruf laesst sich einfach erneut senden, ohne Schaden
+ * anzurichten.
+ */
+export async function PATCH(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const limited = rateLimit(
+    `mutate:${clientIp(request)}`,
+    LIMITS.mutation.limit,
+    LIMITS.mutation.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = projectReorderSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const columns = parsed.data.columns as Partial<Record<ProjectStatus, string[]>>;
+  const requestedIds = Object.values(columns).flat();
+
+  // Nur eigene Projekte anfassen – sonst liessen sich fremde ueber
+  // untergeschobene IDs verschieben.
+  const owned = await prisma.project.findMany({
+    where: { ownerId: auth.user.id, id: { in: requestedIds } },
+    select: { id: true, status: true, updatedAt: true },
+  });
+  const ownedIds = new Set(owned.map((project) => project.id));
+  const vorher = new Map(owned.map((project) => [project.id, project]));
+
+  const updates: Prisma.PrismaPromise<unknown>[] = [];
+  const entries: Parameters<typeof recordActivities>[0] = [];
+
+  for (const [status, ids] of Object.entries(columns) as Array<[ProjectStatus, string[]]>) {
+    ids.forEach((projectId, index) => {
+      const before = vorher.get(projectId);
+      if (!ownedIds.has(projectId) || !before) return;
+
+      const gewandert = before.status !== status;
+
+      updates.push(
+        prisma.project.update({
+          where: { id: projectId },
+          data: {
+            status,
+            position: index,
+            // Beim reinen Umsortieren das Aenderungsdatum festhalten. Sonst
+            // schoebe ein Aufraeumen im Brett saemtliche Projekte in der
+            // Sortierung "Zuletzt geaendert" nach oben – das Brett wuerde die
+            // Liste umsortieren, ohne dass sich inhaltlich etwas geaendert hat.
+            ...(gewandert ? {} : { updatedAt: before.updatedAt }),
+          },
+        }),
+      );
+
+      // Ein Statuswechsel gehoert in den Verlauf, ein blosses Umsortieren
+      // nicht – sonst besteht er bald nur noch aus Rangaenderungen.
+      if (gewandert) {
+        entries.push({
+          projectId,
+          userId: auth.user.id,
+          kind: "STATUS_CHANGED",
+          summary: describeStatus(before.status, status),
+          meta: { from: before.status, to: status },
+        });
+      }
+    });
+  }
+
+  if (updates.length > 0) {
+    await prisma.$transaction(updates);
+    await recordActivities(entries);
+  }
+
+  return NextResponse.json({
+    updated: updates.length,
+    ignored: requestedIds.length - updates.length,
+  });
+}

src/app/api/projects/route.ts

@@ -2,7 +2,7 @@ import { NextResponse } from "next/server";
 import { recordActivity } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
-import { projectListInclude, uniqueSlug } from "@/lib/projects";
+import { nextProjectPosition, projectListInclude, uniqueSlug } from "@/lib/projects";
 import { applyLeadingRepo } from "@/lib/repositories";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
@@ -74,6 +74,20 @@ export async function POST(request: Request) {
     if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
   }
 
+  // Aus der Vorlage kommen nur Notizen und Aufgaben. Die Stammdaten hat die
+  // Oberflaeche schon in die Felder uebernommen, damit man sie vor dem
+  // Speichern noch sieht und aendern kann.
+  const vorlage = data.templateId
+    ? await prisma.projectTemplate.findFirst({
+        where: { id: data.templateId, ownerId: auth.user.id },
+        select: { name: true, notes: true, tasks: true },
+      })
+    : null;
+  if (data.templateId && !vorlage) return jsonError("Vorlage nicht gefunden.", 404);
+
+  const notes = templateNotes(vorlage?.notes);
+  const tasks = templateTasks(vorlage?.tasks);
+
   const angelegt = await prisma.project.create({
     data: {
       ownerId: auth.user.id,
@@ -87,6 +101,11 @@ export async function POST(request: Request) {
       accent: data.accent,
       tags: data.tags,
       favorite: data.favorite,
+      progressFromTasks: data.progressFromTasks,
+      // Hinten an die Statusspalte des Bretts.
+      position: await nextProjectPosition(auth.user.id, data.status),
+      notes: { create: notes },
+      tasks: { create: tasks },
     },
     select: { id: true },
   });
@@ -109,12 +128,56 @@ export async function POST(request: Request) {
     projectId: project.id,
     userId: auth.user.id,
     kind: "PROJECT_CREATED",
-    summary:
+    summary: vorlage
-      data.status === "IDEA"
+      ? `Aus Vorlage „${vorlage.name}“ angelegt`
+      : data.status === "IDEA"
         ? "Als Idee angelegt"
         : `Angelegt mit Status „${statusOf(data.status).label}“`,
-    meta: { status: data.status },
+    meta: {
+      status: data.status,
+      ...(vorlage ? { template: vorlage.name, notes: notes.length, tasks: tasks.length } : {}),
+    },
   });
 
   return NextResponse.json({ project }, { status: 201 });
 }
+
+/**
+ * Die Vorlage kommt als JSON aus der Datenbank und ist damit fuer TypeScript
+ * unbekannt. Hier wird sie auf das Noetige zurechtgeschnitten – lieber einen
+ * Eintrag auslassen als am Anlegen scheitern.
+ */
+function templateNotes(value: unknown) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === "object")
+    .filter((entry) => typeof entry.content === "string" && entry.content.trim().length > 0)
+    .slice(0, 50)
+    .map((entry) => ({
+      title: typeof entry.title === "string" ? entry.title : null,
+      content: entry.content as string,
+      pinned: entry.pinned === true,
+    }));
+}
+
+function templateTasks(value: unknown) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((entry): entry is Record<string, unknown> => Boolean(entry) && typeof entry === "object")
+    .filter((entry) => typeof entry.title === "string" && entry.title.trim().length > 0)
+    .slice(0, 100)
+    .map((entry, index) => ({
+      title: entry.title as string,
+      description: typeof entry.description === "string" ? entry.description : null,
+      status: (["TODO", "DOING", "BLOCKED"] as const).includes(
+        entry.status as "TODO" | "DOING" | "BLOCKED",
+      )
+        ? (entry.status as "TODO" | "DOING" | "BLOCKED")
+        : ("TODO" as const),
+      // Reihenfolge wie in der Vorlage.
+      position: index,
+      labels: Array.isArray(entry.labels)
+        ? entry.labels.filter((label): label is string => typeof label === "string").slice(0, 8)
+        : [],
+    }));
+}

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/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

@@ -4,7 +4,13 @@ import { recordActivity, shorten } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { jsonError, readJsonBody } from "@/lib/security/request";
-import { TASK_STATUS_META, nextPosition, refreshDerivedProgress } from "@/lib/tasks";
+import {
+  TASK_STATUS_META,
+  nextPosition,
+  refreshDerivedProgress,
+  spawnRecurrence,
+} from "@/lib/tasks";
+import { issueShouldBeOpen, mirrorStatusToIssue } from "@/lib/tasks/issues";
 import { formatZodError, taskUpdateSchema } from "@/lib/validation";
 
 export const dynamic = "force-dynamic";
@@ -44,6 +50,7 @@ export async function PATCH(request: Request, { params }: Params) {
   if (data.title !== undefined) update.title = data.title;
   if (data.description !== undefined) update.description = data.description;
   if (data.labels !== undefined) update.labels = data.labels;
+  if (data.recurrence !== undefined) update.recurrence = data.recurrence;
   if (data.dueDate !== undefined) {
     update.dueDate = data.dueDate ? new Date(data.dueDate) : null;
   }
@@ -57,8 +64,34 @@ export async function PATCH(request: Request, { params }: Params) {
   }
 
   const task = await prisma.task.update({ where: { id }, data: update });
+
+  // Genau beim Uebergang nach ERLEDIGT entsteht die naechste Fassung. Ein
+  // erneutes Speichern einer schon erledigten Aufgabe darf keine zweite
+  // erzeugen – deshalb haengt es an update.status und nicht an data.status.
+  const folge =
+    update.status === "DONE" && existing.status !== "DONE"
+      ? await spawnRecurrence(id)
+      : null;
+
   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.
@@ -68,12 +101,14 @@ export async function PATCH(request: Request, { params }: Params) {
       projectId: existing.projectId,
       userId: auth.user.id,
       kind: "TASK_MOVED",
-      summary: `Aufgabe „${shorten(task.title, 50)}“ → ${TASK_STATUS_META[nach].label}`,
+      summary: folge
-      meta: { taskId: id, from: existing.status, to: nach },
+        ? `Aufgabe „${shorten(task.title, 40)}“ erledigt, nächste angelegt`
+        : `Aufgabe „${shorten(task.title, 50)}“ → ${TASK_STATUS_META[nach].label}`,
+      meta: { taskId: id, from: existing.status, to: nach, ...(folge ? { next: folge.id } : {}) },
     });
   }
 
-  return NextResponse.json({ task });
+  return NextResponse.json({ task, next: folge });
 }
 
 export async function DELETE(_request: Request, { params }: Params) {

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

@@ -0,0 +1,60 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { formatZodError, templateUpdateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function PATCH(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const existing = await prisma.projectTemplate.findFirst({
+    where: { id, ownerId: auth.user.id },
+    select: { id: true },
+  });
+  if (!existing) return jsonError("Vorlage nicht gefunden", 404);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = templateUpdateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const data = parsed.data;
+
+  if (data.name) {
+    const doppelt = await prisma.projectTemplate.findFirst({
+      where: { ownerId: auth.user.id, name: data.name, id: { not: id } },
+      select: { id: true },
+    });
+    if (doppelt) return jsonError(`Eine Vorlage „${data.name}“ gibt es bereits.`, 409);
+  }
+
+  const template = await prisma.projectTemplate.update({ where: { id }, data });
+  return NextResponse.json({ template });
+}
+
+export async function DELETE(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+
+  // deleteMany mit Besitzerbedingung: trifft fremde Vorlagen gar nicht erst.
+  const result = await prisma.projectTemplate.deleteMany({
+    where: { id, ownerId: auth.user.id },
+  });
+  if (result.count === 0) return jsonError("Vorlage nicht gefunden", 404);
+
+  return NextResponse.json({ ok: true });
+}

src/app/api/templates/from-project/route.ts

@@ -0,0 +1,95 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
+import { formatZodError, templateFromProjectSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Aus einem vorhandenen Projekt eine Vorlage machen.
+ *
+ * Das ist der Weg, auf dem Vorlagen ueblicherweise entstehen: man richtet ein
+ * Projekt so ein, wie es passt, und haelt das dann fest. Eine Vorlage von
+ * Grund auf zu tippen kann man auch – ueber POST /api/templates.
+ *
+ * Nicht mitgenommen wird alles Projektbezogene: Name, Slug, Fortschritt,
+ * Favorit und vor allem die Repositories. Eine Vorlage, die jedes neue
+ * Projekt an dasselbe Repository haengt, waere eine Falle.
+ */
+export async function POST(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const limited = rateLimit(
+    `mutate:${clientIp(request)}`,
+    LIMITS.mutation.limit,
+    LIMITS.mutation.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = templateFromProjectSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const { projectId, name, description, withNotes, withTasks } = parsed.data;
+
+  const project = await prisma.project.findFirst({
+    where: { id: projectId, ownerId: auth.user.id },
+    include: {
+      notes: { orderBy: [{ pinned: "desc" }, { createdAt: "asc" }] },
+      tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
+    },
+  });
+  if (!project) return jsonError("Projekt nicht gefunden", 404);
+
+  const doppelt = await prisma.projectTemplate.findFirst({
+    where: { ownerId: auth.user.id, name },
+    select: { id: true },
+  });
+  if (doppelt) return jsonError(`Eine Vorlage „${name}“ gibt es bereits.`, 409);
+
+  const template = await prisma.projectTemplate.create({
+    data: {
+      ownerId: auth.user.id,
+      name,
+      description: description ?? null,
+      summary: project.summary,
+      projectDescription: project.description,
+      status: project.status,
+      priority: project.priority,
+      accent: project.accent,
+      tags: project.tags,
+      progressFromTasks: project.progressFromTasks,
+      notes: withNotes
+        ? project.notes.map((note) => ({
+            title: note.title,
+            content: note.content,
+            pinned: note.pinned,
+          }))
+        : [],
+      // Erledigte Aufgaben kommen nicht mit: eine Vorlage beschreibt, was zu
+      // tun ist, nicht was einmal getan wurde.
+      tasks: withTasks
+        ? project.tasks
+            .filter((task) => task.status !== "DONE")
+            .map((task) => ({
+              title: task.title,
+              description: task.description,
+              status: task.status,
+              labels: task.labels,
+            }))
+        : [],
+    },
+  });
+
+  return NextResponse.json({ template }, { status: 201 });
+}

src/app/api/templates/route.ts

@@ -0,0 +1,80 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, jsonError, readJsonBody, tooManyRequests } from "@/lib/security/request";
+import { formatZodError, templateCreateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+/** Hoechstzahl je Konto. Wer mehr braucht, hat keine Vorlagen mehr, sondern Projekte. */
+const MAX_TEMPLATES = 30;
+
+export async function GET() {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const templates = await prisma.projectTemplate.findMany({
+    where: { ownerId: auth.user.id },
+    orderBy: { name: "asc" },
+  });
+
+  return NextResponse.json({ templates });
+}
+
+export async function POST(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const limited = rateLimit(
+    `mutate:${clientIp(request)}`,
+    LIMITS.mutation.limit,
+    LIMITS.mutation.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = templateCreateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const vorhanden = await prisma.projectTemplate.count({ where: { ownerId: auth.user.id } });
+  if (vorhanden >= MAX_TEMPLATES) {
+    return jsonError(`Mehr als ${MAX_TEMPLATES} Vorlagen sind nicht vorgesehen.`, 409);
+  }
+
+  const data = parsed.data;
+
+  // Der Name ist je Konto eindeutig; ein Duplikat soll eine verstaendliche
+  // Meldung geben statt eines Datenbankfehlers.
+  const doppelt = await prisma.projectTemplate.findFirst({
+    where: { ownerId: auth.user.id, name: data.name },
+    select: { id: true },
+  });
+  if (doppelt) return jsonError(`Eine Vorlage „${data.name}“ gibt es bereits.`, 409);
+
+  const template = await prisma.projectTemplate.create({
+    data: {
+      ownerId: auth.user.id,
+      name: data.name,
+      description: data.description ?? null,
+      summary: data.summary ?? null,
+      projectDescription: data.projectDescription ?? null,
+      status: data.status,
+      priority: data.priority,
+      accent: data.accent,
+      tags: data.tags,
+      progressFromTasks: data.progressFromTasks,
+      notes: data.notes,
+      tasks: data.tasks,
+    },
+  });
+
+  return NextResponse.json({ template }, { status: 201 });
+}

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

@@ -0,0 +1,136 @@
+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 { 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 !== task.status) {
+      await prisma.task.update({
+        where: { id: task.id },
+        data: {
+          status: ziel,
+          doneAt: ziel === "DONE" ? new Date() : 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

@@ -124,6 +124,30 @@
   }
   .md a:hover { color: #ddd6fe; }
 
+  /* Bilder werden nicht geladen, sondern als Marke gezeigt – siehe die
+     Begruendung in Markdown.tsx. Damit sie nicht wie Fliesstext aussieht,
+     bekommt sie einen Rahmen und ein Symbol davor. */
+  .md .md-image {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3em;
+    border: 1px dashed rgba(255, 255, 255, 0.16);
+    border-radius: 0.4rem;
+    padding: 0.05em 0.45em;
+    font-size: 0.85em;
+    color: #8a98b0;
+    text-decoration: none;
+    vertical-align: baseline;
+  }
+  .md .md-image::before {
+    content: "▣";
+    opacity: 0.6;
+  }
+  .md a.md-image:hover {
+    color: #c4b5fd;
+    border-color: rgba(196, 181, 253, 0.4);
+  }
+
   .md strong { color: #f1f5f9; font-weight: 600; }
 
   .md ul, .md ol { margin: 0.75em 0; padding-left: 1.35em; }
@@ -253,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;
@@ -311,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);
   }
@@ -392,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

@@ -16,12 +16,35 @@
   --color-void-soft: #0a0c1a;
   --color-haze: #12142b;
 
+  /* ── Gedaempfte Textfarben ──────────────────────────────────
+     Tailwinds slate-500 und slate-600 kommen auf diesem sehr dunklen
+     Untergrund nur auf 3,8 bzw. 2,5 zu 1. WCAG AA verlangt 4,5 fuer
+     normalen Text, und beide werden hier reichlich fuer Hinweise und
+     Nebenangaben benutzt – axe-core hat das an 26 Stellen beanstandet.
+
+     Statt an hundert Stellen die Klasse zu tauschen, werden die beiden
+     Stufen hier aufgehellt. Der Abstand zwischen ihnen bleibt sichtbar,
+     der Rest des Entwurfs unangetastet.
+
+     Geprueft gegen die drei vorkommenden Untergruende #0b0d1c (Seite),
+     #0e0f17 (.glass) und #14141d (.popover) – der schlechteste Wert
+     zaehlt. */
+  --color-slate-500: #8a98b0; /* 6,3 : 1 */
+  --color-slate-600: #78879f; /* 5,0 : 1 */
+
   --font-sans: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto,
     "Helvetica Neue", Arial, "Noto Sans", sans-serif;
   --font-mono: ui-monospace, "Cascadia Code", "Source Code Pro", Menlo,
     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 {
@@ -47,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

@@ -1,4 +1,5 @@
 import type { Metadata, Viewport } from "next";
+import { ChangelogButton } from "@/components/ChangelogButton";
 import { CommandPalette } from "@/components/CommandPalette";
 import { TopNav } from "@/components/TopNav";
 import { getSessionUser } from "@/lib/auth/session";
@@ -20,6 +21,20 @@ export async function generateMetadata(): Promise<Metadata> {
       "Uebersicht ueber alle Vibe-Coding Projekte: Status, Notizen und Live-Daten aus GitHub, GitLab und Gitea.",
     applicationName: APP_NAME,
     robots: { index: false, follow: false },
+    manifest: "/manifest.webmanifest",
+    // iOS liest das Manifest nicht; dort braucht es diese Angaben einzeln.
+    appleWebApp: { capable: true, title: APP_NAME, statusBarStyle: "black-translucent" },
+    // Beide Eintraege ausdruecklich: sobald hier etwas steht, ersetzt es den
+    // Verweis, den Next aus app/icon.svg von selbst erzeugt. Ohne die erste
+    // Zeile haette die Seite gar kein Symbol mehr und der Browser fiele auf
+    // /favicon.ico zurueck – das es hier nicht gibt.
+    icons: {
+      icon: [
+        { url: "/icon.svg", type: "image/svg+xml" },
+        { url: "/icon-192.png", sizes: "192x192", type: "image/png" },
+      ],
+      apple: "/apple-touch-icon.png",
+    },
   };
 }
 
@@ -27,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({
@@ -56,7 +76,7 @@ export default async function RootLayout({
         <footer className="mx-auto w-full max-w-[1400px] px-4 pb-10 text-xs text-slate-500 sm:px-6 lg:px-8">
           <div className="flex flex-wrap items-center justify-between gap-2 border-t border-white/5 pt-6">
             <span>{APP_NAME} · lokal betrieben, Daten bleiben in deiner PostgreSQL.</span>
-            <span className="font-mono text-slate-600">v{APP_VERSION}</span>
+            <ChangelogButton version={APP_VERSION} />
           </div>
         </footer>
       </body>

src/app/manifest.ts

@@ -0,0 +1,41 @@
+import type { MetadataRoute } from "next";
+import { APP_NAME, APP_TAGLINE } from "@/lib/config";
+
+/**
+ * Web-App-Manifest: macht Nebula auf dem Handy installierbar.
+ *
+ * Als Funktion und nicht als Konstante, aus demselben Grund wie bei
+ * generateMetadata: nur so wird APP_NAME zur Laufzeit gelesen. Ein
+ * konstanter Export waere beim Build eingefroren und liesse sich im
+ * fertigen Docker-Image nicht mehr aendern.
+ */
+export const dynamic = "force-dynamic";
+
+export default function manifest(): MetadataRoute.Manifest {
+  return {
+    name: `${APP_NAME} – ${APP_TAGLINE} Dashboard`,
+    short_name: APP_NAME,
+    description:
+      "Uebersicht ueber alle Vibe-Coding-Projekte: Status, Notizen und Live-Daten aus GitHub, GitLab und Gitea.",
+    // Ohne Adressleiste, aber mit den Systemleisten – die Anwendung braucht
+    // keinen Vollbildmodus, wohl aber die Uhrzeit und den Akkustand.
+    display: "standalone",
+    start_url: "/",
+    scope: "/",
+    background_color: "#05060f",
+    theme_color: "#05060f",
+    lang: "de",
+    orientation: "any",
+    icons: [
+      { src: "/icon-192.png", sizes: "192x192", type: "image/png", purpose: "any" },
+      { src: "/icon-512.png", sizes: "512x512", type: "image/png", purpose: "any" },
+      // Getrennte Fassung mit mehr Rand: Android schneidet maskierbare
+      // Symbole je nach Geraet rund, eckig oder als Tropfen zu.
+      { src: "/icon-maskable-512.png", sizes: "512x512", type: "image/png", purpose: "maskable" },
+    ],
+    shortcuts: [
+      { name: "Dashboard", url: "/" },
+      { name: "Mein Konto", url: "/account" },
+    ],
+  };
+}

src/app/page.tsx

@@ -52,13 +52,17 @@ export default async function DashboardPage() {
         </p>
       </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

@@ -5,12 +5,13 @@ import { ActivityFeed } from "@/components/ActivityFeed";
 import { GitPanel } from "@/components/GitPanel";
 import { Markdown } from "@/components/Markdown";
 import { NotesPanel } from "@/components/NotesPanel";
+import { ReadmePanel } from "@/components/ReadmePanel";
 import { ProjectHeader } from "@/components/ProjectHeader";
 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";
@@ -54,6 +55,23 @@ 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
+    ? {
+        content: fuehrend.readme,
+        path: fuehrend.readmePath,
+        baseUrl: fuehrend.readmeBaseUrl,
+        // Die Basis endet auf dem Verzeichnis; angehaengt ergibt das die Datei.
+        fileUrl:
+          fuehrend.readmeBaseUrl && fuehrend.readmePath
+            ? `${fuehrend.readmeBaseUrl}${fuehrend.readmePath.split("/").pop()}`
+            : (fuehrend.htmlUrl ?? null),
+      }
+    : null;
+
   return (
     <div className="space-y-6 pt-4">
       <ProjectHeader
@@ -83,6 +101,17 @@ export default async function ProjectPage({ params }: PageProps) {
             )}
           </section>
 
+          {/* Das README des fuehrenden Repositories – bei mehreren waere eine
+              zweite Vorschau untereinander mehr Laenge als Nutzen. */}
+          {readme ? (
+            <ReadmePanel
+              content={readme.content}
+              path={readme.path}
+              baseUrl={readme.baseUrl}
+              fileUrl={readme.fileUrl}
+            />
+          ) : null}
+
           <NotesPanel projectId={detail.id} notes={detail.notes} />
         </div>
 
@@ -90,6 +119,7 @@ export default async function ProjectPage({ params }: PageProps) {
           <GitPanel
             project={detail}
             connections={connections as unknown as ConnectionSafe[]}
+            webhookRepoIds={webhookIds}
           />
           <ActivityFeed projectId={detail.id} initial={detail.activities} />
         </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/components/BulkBar.tsx

@@ -0,0 +1,214 @@
+"use client";
+
+import { useRef, useState } from "react";
+import { useRouter } from "next/navigation";
+import { Loader2, Star, Tag, Trash2, X } from "lucide-react";
+import type { ProjectStatus } from "@prisma/client";
+import { Popover } from "@/components/ui/Popover";
+import { STATUS_META, STATUS_ORDER } from "@/lib/status";
+import { cn, parseTags } from "@/lib/utils";
+
+/**
+ * Leiste fuer die Mehrfachauswahl. Erscheint erst, wenn etwas ausgewaehlt ist,
+ * und liegt fest am unteren Rand – bei einer langen Liste waere sie oben
+ * sonst laengst aus dem Blick gescrollt, waehrend man noch auswaehlt.
+ */
+export function BulkBar({
+  ids,
+  onDone,
+  onClear,
+}: {
+  ids: string[];
+  onDone: () => void;
+  onClear: () => void;
+}) {
+  const router = useRouter();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [statusOpen, setStatusOpen] = useState(false);
+  const [tagsOpen, setTagsOpen] = useState(false);
+  const [tagInput, setTagInput] = useState("");
+  const statusRef = useRef<HTMLButtonElement>(null);
+  const tagsRef = useRef<HTMLButtonElement>(null);
+
+  async function apply(body: Record<string, unknown>) {
+    setBusy(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/projects/bulk", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ids, ...body }),
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(payload.error ?? "Das hat nicht geklappt.");
+      onDone();
+      router.refresh();
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setBusy(false);
+      setStatusOpen(false);
+      setTagsOpen(false);
+    }
+  }
+
+  async function remove() {
+    if (
+      !window.confirm(
+        `${ids.length} Projekt${ids.length === 1 ? "" : "e"} mit allen Notizen und Aufgaben ` +
+          "unwiderruflich loeschen?",
+      )
+    ) {
+      return;
+    }
+    await apply({ action: "delete" });
+  }
+
+  return (
+    // 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>
+
+        <span className="h-5 w-px bg-white/10" aria-hidden />
+
+        <button
+          ref={statusRef}
+          type="button"
+          className="btn btn-ghost px-2.5 py-1.5 text-xs"
+          onClick={() => setStatusOpen((value) => !value)}
+          disabled={busy}
+          aria-haspopup="menu"
+          aria-expanded={statusOpen}
+        >
+          Status
+        </button>
+        <Popover
+          open={statusOpen}
+          anchorRef={statusRef}
+          onClose={() => setStatusOpen(false)}
+          align="start"
+        >
+          <div role="menu" className="min-w-[12rem] p-1">
+            {STATUS_ORDER.map((status) => (
+              <button
+                key={status}
+                type="button"
+                role="menuitem"
+                className="flex w-full items-center gap-2 rounded-lg px-2.5 py-2 text-left text-sm text-slate-300 hover:bg-white/6"
+                onClick={() => apply({ action: "status", status })}
+              >
+                <span
+                  className="h-2 w-2 rounded-full"
+                  style={{ backgroundColor: STATUS_META[status].color }}
+                />
+                {STATUS_META[status].label}
+              </button>
+            ))}
+          </div>
+        </Popover>
+
+        <button
+          ref={tagsRef}
+          type="button"
+          className="btn btn-ghost px-2.5 py-1.5 text-xs"
+          onClick={() => setTagsOpen((value) => !value)}
+          disabled={busy}
+          aria-haspopup="menu"
+          aria-expanded={tagsOpen}
+        >
+          <Tag className="h-3.5 w-3.5" />
+          Tags
+        </button>
+        {/* 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>
+            <input
+              id="bulk-tags"
+              className="field"
+              value={tagInput}
+              onChange={(event) => setTagInput(event.target.value)}
+              placeholder="experiment, archiv"
+              autoFocus
+            />
+            <div className="flex gap-2">
+              <button
+                type="button"
+                className="btn btn-primary flex-1 px-2 py-1.5 text-xs"
+                disabled={busy || parseTags(tagInput).length === 0}
+                onClick={() =>
+                  apply({ action: "tags", tags: parseTags(tagInput), tagMode: "add" })
+                }
+              >
+                Hinzufügen
+              </button>
+              <button
+                type="button"
+                className="btn btn-ghost flex-1 px-2 py-1.5 text-xs"
+                disabled={busy || parseTags(tagInput).length === 0}
+                onClick={() =>
+                  apply({ action: "tags", tags: parseTags(tagInput), tagMode: "remove" })
+                }
+              >
+                Entfernen
+              </button>
+            </div>
+          </div>
+        </Popover>
+
+        <button
+          type="button"
+          className="btn btn-ghost px-2.5 py-1.5 text-xs"
+          onClick={() => apply({ action: "favorite", favorite: true })}
+          disabled={busy}
+          title="Als Favoriten markieren"
+        >
+          <Star className="h-3.5 w-3.5" />
+        </button>
+
+        <button
+          type="button"
+          className="btn btn-ghost px-2.5 py-1.5 text-xs text-rose-200"
+          onClick={remove}
+          disabled={busy}
+        >
+          <Trash2 className="h-3.5 w-3.5" />
+          Löschen
+        </button>
+
+        {busy ? <Loader2 className="h-4 w-4 animate-spin text-slate-400" /> : null}
+
+        <button
+          type="button"
+          onClick={onClear}
+          className="rounded-lg p-1.5 text-slate-500 hover:text-white"
+          aria-label="Auswahl aufheben"
+        >
+          <X className="h-4 w-4" />
+        </button>
+
+        {error ? (
+          <p className={cn("w-full px-1 text-xs text-rose-300")}>{error}</p>
+        ) : null}
+      </div>
+    </div>
+  );
+}

src/components/ChangelogButton.tsx

@@ -0,0 +1,84 @@
+"use client";
+
+import { useState } from "react";
+import { Modal } from "@/components/ui/Modal";
+import { CHANGELOG, KIND_META } from "@/lib/changelog";
+import { cn, formatDate } from "@/lib/utils";
+
+/**
+ * Die Versionsnummer in der Fusszeile oeffnet den Aenderungsverlauf.
+ *
+ * Kein eigener Menuepunkt: gesucht wird so etwas erfahrungsgemaess dort, wo
+ * die Version steht – und einen Platz in der Navigation ist es nicht wert.
+ */
+export function ChangelogButton({ version }: { version: string }) {
+  const [open, setOpen] = useState(false);
+  const aktuell = CHANGELOG[0]?.version;
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={() => setOpen(true)}
+        className="rounded font-mono text-slate-600 underline decoration-dotted underline-offset-4 transition-colors hover:text-violet-300 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-violet-400/60"
+        title="Was ist neu?"
+      >
+        v{version}
+      </button>
+
+      <Modal
+        open={open}
+        onClose={() => setOpen(false)}
+        width="lg"
+        title="Änderungsverlauf"
+        description={
+          // Ein Hinweis, falls die laufende Fassung neuer ist als der Eintrag.
+          // Das passiert, wenn jemand die Version hochzaehlt und den Eintrag
+          // vergisst – dann soll es auffallen statt still danebenzustehen.
+          aktuell === version
+            ? "Was in den letzten Fassungen dazugekommen ist."
+            : `Diese Instanz läuft auf v${version}; der Verlauf endet bei v${aktuell}.`
+        }
+      >
+        <ol className="space-y-7">
+          {CHANGELOG.map((release) => (
+            <li key={release.version}>
+              <div className="flex flex-wrap items-baseline gap-x-3 gap-y-1">
+                <h3 className="font-mono text-base font-semibold text-white">
+                  v{release.version}
+                </h3>
+                {release.version === version ? (
+                  <span className="rounded-full bg-violet-500/15 px-2 py-0.5 text-[10px] uppercase tracking-wider text-violet-200 ring-1 ring-violet-400/30">
+                    installiert
+                  </span>
+                ) : null}
+                <span className="text-xs text-slate-500">{formatDate(release.date)}</span>
+              </div>
+
+              <p className="mt-1 text-sm text-slate-400">{release.headline}</p>
+
+              <ul className="mt-3 space-y-2">
+                {release.changes.map((change, index) => {
+                  const meta = KIND_META[change.kind];
+                  return (
+                    <li key={index} className="flex gap-2.5 text-sm leading-snug text-slate-300">
+                      <span
+                        className={cn(
+                          "mt-0.5 h-fit shrink-0 rounded-md px-1.5 py-0.5 text-[10px] font-medium uppercase tracking-wider ring-1",
+                          meta.className,
+                        )}
+                      >
+                        {meta.label}
+                      </span>
+                      <span className="min-w-0">{change.text}</span>
+                    </li>
+                  );
+                })}
+              </ul>
+            </li>
+          ))}
+        </ol>
+      </Modal>
+    </>
+  );
+}

src/components/CommandPalette.tsx

@@ -5,6 +5,7 @@ import { createPortal } from "react-dom";
 import { useRouter } from "next/navigation";
 import {
   Bell,
+  CheckSquare,
   CornerDownLeft,
   GitBranch,
   LayoutDashboard,
@@ -55,6 +56,13 @@ interface Action {
 
 const ACTIONS: Action[] = [
   { id: "dashboard", label: "Dashboard", hint: "Alle Projekte", icon: LayoutDashboard, href: "/" },
+  {
+    id: "tasks",
+    label: "Aufgaben",
+    hint: "Über alle Projekte, nach Fälligkeit",
+    icon: CheckSquare,
+    href: "/tasks",
+  },
   {
     id: "connections",
     label: "Git-Verbindungen",

src/components/GitPanel.tsx

@@ -17,6 +17,7 @@ import {
   Lock,
   Package,
   Plus,
+  Radio,
   RefreshCw,
   ShieldCheck,
   Star,
@@ -24,10 +25,12 @@ import {
   Unlink,
 } from "lucide-react";
 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, asRecord } from "@/types";
+import { asArray, asCalendar, asRecord } from "@/types";
 import type {
   BranchInfo,
   CommitInfo,
@@ -54,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");
@@ -64,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);
@@ -71,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() {
@@ -109,6 +118,7 @@ export function GitPanel({
   const pulls = asArray<TicketInfo>(snapshot?.pullRequests);
   const issues = asArray<TicketInfo>(snapshot?.issues);
   const activity = asArray<number>(snapshot?.commitActivity);
+  const calendar = asCalendar(snapshot?.commitCalendar);
 
   /** Ein einzelnes Repository oder – ohne Argument – alle. */
   async function sync(nurDieses?: string) {
@@ -278,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)}
@@ -310,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(
@@ -416,6 +454,9 @@ export function GitPanel({
             </div>
           ) : null}
 
+          {/* Der Jahresueberblick, sobald er einmal geholt wurde. */}
+          {calendar ? <Heatmap calendar={calendar} /> : null}
+
           {/* Sprachen */}
           {languageTotal > 0 ? (
             <div className="glass p-4">

src/components/Heatmap.tsx

@@ -0,0 +1,190 @@
+import { CalendarRange } from "lucide-react";
+import type { CommitCalendar } from "@/lib/git/calendar";
+import { formatDate } from "@/lib/utils";
+
+/**
+ * Commits je Tag als Kalender – ein Feld pro Tag, Wochen als Spalten.
+ *
+ * Wie die Verlaufslinie ohne Diagrammbibliothek: es sind Quadrate in einem
+ * Raster, dafuer braucht es keine Achsen und keine Legende ausser der
+ * Farbskala.
+ *
+ * Gezeichnet wird nur der Zeitraum, fuer den wirklich Daten vorliegen.
+ * Wo die Seiten des Anbieters nur ein paar Monate zurueckreichen, faengt die
+ * Heatmap dort an – ein leeres Feld wuerde sonst behaupten, an dem Tag sei
+ * nicht gearbeitet worden, obwohl darueber nichts bekannt ist.
+ */
+
+const WOCHENTAGE = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
+const MONATE = [
+  "Jan", "Feb", "Mär", "Apr", "Mai", "Jun",
+  "Jul", "Aug", "Sep", "Okt", "Nov", "Dez",
+];
+
+/** Fuenf Stufen, damit ein einzelner Ausreisser nicht alles andere platt macht. */
+function stufe(anzahl: number, hoch: number): number {
+  if (anzahl <= 0) return 0;
+  if (hoch <= 1) return 4;
+  const anteil = anzahl / hoch;
+  if (anteil > 0.75) return 4;
+  if (anteil > 0.5) return 3;
+  if (anteil > 0.25) return 2;
+  return 1;
+}
+
+const FARBEN = [
+  "fill-white/6",
+  "fill-violet-500/25",
+  "fill-violet-500/45",
+  "fill-violet-400/70",
+  "fill-violet-300",
+];
+
+/** Montag der Woche, in der dieser Tag liegt (UTC). */
+function wochenanfang(tag: Date): Date {
+  const kopie = new Date(tag);
+  // getUTCDay: 0 = Sonntag. Die Woche soll am Montag beginnen.
+  const versatz = (kopie.getUTCDay() + 6) % 7;
+  kopie.setUTCDate(kopie.getUTCDate() - versatz);
+  kopie.setUTCHours(0, 0, 0, 0);
+  return kopie;
+}
+
+export function Heatmap({ calendar }: { calendar: CommitCalendar }) {
+  const von = new Date(`${calendar.from}T00:00:00.000Z`);
+  const bis = new Date(`${calendar.to}T00:00:00.000Z`);
+  if (Number.isNaN(von.getTime()) || Number.isNaN(bis.getTime()) || von > bis) return null;
+
+  const start = wochenanfang(von);
+  const wochen: Array<Array<{ key: string; anzahl: number; ausserhalb: boolean }>> = [];
+
+  let hoechstwert = 0;
+  for (const wert of Object.values(calendar.days)) {
+    if (wert > hoechstwert) hoechstwert = wert;
+  }
+
+  const zeiger = new Date(start);
+  while (zeiger <= bis) {
+    const woche: Array<{ key: string; anzahl: number; ausserhalb: boolean }> = [];
+    for (let tag = 0; tag < 7; tag += 1) {
+      const key = zeiger.toISOString().slice(0, 10);
+      // Vor dem ersten bekannten Tag und nach heute wird nichts gezeichnet.
+      const ausserhalb = zeiger < von || zeiger > bis;
+      woche.push({ key, anzahl: calendar.days[key] ?? 0, ausserhalb });
+      zeiger.setUTCDate(zeiger.getUTCDate() + 1);
+    }
+    wochen.push(woche);
+  }
+
+  const gesamt = Object.values(calendar.days).reduce((sum, wert) => sum + wert, 0);
+  const tageMitCommits = Object.keys(calendar.days).length;
+
+  // Masse in SVG-Einheiten; die Breite ergibt sich aus der Zahl der Wochen.
+  const feld = 11;
+  const luecke = 3;
+  const kopf = 14;
+  const spalte = feld + luecke;
+  const breite = wochen.length * spalte - luecke;
+  const hoehe = kopf + 7 * spalte - luecke;
+
+  // Monatsbeschriftung an der Woche, in der ein neuer Monat beginnt.
+  const monate: Array<{ x: number; label: string }> = [];
+  let letzterMonat = -1;
+  wochen.forEach((woche, index) => {
+    const ersterTag = new Date(`${woche[0].key}T00:00:00.000Z`);
+    const monat = ersterTag.getUTCMonth();
+    if (monat !== letzterMonat) {
+      letzterMonat = monat;
+      monate.push({ x: index * spalte, label: MONATE[monat] });
+    }
+  });
+
+  return (
+    <div className="glass p-4">
+      <div className="mb-3 flex flex-wrap items-baseline justify-between gap-x-3 gap-y-1">
+        <p className="flex items-center gap-1.5 text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">
+          <CalendarRange className="h-3 w-3" />
+          Commits je Tag
+        </p>
+        <p className="text-[11px] text-slate-500">
+          {gesamt} an {tageMitCommits} {tageMitCommits === 1 ? "Tag" : "Tagen"} ·{" "}
+          {/* Der Zeitraum gehoert dazu: er ist nicht immer ein Jahr. */}
+          seit {formatDate(calendar.from)}
+          {calendar.truncated ? " (Älteres nicht abgerufen)" : ""}
+        </p>
+      </div>
+
+      <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="block shrink-0"
+          role="img"
+          aria-label={`Commits je Tag seit ${formatDate(calendar.from)}: ${gesamt} an ${tageMitCommits} Tagen`}
+        >
+          {monate.map((monat, index) => (
+            <text
+              key={`${monat.label}-${index}`}
+              x={monat.x + 22}
+              y={9}
+              className="fill-slate-500 text-[8px]"
+            >
+              {monat.label}
+            </text>
+          ))}
+
+          {/* Nur jeder zweite Wochentag, sonst steht es zu eng. */}
+          {WOCHENTAGE.map((tag, index) =>
+            index % 2 === 1 ? (
+              <text
+                key={tag}
+                x={0}
+                y={kopf + index * spalte + feld - 2}
+                className="fill-slate-600 text-[7px]"
+              >
+                {tag}
+              </text>
+            ) : null,
+          )}
+
+          {wochen.map((woche, x) =>
+            woche.map((tag, y) =>
+              tag.ausserhalb ? null : (
+                <rect
+                  key={tag.key}
+                  x={x * spalte + 22}
+                  y={kopf + y * spalte}
+                  width={feld}
+                  height={feld}
+                  rx={2}
+                  className={FARBEN[stufe(tag.anzahl, hoechstwert)]}
+                >
+                  <title>
+                    {`${formatDate(tag.key)}: ${tag.anzahl} ${tag.anzahl === 1 ? "Commit" : "Commits"}`}
+                  </title>
+                </rect>
+              ),
+            ),
+          )}
+        </svg>
+      </div>
+
+      <div className="mt-2 flex items-center justify-end gap-1.5 text-[10px] text-slate-600">
+        <span>weniger</span>
+        {FARBEN.map((farbe, index) => (
+          <svg key={index} width={9} height={9} aria-hidden>
+            <rect width={9} height={9} rx={2} className={farbe} />
+          </svg>
+        ))}
+        <span>mehr</span>
+      </div>
+    </div>
+  );
+}

src/components/KanbanBoard.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import {
@@ -8,53 +8,81 @@ import {
   DragOverlay,
   PointerSensor,
   TouchSensor,
-  closestCorners,
+  pointerWithin,
-  useDraggable,
   useDroppable,
   useSensor,
   useSensors,
   type DragEndEvent,
+  type DragOverEvent,
   type DragStartEvent,
 } from "@dnd-kit/core";
 import { restrictToWindowEdges } from "@dnd-kit/modifiers";
-import { GitBranch, GripVertical, NotebookPen } from "lucide-react";
+import { SortableContext, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { GitBranch, GripVertical, Loader2, NotebookPen } from "lucide-react";
 import type { ProjectStatus } from "@prisma/client";
 import { CiBadge } from "@/components/CiBadge";
 import { STATUS_META, STATUS_ORDER, accentOf } from "@/lib/status";
 import { cn, truncate } from "@/lib/utils";
 import type { ProjectListItem } from "@/types";
 
+type Columns = Record<ProjectStatus, ProjectListItem[]>;
+
 /**
- * Statusspalten mit Ziehen und Ablegen.
+ * Statusspalten mit Ziehen, Ablegen und freier Reihenfolge.
  *
- * Der Statuswechsel wird sofort angezeigt und erst danach gespeichert;
+ * Die Reihenfolge innerhalb einer Spalte wird als Position am Projekt
- * scheitert das Speichern, springt die Karte zurueck. Die Reihenfolge
+ * gespeichert – wie beim Aufgabenbrett. Deshalb richtet sich das Brett auch
- * innerhalb einer Spalte ist nicht frei sortierbar – sie folgt der im Board
+ * nicht nach der im Kopf gewaehlten Sortierung: die gilt fuer Raster und
- * gewaehlten Sortierung, sonst muesste eine Position mitgespeichert werden.
+ * Gruppen, hier zaehlt die Anordnung von Hand.
+ *
+ * Verschieben wird sofort angezeigt und erst danach gespeichert; scheitert
+ * das Speichern, springt alles auf den Serverstand zurueck.
  */
 export function KanbanBoard({
   projects,
   showArchived,
+  selection,
+  onToggleSelect,
 }: {
   projects: ProjectListItem[];
   showArchived: boolean;
+  selection: Set<string>;
+  onToggleSelect: (id: string, selected: boolean) => void;
 }) {
   const router = useRouter();
-  const [overrides, setOverrides] = useState<Record<string, ProjectStatus>>({});
   const [activeId, setActiveId] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
 
-  // Eine Verschiebung, die der Server bestaetigt hat, braucht keine
+  const sichtbar = useMemo(
-  // oertliche Ausnahme mehr.
+    () => STATUS_ORDER.filter((status) => showArchived || status !== "ARCHIVED"),
-  useEffect(() => {
+    [showArchived],
-    setOverrides((current) => {
+  );
-      const next: Record<string, ProjectStatus> = {};
+
-      for (const [id, status] of Object.entries(current)) {
+  const group = useMemo(
-        const project = projects.find((entry) => entry.id === id);
+    () => (list: ProjectListItem[]): Columns => {
-        if (project && project.status !== status) next[id] = status;
+      const leer = Object.fromEntries(
+        STATUS_ORDER.map((status) => [status, [] as ProjectListItem[]]),
+      ) as Columns;
+      for (const project of list) leer[project.status].push(project);
+      for (const status of STATUS_ORDER) {
+        // Bei gleicher Position bleibt es bei der Reihenfolge, in der die
+        // Liste kam – das ist die im Kopf gewaehlte Sortierung.
+        leer[status].sort((a, b) => a.position - b.position);
       }
-      return Object.keys(next).length === Object.keys(current).length ? current : next;
+      return leer;
-    });
+    },
-  }, [projects]);
+    [],
+  );
+
+  const [columns, setColumns] = useState<Columns>(() => group(projects));
+
+  // Waehrend eines Zuges nicht dazwischenfunken: der Serverstand ist dann
+  // noch der alte und wuerde die Karte zurueckspringen lassen.
+  const dragging = useRef(false);
+  useEffect(() => {
+    if (!dragging.current) setColumns(group(projects));
+  }, [projects, group]);
 
   const sensors = useSensors(
     // Erst ab ein paar Pixeln Bewegung ziehen – sonst liesse sich die Karte
@@ -63,72 +91,138 @@ export function KanbanBoard({
     useSensor(TouchSensor, { activationConstraint: { delay: 180, tolerance: 8 } }),
   );
 
-  const statusOf = (project: ProjectListItem) => overrides[project.id] ?? project.status;
+  const active = activeId
+    ? Object.values(columns).flat().find((project) => project.id === activeId) ?? null
+    : null;
 
-  const columns = useMemo(() => {
+  /** In welcher Spalte steckt diese Kennung – oder ist sie selbst eine? */
-    const visible = STATUS_ORDER.filter(
+  function containerOf(key: string): ProjectStatus | null {
-      (status) => showArchived || status !== "ARCHIVED",
+    if ((STATUS_ORDER as string[]).includes(key)) return key as ProjectStatus;
+    return (
+      STATUS_ORDER.find((status) => columns[status].some((project) => project.id === key)) ?? null
     );
-    return visible.map((status) => ({
+  }
-      status,
-      items: projects.filter((project) => statusOf(project) === status),
-    }));
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [projects, overrides, showArchived]);
-
-  const active = activeId ? projects.find((project) => project.id === activeId) : null;
 
   function onDragStart(event: DragStartEvent) {
+    dragging.current = true;
     setActiveId(String(event.active.id));
   }
 
+  function onDragOver(event: DragOverEvent) {
+    const activeKey = String(event.active.id);
+    const overKey = event.over ? String(event.over.id) : null;
+    if (!overKey) return;
+
+    const from = containerOf(activeKey);
+    const to = containerOf(overKey);
+    if (!from || !to || from === to) return;
+
+    setColumns((current) => {
+      const moved = current[from].find((project) => project.id === activeKey);
+      if (!moved) return current;
+
+      const zielIndex = current[to].findIndex((project) => project.id === overKey);
+      const einfuegenBei = zielIndex >= 0 ? zielIndex : current[to].length;
+
+      return {
+        ...current,
+        [from]: current[from].filter((project) => project.id !== activeKey),
+        [to]: [
+          ...current[to].slice(0, einfuegenBei),
+          { ...moved, status: to },
+          ...current[to].slice(einfuegenBei),
+        ],
+      };
+    });
+  }
+
   async function onDragEnd(event: DragEndEvent) {
+    const activeKey = String(event.active.id);
+    const overKey = event.over ? String(event.over.id) : null;
+
+    let next = columns;
+
+    if (overKey) {
+      const container = containerOf(activeKey);
+      const ueber = containerOf(overKey);
+      if (container && container === ueber) {
+        const list = columns[container];
+        const alt = list.findIndex((project) => project.id === activeKey);
+        const neu = list.findIndex((project) => project.id === overKey);
+        if (alt >= 0 && neu >= 0 && alt !== neu) {
+          const sortiert = [...list];
+          const [moved] = sortiert.splice(alt, 1);
+          sortiert.splice(neu, 0, moved);
+          next = { ...columns, [container]: sortiert };
+          setColumns(next);
+        }
+      }
+    }
+
     setActiveId(null);
+    dragging.current = false;
+    await persist(next);
+  }
 
-    const id = String(event.active.id);
+  async function persist(next: Columns) {
-    const target = event.over?.id ? (String(event.over.id) as ProjectStatus) : null;
+    setSaving(true);
-    if (!target) return;
-
-    const project = projects.find((entry) => entry.id === id);
-    if (!project) return;
-
-    const previous = statusOf(project);
-    if (previous === target) return;
-
-    setOverrides((current) => ({ ...current, [id]: target }));
-
     try {
-      const response = await fetch(`/api/projects/${id}`, {
+      const response = await fetch("/api/projects/reorder", {
         method: "PATCH",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ status: target }),
+        body: JSON.stringify({
+          columns: Object.fromEntries(
+            sichtbar.map((status) => [status, next[status].map((project) => project.id)]),
+          ),
+        }),
       });
       if (!response.ok) throw new Error("failed");
       router.refresh();
     } catch {
-      setOverrides((current) => {
+      // Zurueck auf den Serverstand – die Bewegung war dann nur optisch.
-        const next = { ...current };
+      setColumns(group(projects));
-        delete next[id];
+    } finally {
-        return next;
+      setSaving(false);
-      });
     }
   }
 
   return (
     <DndContext
       sensors={sensors}
-      collisionDetection={closestCorners}
+      collisionDetection={pointerWithin}
       modifiers={[restrictToWindowEdges]}
       onDragStart={onDragStart}
+      onDragOver={onDragOver}
       onDragEnd={onDragEnd}
-      onDragCancel={() => setActiveId(null)}
+      onDragCancel={() => {
+        setActiveId(null);
+        dragging.current = false;
+        setColumns(group(projects));
+      }}
     >
+      {saving ? (
+        <p className="mb-2 flex items-center gap-1.5 text-[11px] text-slate-500">
+          <Loader2 className="h-3 w-3 animate-spin" />
+          Reihenfolge wird gespeichert…
+        </p>
+      ) : null}
+
       <div className="flex gap-3 overflow-x-auto pb-3">
-        {columns.map((column) => (
+        {sichtbar.map((status) => (
-          <Column key={column.status} status={column.status} count={column.items.length}>
+          <Column key={status} status={status} count={columns[status].length}>
-            {column.items.map((project) => (
+            <SortableContext
-              <KanbanCard key={project.id} project={project} />
+              items={columns[status].map((project) => project.id)}
-            ))}
+              strategy={verticalListSortingStrategy}
+            >
+              {columns[status].map((project) => (
+                <KanbanCard
+                  key={project.id}
+                  project={project}
+                  selected={selection.has(project.id)}
+                  onToggleSelect={onToggleSelect}
+                />
+              ))}
+            </SortableContext>
           </Column>
         ))}
       </div>
@@ -159,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",
       )}
     >
@@ -196,28 +294,36 @@ function Column({
 function KanbanCard({
   project,
   overlay = false,
+  selected = false,
+  onToggleSelect,
 }: {
   project: ProjectListItem;
   overlay?: boolean;
+  selected?: boolean;
+  onToggleSelect?: (id: string, selected: boolean) => void;
 }) {
   const accent = accentOf(project.accent);
-  const { attributes, listeners, setNodeRef, isDragging } = useDraggable({ id: project.id });
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
+    id: project.id,
+  });
 
   return (
     <article
       ref={overlay ? undefined : setNodeRef}
+      style={
+        {
+          "--accent-from": accent.from,
+          "--accent-to": accent.to,
+          ...(overlay ? {} : { transform: CSS.Transform.toString(transform), transition }),
+        } as React.CSSProperties
+      }
       className={cn(
         "popover group relative overflow-hidden p-3",
         // Das Original bleibt als blasser Platzhalter stehen.
         isDragging && !overlay && "opacity-30",
         overlay && "rotate-2 cursor-grabbing shadow-2xl ring-1 ring-violet-400/40",
+        selected && "ring-1 ring-violet-400/60",
       )}
-      style={
-        {
-          "--accent-from": accent.from,
-          "--accent-to": accent.to,
-        } as React.CSSProperties
-      }
     >
       <span className="accent-bar absolute inset-x-0 top-0 h-[2px] opacity-70" aria-hidden="true" />
 
@@ -233,6 +339,16 @@ function KanbanCard({
           <GripVertical className="h-3.5 w-3.5" />
         </button>
 
+        {onToggleSelect ? (
+          <input
+            type="checkbox"
+            checked={selected}
+            onChange={(event) => onToggleSelect(project.id, event.target.checked)}
+            className="mt-1 h-3.5 w-3.5 shrink-0 accent-violet-500"
+            aria-label={`${project.name} auswaehlen`}
+          />
+        ) : null}
+
         <div className="min-w-0 flex-1">
           <Link
             href={`/projects/${project.id}`}

src/components/Markdown.test.tsx

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import { Markdown } from "./Markdown";
+
+/**
+ * Markdown kommt aus zwei Quellen, denen nicht zu trauen ist: eigenen
+ * Notizen (die zwar der Benutzer schreibt, aber ohne Bereinigung ein
+ * XSS-Loch waeren) und dem README eines fremden Repositories.
+ *
+ * Diese Tests halten die Bereinigung fest. Sie rendern serverseitig, was
+ * fuer die Frage genuegt – es geht um das erzeugte HTML, nicht um
+ * Verhalten im Browser.
+ */
+
+const html = (text: string, baseUrl?: string) =>
+  renderToStaticMarkup(<Markdown baseUrl={baseUrl}>{text}</Markdown>);
+
+describe("Bereinigung", () => {
+  it("laesst kein script durch", () => {
+    const ausgabe = html("<script>alert(1)</script>\n\nText danach.");
+    expect(ausgabe).not.toContain("<script");
+    expect(ausgabe).not.toContain("alert(1)");
+    expect(ausgabe).toContain("Text danach.");
+  });
+
+  it("entfernt Ereignis-Attribute aus rohem HTML", () => {
+    const ausgabe = html('<img src="x" onerror="alert(1)">');
+    expect(ausgabe).not.toContain("onerror");
+    expect(ausgabe).not.toContain("alert");
+  });
+
+  it("laesst kein javascript: als Link durch", () => {
+    const ausgabe = html("[klick](javascript:alert(1))");
+    expect(ausgabe).not.toContain("javascript:");
+  });
+
+  it("laesst kein javascript: ueber ein Bild durch", () => {
+    // Das Bild wird zu einem Link umgebaut – die Quelle darf dabei nicht
+    // unbesehen zum href werden.
+    const ausgabe = html("![x](javascript:alert(1))");
+    expect(ausgabe).not.toContain("javascript:");
+  });
+
+  it("laesst kein data: mit HTML durch", () => {
+    const ausgabe = html("[klick](data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==)");
+    expect(ausgabe).not.toContain("data:text/html");
+  });
+
+  it("haengt an jeden Link noopener und noreferrer", () => {
+    const ausgabe = html("[Ziel](https://example.com)");
+    expect(ausgabe).toContain('target="_blank"');
+    expect(ausgabe).toContain("noopener");
+    expect(ausgabe).toContain("noreferrer");
+  });
+
+  it("laedt keine Bilder, sondern zeigt eine Marke", () => {
+    // Die Content-Security-Policy erlaubt img-src nur von der eigenen
+    // Instanz; ein fremdes README duerfte sonst Zaehlpixel nachladen.
+    const ausgabe = html("![Abzeichen](https://example.com/badge.svg)");
+    expect(ausgabe).not.toContain("<img");
+    expect(ausgabe).toContain("md-image");
+    expect(ausgabe).toContain("Abzeichen");
+  });
+});
+
+describe("Relative Verweise", () => {
+  const BASIS = "https://git.example.com/o/r/blob/main/";
+
+  it("loest relative Links gegen die Basis auf", () => {
+    expect(html("[Doku](docs/x.md)", BASIS)).toContain(`${BASIS}docs/x.md`);
+  });
+
+  it("laesst absolute Links und Anker in Ruhe", () => {
+    expect(html("[Extern](https://example.com/a)", BASIS)).toContain("https://example.com/a");
+    expect(html("[Anker](#titel)", BASIS)).toContain('href="#titel"');
+  });
+
+  it("laesst ohne Basis alles unveraendert", () => {
+    expect(html("[Doku](docs/x.md)")).toContain('href="docs/x.md"');
+  });
+
+  it("erzeugt aus einem Bild im Link keinen Link im Link", () => {
+    // "[![Abzeichen](bild)](ziel)" ist in READMEs die Regel. Ein a im a ist
+    // ungueltiges HTML; der Browser zieht es auseinander, was zu einem
+    // Hydrationsfehler fuehrt – genau daran ist der erste Versuch gescheitert.
+    const ausgabe = html("[![Abzeichen](img/b.svg)](https://example.com/ziel)", BASIS);
+    expect(ausgabe).toContain("<span");
+    expect(ausgabe.match(/<a /g) ?? []).toHaveLength(1);
+  });
+});

src/components/Markdown.tsx

@@ -24,12 +24,93 @@ const schema = {
   },
 };
 
+/** Loest relative Verweise gegen die Basis auf; laesst absolute in Ruhe. */
+function absolut(href: string | undefined, base: string | null | undefined): string | undefined {
+  if (!href || !base) return href;
+  if (/^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//") || href.startsWith("#")) {
+    return href;
+  }
+  try {
+    return new URL(href, base).toString();
+  } catch {
+    return href;
+  }
+}
+
+type HastNode = {
+  type: string;
+  tagName?: string;
+  properties?: Record<string, unknown>;
+  children?: HastNode[];
+  value?: string;
+};
+
+/**
+ * Ersetzt Bilder durch eine anklickbare Marke – siehe die Begruendung
+ * unten am `.md-image`-Stil.
+ *
+ * Das passiert im Baum und nicht ueber eine Komponente, weil es auf den
+ * Elternknoten ankommt: `[![Abzeichen](bild)](ziel)` ist in READMEs die
+ * Regel, und ein `<a>` in einem `<a>` ist ungueltiges HTML. Der Browser
+ * zieht es beim Parsen auseinander, was zu einem Hydrationsfehler fuehrt –
+ * genau daran ist es beim ersten Versuch gescheitert. Innerhalb eines Links
+ * bleibt deshalb nur der Text stehen; der umgebende Link ist ohnehin das,
+ * was man anklicken will.
+ */
+function bilderAlsMarke(base: string | null | undefined) {
+  return () => (tree: HastNode) => {
+    const gehe = (knoten: HastNode, inLink: boolean) => {
+      const kinder = knoten.children;
+      if (!kinder) return;
+
+      for (let index = 0; index < kinder.length; index += 1) {
+        const kind = kinder[index];
+
+        if (kind.type === "element" && kind.tagName === "img") {
+          const quelle = typeof kind.properties?.src === "string" ? kind.properties.src : undefined;
+          const alt = typeof kind.properties?.alt === "string" ? kind.properties.alt.trim() : "";
+          const text: HastNode = { type: "text", value: alt || "Bild" };
+          const ziel = absolut(quelle, base);
+
+          kinder[index] =
+            inLink || !ziel
+              ? { type: "element", tagName: "span", properties: { className: ["md-image"] }, children: [text] }
+              : {
+                  type: "element",
+                  tagName: "a",
+                  properties: {
+                    className: ["md-image"],
+                    href: ziel,
+                    title: ziel,
+                    target: "_blank",
+                    rel: "noreferrer noopener nofollow",
+                  },
+                  children: [text],
+                };
+          continue;
+        }
+
+        gehe(kind, inLink || (kind.type === "element" && kind.tagName === "a"));
+      }
+    };
+
+    gehe(tree, false);
+  };
+}
+
 export function Markdown({
   children,
   className,
+  baseUrl,
 }: {
   children: string | null | undefined;
   className?: string;
+  /**
+   * Wogegen relative Verweise aufzuloesen sind. Gesetzt beim README aus
+   * einem Repository – dort zeigen Links auf Dateien daneben, die ohne
+   * Basis ins Leere liefen.
+   */
+  baseUrl?: string | null;
 }) {
   if (!children?.trim()) return null;
 
@@ -37,12 +118,22 @@ export function Markdown({
     <div className={cn("md", className)}>
       <ReactMarkdown
         remarkPlugins={[remarkGfm]}
-        rehypePlugins={[[rehypeSanitize, schema]]}
+        // Erst bereinigen, dann umbauen: die Marke soll nicht selbst durch
+        // die Bereinigung laufen und dabei ihre Klassen verlieren.
+        rehypePlugins={[[rehypeSanitize, schema], bilderAlsMarke(baseUrl)]}
         components={{
           // Links aus fremdem Inhalt immer in neuem Tab und ohne
           // Zugriff auf das oeffnende Fenster.
-          a: ({ href, children: content }) => (
+          // className muss durchgereicht werden, sonst verlieren die
-            <a href={href} target="_blank" rel="noreferrer noopener nofollow">
+          // Bildmarken aus dem Umbau oben ihre Gestalt.
+          a: ({ href, className: klasse, title, children: content }) => (
+            <a
+              href={absolut(href, baseUrl)}
+              className={klasse}
+              title={title}
+              target="_blank"
+              rel="noreferrer noopener nofollow"
+            >
               {content}
             </a>
           ),

src/components/ProjectBoard.tsx

@@ -7,6 +7,7 @@ import {
   Database,
   Download,
   LayoutGrid,
+  List,
   ListFilter,
   NotebookPen,
   Plus,
@@ -16,10 +17,12 @@ import {
   X,
 } from "lucide-react";
 import type { ProjectStatus } 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 { cn } from "@/lib/utils";
@@ -52,7 +55,20 @@ 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", "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";
 
 const SORT_LABEL: Record<SortKey, string> = {
   updated: "Zuletzt geaendert",
@@ -74,11 +90,52 @@ export function ProjectBoard({
   const [sort, setSort] = useState<SortKey>("updated");
   const [view, setView] = useState<ViewMode>("grid");
   const [showArchived, setShowArchived] = useState(false);
+
+  /**
+   * Ansicht und Sortierung ueberdauern das Neuladen.
+   *
+   * Wer sein Brett von Hand anordnet, will es beim naechsten Aufruf auch
+   * sehen und nicht wieder das Raster. Bewusst erst nach dem ersten Rendern
+   * gelesen: der Server kennt den gespeicherten Wert nicht, und ein
+   * Unterschied zwischen beiden waere ein Hydrationsfehler.
+   *
+   * Der Suchbegriff bleibt aussen vor – eine Suche von gestern beim Oeffnen
+   * wiederherzustellen waere eher verwirrend als hilfreich.
+   */
+  useEffect(() => {
+    try {
+      const gespeichert = window.localStorage.getItem(ANSICHT_SCHLUESSEL);
+      if (!gespeichert) return;
+      const wert = JSON.parse(gespeichert) as Partial<{
+        view: ViewMode;
+        sort: SortKey;
+        showArchived: boolean;
+      }>;
+      if (wert.view && VIEWS.includes(wert.view)) setView(wert.view);
+      if (wert.sort && wert.sort in SORT_LABEL) setSort(wert.sort);
+      if (typeof wert.showArchived === "boolean") setShowArchived(wert.showArchived);
+    } catch {
+      // Kaputter oder gesperrter Speicher: dann eben die Voreinstellung.
+    }
+  }, []);
+
+  useEffect(() => {
+    try {
+      window.localStorage.setItem(
+        ANSICHT_SCHLUESSEL,
+        JSON.stringify({ view, sort, showArchived }),
+      );
+    } catch {
+      // Im privaten Modus mancher Browser nicht beschreibbar – kein Grund,
+      // die Seite scheitern zu lassen.
+    }
+  }, [view, sort, showArchived]);
   const [dialogOpen, setDialogOpen] = useState(false);
   const [importOpen, setImportOpen] = useState(false);
   const [dataMenuOpen, setDataMenuOpen] = useState(false);
   const dataButtonRef = useRef<HTMLButtonElement>(null);
   const [noteHits, setNoteHits] = useState<NoteHit[]>([]);
+  const [selection, setSelection] = useState<Set<string>>(new Set());
 
   /**
    * Notizen liegen im Board nicht vor – sie mitzuladen wuerde die Seite
@@ -174,6 +231,28 @@ export function ProjectBoard({
     })).filter((group) => group.items.length > 0);
   }, [visible]);
 
+  /**
+   * Was der Filter ausblendet, bleibt nicht ausgewaehlt. Sonst traefe eine
+   * Massenaenderung Projekte, die man gar nicht mehr vor Augen hat.
+   */
+  useEffect(() => {
+    setSelection((current) => {
+      if (current.size === 0) return current;
+      const sichtbar = new Set(visible.map((project) => project.id));
+      const next = new Set([...current].filter((id) => sichtbar.has(id)));
+      return next.size === current.size ? current : next;
+    });
+  }, [visible]);
+
+  function toggleSelect(id: string, selected: boolean) {
+    setSelection((current) => {
+      const next = new Set(current);
+      if (selected) next.add(id);
+      else next.delete(id);
+      return next;
+    });
+  }
+
   function toggleStatus(status: ProjectStatus) {
     setStatusFilter((current) =>
       current.includes(status)
@@ -186,10 +265,14 @@ export function ProjectBoard({
 
   return (
     <section className="space-y-5">
-      {/* Steuerleiste */}
+      {/* Steuerleiste.
-      <div className="glass flex flex-col gap-4 p-4">
+          Auf dem Telefon steht die Suche allein in der ersten Zeile und die
-        <div className="flex flex-wrap items-center gap-3">
+          Werkzeuge darunter. Frueher lagen beide in einer Zeile, die nicht
-          <div className="relative min-w-[220px] flex-1">
+          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"
@@ -213,11 +296,22 @@ 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
+              // stehen zu lassen, ohne dass sie etwas bewirkt, waere irrefuehrend.
+              disabled={view === "kanban"}
+              title={
+                view === "kanban"
+                  ? "Im Brett bestimmt die Reihenfolge, in der du die Karten ablegst."
+                  : undefined
+              }
             >
               {(Object.keys(SORT_LABEL) as SortKey[]).map((key) => (
                 <option key={key} value={key}>
@@ -226,50 +320,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"
@@ -278,13 +333,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" />
@@ -388,11 +481,24 @@ export function ProjectBoard({
       {visible.length === 0 ? (
         <EmptyState hasFilters={hasFilters} onCreate={() => setDialogOpen(true)} />
       ) : view === "kanban" ? (
-        <KanbanBoard projects={visible} showArchived={showArchived} />
+        <KanbanBoard
+          projects={visible}
+          showArchived={showArchived}
+          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) => (
-            <ProjectCard key={project.id} project={project} index={index} />
+            <ProjectCard
+              key={project.id}
+              project={project}
+              index={index}
+              selected={selection.has(project.id)}
+              onToggleSelect={toggleSelect}
+            />
           ))}
         </div>
       ) : (
@@ -416,7 +522,13 @@ export function ProjectBoard({
                 </div>
                 <div className="grid gap-4 sm:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4">
                   {group.items.map((project, index) => (
-                    <ProjectCard key={project.id} project={project} index={index} />
+                    <ProjectCard
+                      key={project.id}
+                      project={project}
+                      index={index}
+                      selected={selection.has(project.id)}
+                      onToggleSelect={toggleSelect}
+                    />
                   ))}
                 </div>
               </div>
@@ -425,6 +537,14 @@ export function ProjectBoard({
         </div>
       )}
 
+      {selection.size > 0 ? (
+        <BulkBar
+          ids={[...selection]}
+          onDone={() => setSelection(new Set())}
+          onClear={() => setSelection(new Set())}
+        />
+      ) : null}
+
       <Popover
         anchorRef={dataButtonRef}
         open={dataMenuOpen}

src/components/ProjectCard.tsx

@@ -29,7 +29,17 @@ const PROVIDER_LABEL: Record<string, string> = {
  * Karte im Board. Die gesamte Flaeche ist ein Link (per "stretched link"),
  * interaktive Elemente liegen darueber und bekommen pointer-events zurueck.
  */
-export function ProjectCard({ project, index = 0 }: { project: ProjectListItem; index?: number }) {
+export function ProjectCard({
+  project,
+  index = 0,
+  selected = false,
+  onToggleSelect,
+}: {
+  project: ProjectListItem;
+  index?: number;
+  selected?: boolean;
+  onToggleSelect?: (id: string, selected: boolean) => void;
+}) {
   const accent = accentOf(project.accent);
   const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
   // Auf der Karte ist nur fuer eines Platz: das fuehrende. Wie viele es
@@ -60,7 +70,10 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
 
   return (
     <article
-      className="glass card-glow fade-up group relative overflow-hidden p-5"
+      className={cn(
+        "glass card-glow fade-up group relative overflow-hidden p-5",
+        selected && "ring-1 ring-violet-400/60",
+      )}
       style={
         {
           "--accent-from": accent.from,
@@ -81,6 +94,21 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
         <div className="flex items-start justify-between gap-3">
           <div className="min-w-0 flex-1">
             <div className="flex items-center gap-2">
+              {/* Gedaempft, aber immer da. Nur beim Ueberfahren einzublenden
+                  waere auf einem Touchgeraet gar nicht erreichbar – und wer
+                  es nie sieht, weiss nicht, dass es die Auswahl gibt. */}
+              {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-3.5 w-3.5 shrink-0 accent-violet-500 transition-opacity",
+                    !selected && "opacity-35 group-hover:opacity-100 focus-visible:opacity-100",
+                  )}
+                />
+              ) : null}
               <h3 className="truncate text-base font-semibold text-white transition-colors group-hover:text-violet-200">
                 {project.name}
               </h3>

src/components/ProjectDialog.tsx

@@ -2,7 +2,7 @@
 
 import { useEffect, useMemo, useState } from "react";
 import { useRouter } from "next/navigation";
-import { Loader2, RefreshCw, Search } from "lucide-react";
+import { Loader2, RefreshCw, Search, Trash2 } from "lucide-react";
 import type { ProjectStatus } from "@prisma/client";
 import { Modal } from "@/components/ui/Modal";
 import { ACCENTS, PRIORITY_META, STATUS_META, STATUS_ORDER } from "@/lib/status";
@@ -17,6 +17,33 @@ interface ProjectDialogProps {
   project?: ProjectListItem | null;
 }
 
+/** Eine Vorlage, so wie sie /api/templates liefert. */
+export interface ProjectTemplateEntry {
+  id: string;
+  name: string;
+  description: string | null;
+  summary: string | null;
+  projectDescription: string | null;
+  status: ProjectStatus;
+  priority: number;
+  accent: string;
+  tags: string[];
+  progressFromTasks: boolean;
+  notes: unknown[];
+  tasks: unknown[];
+}
+
+/** "3 Notizen, 5 Aufgaben" – oder was davon zutrifft. */
+function beschreibeVorlage(vorlage: ProjectTemplateEntry): string {
+  const teile: string[] = [];
+  const notizen = Array.isArray(vorlage.notes) ? vorlage.notes.length : 0;
+  const aufgaben = Array.isArray(vorlage.tasks) ? vorlage.tasks.length : 0;
+  if (notizen > 0) teile.push(`${notizen} ${notizen === 1 ? "Notiz" : "Notizen"}`);
+  if (aufgaben > 0) teile.push(`${aufgaben} ${aufgaben === 1 ? "Aufgabe" : "Aufgaben"}`);
+  if (vorlage.tags.length > 0) teile.push(vorlage.tags.map((tag) => `#${tag}`).join(" "));
+  return teile.length > 0 ? teile.join(" · ") : "nur Stammdaten";
+}
+
 interface FormState {
   name: string;
   summary: string;
@@ -33,6 +60,8 @@ interface FormState {
   repoName: string;
   autoSync: boolean;
   progressFromTasks: boolean;
+  /** Nur beim Anlegen: aus welcher Vorlage Notizen und Aufgaben kommen. */
+  templateId: string;
 }
 
 const EMPTY: FormState = {
@@ -51,6 +80,7 @@ const EMPTY: FormState = {
   repoName: "",
   autoSync: true,
   progressFromTasks: false,
+  templateId: "",
 };
 
 export function ProjectDialog({ open, onClose, connections, project }: ProjectDialogProps) {
@@ -60,14 +90,72 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
   const [error, setError] = useState<string | null>(null);
   const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});
 
+  const isEdit = Boolean(project);
+
+  const [templates, setTemplates] = useState<ProjectTemplateEntry[]>([]);
+  const gewaehlteVorlage = templates.find((entry) => entry.id === form.templateId) ?? null;
+
+  /**
+   * Die Vorlagen werden erst geladen, wenn der Dialog aufgeht – und nur zum
+   * Anlegen. Beim Bearbeiten waeren sie nur Ballast.
+   */
+  useEffect(() => {
+    if (!open || isEdit) return;
+    let abgebrochen = false;
+    fetch("/api/templates")
+      .then((response) => (response.ok ? response.json() : { templates: [] }))
+      .then((payload) => {
+        if (!abgebrochen) setTemplates(payload.templates ?? []);
+      })
+      .catch(() => undefined);
+    return () => {
+      abgebrochen = true;
+    };
+  }, [open, isEdit]);
+
+  /**
+   * Uebernimmt die Stammdaten sichtbar in die Felder. Notizen und Aufgaben
+   * bleiben der Serverseite ueberlassen: sie liessen sich hier nicht
+   * darstellen, und wer die Vorlage wieder abwaehlt, soll sie auch nicht
+   * mitgeschleppt bekommen.
+   *
+   * Bereits Getipptes wird nicht ueberschrieben – nur leere Felder werden
+   * gefuellt.
+   */
+  function applyTemplate(templateId: string) {
+    const vorlage = templates.find((entry) => entry.id === templateId);
+    if (!vorlage) {
+      update("templateId", "");
+      return;
+    }
+
+    setForm((previous) => ({
+      ...previous,
+      templateId,
+      name: previous.name || vorlage.name,
+      summary: previous.summary || (vorlage.summary ?? ""),
+      description: previous.description || (vorlage.projectDescription ?? ""),
+      status: vorlage.status,
+      priority: vorlage.priority,
+      accent: vorlage.accent,
+      tags: previous.tags || vorlage.tags.join(", "),
+      progressFromTasks: vorlage.progressFromTasks,
+    }));
+  }
+
+  async function removeTemplate(vorlage: ProjectTemplateEntry) {
+    if (!window.confirm(`Vorlage „${vorlage.name}“ loeschen?`)) return;
+    await fetch(`/api/templates/${vorlage.id}`, { method: "DELETE" }).catch(() => undefined);
+    setTemplates((current) => current.filter((entry) => entry.id !== vorlage.id));
+    update("templateId", "");
+  }
+
   const [repoPickerOpen, setRepoPickerOpen] = useState(false);
   const [repos, setRepos] = useState<RepoListEntry[]>([]);
   const [reposLoading, setReposLoading] = useState(false);
   const [repoFilter, setRepoFilter] = useState("");
   const [repoError, setRepoError] = useState<string | null>(null);
 
-  const isEdit = Boolean(project);
-
   useEffect(() => {
     if (!open) return;
     setError(null);
@@ -96,6 +184,7 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
             repoName: project.repositories[0]?.repoName ?? "",
             autoSync: project.repositories[0]?.autoSync ?? true,
             progressFromTasks: project.progressFromTasks,
+            templateId: "",
           }
         : EMPTY,
     );
@@ -165,6 +254,8 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
       repoName: form.repoName,
       autoSync: form.autoSync,
       progressFromTasks: form.progressFromTasks,
+      // Nur beim Anlegen; beim Bearbeiten kennt das Schema das Feld nicht.
+      ...(isEdit ? {} : { templateId: form.templateId || null }),
     };
 
     try {
@@ -203,6 +294,52 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
       }
     >
       <form onSubmit={submit} className="space-y-5">
+        {/* Nur beim Anlegen. Ein bestehendes Projekt nachtraeglich aus einer
+            Vorlage zu befuellen wuerde Notizen und Aufgaben verdoppeln. */}
+        {!isEdit && templates.length > 0 ? (
+          <div className="glass-soft p-4">
+            <label className="field-label" htmlFor="project-template">
+              Aus Vorlage
+            </label>
+            <div className="flex flex-wrap items-center gap-2">
+              <select
+                id="project-template"
+                className="field w-auto min-w-[14rem] flex-1"
+                value={form.templateId}
+                onChange={(event) => applyTemplate(event.target.value)}
+              >
+                <option value="">– ohne Vorlage –</option>
+                {templates.map((template) => (
+                  <option key={template.id} value={template.id}>
+                    {template.name}
+                  </option>
+                ))}
+              </select>
+              {gewaehlteVorlage ? (
+                <button
+                  type="button"
+                  className="btn btn-ghost px-2.5 py-1.5 text-xs text-rose-200"
+                  onClick={() => removeTemplate(gewaehlteVorlage)}
+                  title="Diese Vorlage loeschen"
+                >
+                  <Trash2 className="h-3.5 w-3.5" />
+                </button>
+              ) : null}
+            </div>
+            {gewaehlteVorlage ? (
+              <p className="mt-1.5 text-xs text-slate-500">
+                {gewaehlteVorlage.description ? `${gewaehlteVorlage.description} · ` : ""}
+                {beschreibeVorlage(gewaehlteVorlage)}
+              </p>
+            ) : (
+              <p className="mt-1.5 text-xs text-slate-500">
+                Vorlagen entstehen aus einem bestehenden Projekt – im Projektkopf unter
+                „Als Vorlage sichern“.
+              </p>
+            )}
+          </div>
+        ) : null}
+
         <div className="grid gap-4 sm:grid-cols-2">
           <div className="sm:col-span-2">
             <label className="field-label" htmlFor="project-name">

src/components/ProjectHeader.tsx

@@ -5,6 +5,7 @@ import { useRouter } from "next/navigation";
 import Link from "next/link";
 import {
   ArrowLeft,
+  BookmarkPlus,
   CalendarDays,
   CheckSquare,
   Download,
@@ -17,6 +18,7 @@ import {
   Trash2,
 } from "lucide-react";
 import { ProjectDialog } from "@/components/ProjectDialog";
+import { SaveTemplateDialog } from "@/components/SaveTemplateDialog";
 import { StatusSelect } from "@/components/StatusSelect";
 import { Popover } from "@/components/ui/Popover";
 import { repoTitle } from "@/lib/git/meta";
@@ -36,6 +38,7 @@ export function ProjectHeader({
   const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
 
   const [editOpen, setEditOpen] = useState(false);
+  const [templateOpen, setTemplateOpen] = useState(false);
   const [exportOpen, setExportOpen] = useState(false);
   const exportButtonRef = useRef<HTMLButtonElement>(null);
   const [favorite, setFavorite] = useState(project.favorite);
@@ -71,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,
@@ -165,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"
@@ -176,9 +183,19 @@ export function ProjectHeader({
               aria-haspopup="menu"
               aria-expanded={exportOpen}
               title="Exportieren"
+              aria-label="Exportieren"
             >
               <Download className="h-3.5 w-3.5" />
             </button>
+            <button
+              type="button"
+              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>
             <button
               type="button"
               className="btn btn-ghost px-3 py-1.5 text-xs"
@@ -284,6 +301,16 @@ export function ProjectHeader({
         connections={connections}
         project={project}
       />
+
+      <SaveTemplateDialog
+        open={templateOpen}
+        onClose={() => setTemplateOpen(false)}
+        projectId={project.id}
+        projectName={project.name}
+        noteCount={project.notes.length}
+        // Erledigte kommen nicht mit – hier steht, was wirklich uebernommen wird.
+        taskCount={project.tasks.filter((task) => task.status !== "DONE").length}
+      />
     </header>
   );
 }

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/ReadmePanel.tsx

@@ -0,0 +1,86 @@
+"use client";
+
+import { useState } from "react";
+import { BookOpen, ChevronDown, ExternalLink } from "lucide-react";
+import { Markdown } from "@/components/Markdown";
+import { cn } from "@/lib/utils";
+
+/**
+ * Das README des verknuepften Repositories.
+ *
+ * Erspart den Wechsel ins Git, nur um zu sehen, worum ein halbvergessenes
+ * Projekt eigentlich ging. Nicht zum Lesen ganzer Handbuecher gedacht:
+ * eingeklappt zeigt es die ersten Zeilen, ausgeklappt alles.
+ */
+export function ReadmePanel({
+  content,
+  path,
+  baseUrl,
+  fileUrl,
+}: {
+  content: string;
+  path: string | null;
+  baseUrl: string | null;
+  /** Direktlink auf die Datei im Git-System. */
+  fileUrl: string | null;
+}) {
+  const [offen, setOffen] = useState(false);
+
+  // Kurze READMEs vollstaendig zu zeigen ist einfacher, als sie mit einem
+  // Knopf zu versehen, der nichts freigibt.
+  const kurz = content.length < 900;
+
+  return (
+    <section className="glass p-5">
+      <div className="mb-3 flex flex-wrap items-center justify-between gap-2">
+        <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-300">
+          <BookOpen className="h-4 w-4 text-cyan-300" />
+          {path ?? "README"}
+        </h2>
+        {fileUrl ? (
+          <a
+            href={fileUrl}
+            target="_blank"
+            rel="noreferrer noopener"
+            className="inline-flex items-center gap-1.5 text-xs text-slate-500 transition-colors hover:text-violet-300"
+          >
+            Im Git öffnen
+            <ExternalLink className="h-3 w-3" />
+          </a>
+        ) : null}
+      </div>
+
+      <div className="relative">
+        <div
+          className={cn(
+            "overflow-hidden transition-[max-height] duration-300",
+            !kurz && !offen && "max-h-72",
+          )}
+        >
+          <Markdown baseUrl={baseUrl}>{content}</Markdown>
+        </div>
+
+        {/* Verlauf ueber den abgeschnittenen Rand, damit erkennbar ist, dass
+            es weitergeht. Nur wenn wirklich etwas verdeckt wird. */}
+        {!kurz && !offen ? (
+          <div
+            aria-hidden
+            className="pointer-events-none absolute inset-x-0 bottom-0 h-16 bg-gradient-to-t from-[#0b0d1c] to-transparent"
+          />
+        ) : null}
+      </div>
+
+      {!kurz ? (
+        <button
+          type="button"
+          onClick={() => setOffen((wert) => !wert)}
+          className="btn btn-ghost mt-2 w-full text-xs"
+          aria-expanded={offen}
+        >
+          <ChevronDown className={cn("h-3.5 w-3.5 transition-transform", offen && "rotate-180")} />
+          {offen ? "Weniger" : "Ganzes README anzeigen"}
+        </button>
+      ) : null}
+    </section>
+  );
+}

src/components/SaveTemplateDialog.tsx

@@ -0,0 +1,174 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { BookmarkPlus, Check, Loader2 } from "lucide-react";
+import { Modal } from "@/components/ui/Modal";
+
+/**
+ * Aus dem offenen Projekt eine Vorlage machen.
+ *
+ * Bewusst hier und nicht in einer eigenen Verwaltungsseite: Vorlagen
+ * entstehen aus einem Projekt, das sich bewaehrt hat. Sie von Grund auf zu
+ * tippen kann man ueber die API, taeglich braucht das niemand.
+ */
+export function SaveTemplateDialog({
+  open,
+  onClose,
+  projectId,
+  projectName,
+  noteCount,
+  taskCount,
+}: {
+  open: boolean;
+  onClose: () => void;
+  projectId: string;
+  projectName: string;
+  noteCount: number;
+  taskCount: number;
+}) {
+  const [name, setName] = useState("");
+  const [description, setDescription] = useState("");
+  const [withNotes, setWithNotes] = useState(true);
+  const [withTasks, setWithTasks] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [done, setDone] = useState(false);
+
+  useEffect(() => {
+    if (!open) return;
+    setName(projectName);
+    setDescription("");
+    setWithNotes(true);
+    setWithTasks(true);
+    setError(null);
+    setDone(false);
+  }, [open, projectName]);
+
+  async function submit(event: React.FormEvent) {
+    event.preventDefault();
+    setSaving(true);
+    setError(null);
+    try {
+      const response = await fetch("/api/templates/from-project", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId, name, description, withNotes, withTasks }),
+      });
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(payload.error ?? "Speichern fehlgeschlagen.");
+      setDone(true);
+      // Kurz stehen lassen, damit die Bestaetigung ankommt.
+      setTimeout(onClose, 900);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      width="md"
+      title="Als Vorlage sichern"
+      description="Neue Projekte starten damit mit denselben Tags, Notizen und Aufgaben."
+    >
+      <form onSubmit={submit} className="space-y-4">
+        <div>
+          <label className="field-label" htmlFor="template-name">
+            Name der Vorlage *
+          </label>
+          <input
+            id="template-name"
+            className="field"
+            value={name}
+            onChange={(event) => setName(event.target.value)}
+            maxLength={80}
+            required
+            autoFocus
+          />
+        </div>
+
+        <div>
+          <label className="field-label" htmlFor="template-description">
+            Wofür ist sie gut? (optional)
+          </label>
+          <input
+            id="template-description"
+            className="field"
+            value={description}
+            onChange={(event) => setDescription(event.target.value)}
+            placeholder="z. B. Kleine Web-App mit Docker und CI"
+            maxLength={280}
+          />
+        </div>
+
+        <div className="space-y-2">
+          <label className="flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
+            <input
+              type="checkbox"
+              checked={withNotes}
+              onChange={(event) => setWithNotes(event.target.checked)}
+              disabled={noteCount === 0}
+              className="mt-0.5 h-4 w-4 accent-violet-500"
+            />
+            <span>
+              Notizen übernehmen
+              <span className="mt-0.5 block text-[11px] text-slate-600">
+                {noteCount === 0
+                  ? "Dieses Projekt hat keine Notizen."
+                  : `${noteCount} ${noteCount === 1 ? "Notiz" : "Notizen"}`}
+              </span>
+            </span>
+          </label>
+
+          <label className="flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
+            <input
+              type="checkbox"
+              checked={withTasks}
+              onChange={(event) => setWithTasks(event.target.checked)}
+              disabled={taskCount === 0}
+              className="mt-0.5 h-4 w-4 accent-violet-500"
+            />
+            <span>
+              Aufgaben übernehmen
+              <span className="mt-0.5 block text-[11px] text-slate-600">
+                {taskCount === 0
+                  ? "Dieses Projekt hat keine offenen Aufgaben."
+                  : `${taskCount} offene ${taskCount === 1 ? "Aufgabe" : "Aufgaben"} — erledigte kommen nicht mit`}
+              </span>
+            </span>
+          </label>
+        </div>
+
+        <p className="rounded-lg border border-white/8 bg-black/25 px-3 py-2 text-xs text-slate-500">
+          Repositories gehen <strong>nicht</strong> mit. Eine Vorlage, die jedes neue Projekt
+          an dasselbe Repository hängt, wäre eine Falle.
+        </p>
+
+        {error ? (
+          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
+            {error}
+          </p>
+        ) : null}
+
+        <div className="flex justify-end gap-3 pt-1">
+          <button type="button" className="btn btn-ghost" onClick={onClose}>
+            Abbrechen
+          </button>
+          <button type="submit" className="btn btn-primary" disabled={saving || done}>
+            {saving ? (
+              <Loader2 className="h-4 w-4 animate-spin" />
+            ) : done ? (
+              <Check className="h-4 w-4" />
+            ) : (
+              <BookmarkPlus className="h-4 w-4" />
+            )}
+            {done ? "Gesichert" : "Sichern"}
+          </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>
+          <p className="mt-1.5 text-2xl font-semibold tabular-nums text-white sm:mt-2 sm:text-3xl">
-          {hint ? <p className="mt-1 truncate text-xs text-slate-500">{hint}</p> : null}
+            {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/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">
+      <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 items-center gap-3">
+        <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="flex min-w-0 flex-col leading-none">
-            <span className="text-gradient text-lg font-semibold tracking-tight">
+            <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/tasks/TaskCard.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { AlignLeft, CalendarClock, GripVertical } from "lucide-react";
+import { AlignLeft, CalendarClock, GripVertical, Repeat } from "lucide-react";
 import type { Task } from "@prisma/client";
+import { RECURRENCE_META } from "@/lib/tasks";
 import { cn, formatDate } from "@/lib/utils";
 
 /** Faelligkeit einordnen: ueberfaellig, heute, demnaechst. */
@@ -69,12 +70,22 @@ export function TaskCard({
             {task.title}
           </p>
 
-          {(task.description || task.dueDate || task.labels.length > 0) && (
+          {(task.description || task.dueDate || task.recurrence || task.labels.length > 0) && (
             <div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-[10px]">
               {task.description ? (
                 <AlignLeft className="h-2.5 w-2.5 text-slate-600" aria-label="hat Beschreibung" />
               ) : null}
 
+              {task.recurrence ? (
+                <span
+                  className="inline-flex items-center gap-1 text-slate-500"
+                  title={`Wiederholt sich: ${RECURRENCE_META[task.recurrence].label}`}
+                >
+                  <Repeat className="h-2.5 w-2.5" />
+                  {RECURRENCE_META[task.recurrence].short}
+                </span>
+              ) : null}
+
               {task.dueDate ? (
                 <span className={cn("inline-flex items-center gap-1", due?.className)}>
                   <CalendarClock className="h-2.5 w-2.5" />

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 { ExternalLink, GitPullRequestArrow, Loader2, Trash2 } from "lucide-react";
-import type { Task, TaskStatus } from "@prisma/client";
+import type { Recurrence, TaskStatus } from "@prisma/client";
 import { Modal } from "@/components/ui/Modal";
-import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
+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;
 }) {
@@ -36,11 +57,40 @@ export function TaskDialog({
   const [status, setStatus] = useState<TaskStatus>(initialStatus);
   const [dueDate, setDueDate] = useState("");
   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 ?? "");
@@ -48,6 +98,7 @@ export function TaskDialog({
     setStatus(task?.status ?? initialStatus);
     setDueDate(toDateInput(task?.dueDate ?? null));
     setLabels(task?.labels.join(", ") ?? "");
+    setRecurrence(task?.recurrence ?? "");
     setError(null);
   }, [open, task, initialStatus]);
 
@@ -64,6 +115,7 @@ export function TaskDialog({
       // Datum nicht auf den Vortag ziehen.
       dueDate: dueDate ? `${dueDate}T12:00:00` : null,
       labels: parseTags(labels),
+      recurrence: recurrence || null,
     };
 
     try {
@@ -194,6 +246,32 @@ export function TaskDialog({
               placeholder="bug, ui"
             />
           </div>
+
+          <div className="sm:col-span-2">
+            <label className="field-label" htmlFor="task-recurrence">
+              Wiederholung
+            </label>
+            <select
+              id="task-recurrence"
+              className="field"
+              value={recurrence}
+              onChange={(event) => setRecurrence(event.target.value)}
+            >
+              <option value="">– einmalig –</option>
+              {(Object.keys(RECURRENCE_META) as Recurrence[]).map((key) => (
+                <option key={key} value={key}>
+                  {RECURRENCE_META[key].label}
+                </option>
+              ))}
+            </select>
+            {recurrence ? (
+              <p className="mt-1 text-xs text-slate-500">
+                Sobald die Aufgabe nach „Erledigt“ wandert, entsteht die nächste. Gerechnet
+                wird vom Fälligkeitsdatum, nicht vom Abhaken — eine wöchentliche Aufgabe
+                bleibt also auf ihrem Wochentag.
+              </p>
+            ) : null}
+          </div>
         </div>
 
         {error ? (
@@ -202,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,395 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import {
+  CalendarClock,
+  CheckSquare,
+  ExternalLink,
+  Loader2,
+  Plus,
+  Repeat,
+  Square,
+} 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 [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(() => {
+    return tasks.filter((task) => {
+      // Erledigtes fuellt die Liste sonst mit dem, was gerade nicht ansteht.
+      if (!zeigeErledigte && 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;
+      return true;
+    });
+  }, [tasks, statusFilter, projektFilter, zeigeErledigte]);
+
+  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="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" : "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“."
+                : "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;
+    if (left + effektiv > window.innerWidth - margin) left = rect.right - effektiv;
-    left = Math.min(Math.max(margin, left), window.innerWidth - width - margin);
+    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

@@ -75,6 +75,8 @@ export interface PendingLoginState {
     isActive: boolean;
     /** Entschluesselter TOTP-Schluessel; null, wenn er nicht lesbar ist. */
     totpSecret: string | null;
+    /** Zuletzt eingeloestes Zeitfenster – gegen die Wiederverwendung. */
+    totpLastCounter: number | null;
   };
 }
 
@@ -104,6 +106,7 @@ export async function readPendingLogin(): Promise<PendingLoginState | null> {
       role: pending.user.role,
       isActive: pending.user.isActive,
       totpSecret: tryDecryptSecret(pending.user.totpSecretCipher),
+      totpLastCounter: pending.user.totpLastCounter,
     },
   };
 }

src/lib/auth/totp.test.ts

@@ -6,6 +6,7 @@ import {
   counterFor,
   generateTotpSecret,
   groupSecret,
+  matchTotp,
   otpauthUri,
   totpCode,
   verifyTotp,
@@ -124,3 +125,33 @@ describe("Einrichtung", () => {
     expect(groupSecret("ABCDEFGH")).toBe("ABCD EFGH");
   });
 });
+
+describe("matchTotp", () => {
+  const SECRET = base32Encode(Buffer.from("12345678901234567890", "utf8"));
+  const JETZT = new Date(1111111109_000);
+
+  /**
+   * Der Zaehler ist noetig, um einen verbrauchten Code zu entwerten. RFC 6238
+   * verlangt das in Abschnitt 5.2 ausdruecklich – sonst laesst sich ein
+   * abgefangener Code die restliche Gueltigkeitsdauer ueber wiederverwenden.
+   */
+  it("gibt das Zeitfenster zurueck, das gepasst hat", () => {
+    expect(matchTotp(SECRET, "081804", JETZT)).toBe(37037036);
+  });
+
+  it("nennt bei den Nachbarfenstern deren eigene Nummer", () => {
+    // Genau daran haengt die Entwertung: der Code aus dem vorigen Fenster
+    // darf den Merker nicht auf einen hoeheren Stand setzen.
+    const naechstes = new Date(JETZT.getTime() + TOTP_PERIOD * 1000);
+    expect(matchTotp(SECRET, "081804", naechstes)).toBe(37037036);
+  });
+
+  it("liefert null bei falschem Code", () => {
+    expect(matchTotp(SECRET, "000000", JETZT)).toBeNull();
+  });
+
+  it("stimmt mit verifyTotp ueberein", () => {
+    expect(matchTotp(SECRET, "081804", JETZT) !== null).toBe(verifyTotp(SECRET, "081804", JETZT));
+    expect(matchTotp(SECRET, "000000", JETZT) !== null).toBe(verifyTotp(SECRET, "000000", JETZT));
+  });
+});

src/lib/auth/totp.ts

@@ -102,26 +102,44 @@ export function counterFor(at: Date = new Date()): number {
 }
 
 /**
- * Prueft einen eingegebenen Code. Vergleicht in konstanter Zeit und probiert
+ * Prueft einen eingegebenen Code und gibt das Zeitfenster zurueck, das
- * die Nachbarfenster mit, damit eine leicht abweichende Uhr nicht stoert.
+ * gepasst hat – oder null.
+ *
+ * Das Fenster wird gebraucht, um einen verbrauchten Code zu entwerten:
+ * RFC 6238 verlangt in Abschnitt 5.2 ausdruecklich, dass derselbe Code kein
+ * zweites Mal angenommen wird. Ohne diese Zahl liesse sich ein abgefangener
+ * Code die restliche Gueltigkeitsdauer ueber wiederverwenden.
+ *
+ * Verglichen wird in konstanter Zeit, und die Nachbarfenster werden
+ * mitprobiert, damit eine leicht abweichende Uhr nicht stoert.
  */
+export function matchTotp(
+  secret: string,
+  code: string,
+  at: Date = new Date(),
+  window: number = TOTP_WINDOW,
+): number | null {
+  const eingabe = code.replace(/\s/g, "");
+  if (!/^\d+$/.test(eingabe) || eingabe.length !== TOTP_DIGITS) return null;
+
+  const jetzt = counterFor(at);
+  let treffer: number | null = null;
+  for (let schritt = -window; schritt <= window; schritt += 1) {
+    // Nicht fruehzeitig abbrechen: sonst haengt die Laufzeit davon ab,
+    // welches Fenster gepasst hat.
+    if (constantEquals(totpCode(secret, jetzt + schritt), eingabe)) treffer = jetzt + schritt;
+  }
+  return treffer;
+}
+
+/** Wie matchTotp, wenn nur interessiert *ob* der Code stimmt. */
 export function verifyTotp(
   secret: string,
   code: string,
   at: Date = new Date(),
   window: number = TOTP_WINDOW,
 ): boolean {
-  const eingabe = code.replace(/\s/g, "");
+  return matchTotp(secret, code, at, window) !== null;
-  if (!/^\d+$/.test(eingabe) || eingabe.length !== TOTP_DIGITS) return false;
-
-  const jetzt = counterFor(at);
-  let treffer = false;
-  for (let schritt = -window; schritt <= window; schritt += 1) {
-    // Nicht fruehzeitig abbrechen: sonst haengt die Laufzeit davon ab,
-    // welches Fenster gepasst hat.
-    if (constantEquals(totpCode(secret, jetzt + schritt), eingabe)) treffer = true;
-  }
-  return treffer;
 }
 
 function constantEquals(a: string, b: string): boolean {

src/lib/changelog.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { CHANGELOG, KIND_META } from "./changelog";
+import { APP_VERSION } from "./config";
+
+/**
+ * Der Verlauf und die Versionsnummer sind zwei Angaben, die zusammenpassen
+ * muessen. Genau daran ist dieses Projekt schon einmal gescheitert: die
+ * Version stand in der Fusszeile und in der package.json und zeigte
+ * verschiedene Werte.
+ */
+
+describe("Aenderungsverlauf", () => {
+  it("beginnt mit der Fassung, die auch installiert ist", () => {
+    expect(CHANGELOG[0].version).toBe(APP_VERSION);
+  });
+
+  it("nennt jede Fassung nur einmal", () => {
+    const versionen = CHANGELOG.map((release) => release.version);
+    expect(new Set(versionen).size).toBe(versionen.length);
+  });
+
+  it("zaehlt absteigend", () => {
+    const zahl = (version: string) =>
+      version.split(".").reduce((sum, teil) => sum * 1000 + Number(teil), 0);
+
+    for (let index = 1; index < CHANGELOG.length; index += 1) {
+      expect(
+        zahl(CHANGELOG[index - 1].version),
+        `${CHANGELOG[index - 1].version} muss ueber ${CHANGELOG[index].version} stehen`,
+      ).toBeGreaterThan(zahl(CHANGELOG[index].version));
+    }
+  });
+
+  it("hat zu jeder Fassung ein Datum, eine Zeile und mindestens eine Aenderung", () => {
+    for (const release of CHANGELOG) {
+      expect(release.version, "Version im Format x.y.z").toMatch(/^\d+\.\d+\.\d+$/);
+      expect(Number.isNaN(Date.parse(release.date)), `Datum von ${release.version}`).toBe(false);
+      expect(release.headline.length, `Zeile zu ${release.version}`).toBeGreaterThan(0);
+      expect(release.changes.length, `Eintraege zu ${release.version}`).toBeGreaterThan(0);
+    }
+  });
+
+  it("kennt zu jeder Art eine Beschriftung", () => {
+    for (const release of CHANGELOG) {
+      for (const change of release.changes) {
+        expect(KIND_META[change.kind], `${change.kind} in v${release.version}`).toBeDefined();
+        expect(change.text.trim().length).toBeGreaterThan(0);
+      }
+    }
+  });
+});

src/lib/changelog.ts

@@ -0,0 +1,533 @@
+/**
+ * Was sich von Fassung zu Fassung geaendert hat.
+ *
+ * Bewusst hier und nicht als CHANGELOG.md: die Liste wird in der Anwendung
+ * angezeigt, und zwei Quellen liefen prompt auseinander – wie es der
+ * Versionsnummer schon einmal passiert ist, die eine Zeit lang in der
+ * Fusszeile und in der package.json stand und verschiedene Werte zeigte.
+ *
+ * Die oberste Fassung ist die aktuelle. Neue Eintraege kommen nach vorne.
+ */
+
+export type ChangeKind = "neu" | "besser" | "behoben";
+
+export interface ChangeEntry {
+  kind: ChangeKind;
+  text: string;
+}
+
+export interface Release {
+  version: string;
+  /** ISO-Datum, ohne Uhrzeit. */
+  date: string;
+  /** Ein Satz darueber, worum es in dieser Fassung ging. */
+  headline: string;
+  changes: ChangeEntry[];
+}
+
+export const KIND_META: Record<ChangeKind, { label: string; className: string }> = {
+  neu: {
+    label: "Neu",
+    className: "bg-violet-500/12 text-violet-200 ring-violet-400/30",
+  },
+  besser: {
+    label: "Besser",
+    className: "bg-cyan-500/12 text-cyan-200 ring-cyan-400/30",
+  },
+  behoben: {
+    label: "Behoben",
+    className: "bg-emerald-500/12 text-emerald-200 ring-emerald-400/30",
+  },
+};
+
+export const CHANGELOG: Release[] = [
+  {
+    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",
+    headline: "Sicherheitsdurchsicht und eine Anleitung für den Server.",
+    changes: [
+      {
+        kind: "behoben",
+        text:
+          "Ein Einmalkennwort ließ sich innerhalb seiner Gültigkeit mehrfach verwenden. " +
+          "Das eingelöste Zeitfenster wird jetzt gemerkt — RFC 6238 verlangt das " +
+          "ausdrücklich.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Der Bildoptimierer von Next war ohne Anmeldung erreichbar und reichte Bilder " +
+          "durch libvips, für das es offene Schwachstellen gibt. Nebula benutzt ihn " +
+          "nirgends — jetzt ist er abgeschaltet.",
+      },
+      {
+        kind: "neu",
+        text:
+          "DEPLOYMENT.md: Schritt für Schritt vom leeren Server bis zur Instanz hinter " +
+          "TLS, mit Firewall, Sicherungen und Betrieb.",
+      },
+      {
+        kind: "neu",
+        text:
+          "scripts/update.sh rollt ein Update aus: prüfen, holen, sichern, bauen, " +
+          "starten, Gesundheit prüfen — und nennt bei einem Fehlschlag den Weg zurück.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Umsortieren im Brett und das Anlegen von Vorlagen sind jetzt ebenfalls " +
+          "ratenbegrenzt.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Bereinigung des Markdowns ist mit elf Tests festgehalten: Skripte, " +
+          "Ereignis-Attribute, javascript: und data: kommen nicht durch.",
+      },
+    ],
+  },
+  {
+    version: "1.4.0",
+    date: "2026-07-26",
+    headline: "Worum ging es hier nochmal?",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "README-Vorschau auf der Projektseite. Erspart den Wechsel ins Git, nur um zu " +
+          "sehen, worum ein halbvergessenes Projekt eigentlich ging.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Relative Links im README zeigen dorthin, wo sie hingehören — aufgelöst gegen " +
+          "das Verzeichnis der Datei im Repository.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Bilder im README werden bewusst nicht geladen, sondern als anklickbarer " +
+          "Verweis gezeigt. Die Content-Security-Policy dafür zu öffnen hieße, jedem " +
+          "fremden README das Nachladen beliebiger Bilder zu erlauben — auch Zählpixeln.",
+      },
+    ],
+  },
+  {
+    version: "1.3.0",
+    date: "2026-07-26",
+    headline: "Was sich wiederholt, und was besser lesbar ist.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Wiederkehrende Aufgaben: täglich, wöchentlich, alle zwei Wochen oder monatlich. " +
+          "Wandert die Aufgabe nach „Erledigt“, entsteht die nächste von selbst.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Gedämpfter Text erreichte auf dem dunklen Untergrund nur 3,8 statt der " +
+          "geforderten 4,5 zu 1 — an 26 Stellen. Beide Stufen sind jetzt aufgehellt, " +
+          "der Abstand zwischen ihnen bleibt sichtbar.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Barrierefreiheit ist mit axe-core über zehn Seitenzustände geprüft, " +
+          "einschließlich der Dialoge. Keine Verstöße mehr gegen WCAG 2.1 AA.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Der Folgetermin rechnet vom Fälligkeitsdatum, nicht vom Abhaken — eine " +
+          "wöchentliche Aufgabe bleibt auf ihrem Wochentag. Lange Liegengebliebenes " +
+          "rutscht so weit vor, bis der Termin in der Zukunft liegt.",
+      },
+    ],
+  },
+  {
+    version: "1.2.0",
+    date: "2026-07-26",
+    headline: "Ein Jahr auf einen Blick, und ein Start ohne Leerlauf.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Commit-Heatmap auf der Projektseite: ein Feld je Tag über bis zu ein Jahr, " +
+          "mit Farbskala und Datum im Tooltip.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Projektvorlagen. Ein bewährtes Projekt über „Als Vorlage sichern“ festhalten — " +
+          "Tags, Notizen und offene Aufgaben stehen dann beim nächsten Projekt bereit.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Heatmap-Daten kommen höchstens einmal am Tag und getrennt vom übrigen " +
+          "Abgleich. Bei GitHub genügt ein Aufruf der Jahresstatistik, bei GitLab und " +
+          "Gitea werden bis zu fünf Seiten Commits geholt.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Reicht die Historie nicht ein Jahr zurück, beginnt die Heatmap beim ältesten " +
+          "bekannten Commit — leere Felder für unbekannte Zeiträume wären eine Lüge.",
+      },
+    ],
+  },
+  {
+    version: "1.1.0",
+    date: "2026-07-26",
+    headline: "Das Brett wird zur Arbeitsfläche.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Freie Reihenfolge im Brett: Karten lassen sich innerhalb einer Spalte anordnen, " +
+          "die Position bleibt erhalten.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Mehrfachauswahl. Über die Kästchen mehrere Projekte wählen und Status, Tags oder " +
+          "Favoriten in einem Zug ändern — oder alle auf einmal löschen.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Als App installierbar: Nebula bringt ein Web-Manifest und eigene Symbole mit und " +
+          "lässt sich auf dem Handy zum Startbildschirm hinzufügen.",
+      },
+      {
+        kind: "neu",
+        text: "Dieser Änderungsverlauf, erreichbar über die Versionsnummer in der Fußzeile.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Ansicht, Sortierung und der Archivschalter überdauern das Neuladen. Wer sein " +
+          "Brett von Hand anordnet, will es beim nächsten Aufruf auch sehen.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Neu angelegte, importierte und verschobene Projekte bekamen keine Position und " +
+          "stapelten sich im Brett alle auf demselben Platz.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Umsortieren im Brett fasst das Änderungsdatum nicht mehr an. Vorher schob ein " +
+          "Aufräumen sämtliche Projekte in der Sortierung „Zuletzt geändert“ nach oben.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Sortierung im Kopf ist im Brett abgeschaltet — dort zählt die Anordnung von Hand. " +
+          "Sie stehen zu lassen, ohne dass sie wirkt, wäre irreführend.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Prisma liest seine Einstellungen aus prisma.config.ts statt aus der package.json. " +
+          "Damit ist die Warnung vor Prisma 7 weg.",
+      },
+    ],
+  },
+  {
+    version: "1.0.0",
+    date: "2026-07-26",
+    headline: "Der Funktionsumfang ist beisammen.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Aktivitätsverlauf je Projekt: Statuswechsel, Notizen, Aufgaben und neue Commits " +
+          "in einer Zeitleiste.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Zwei-Faktor-Anmeldung per TOTP, mit QR-Code zum Einrichten und zehn " +
+          "Wiederherstellungscodes für den Fall, dass das Gerät verloren geht.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Mehrere Repositories je Projekt — Frontend und Backend gehören in eine Karte. " +
+          "Jedes mit eigenen Kennzahlen, eigener CI und eigenem Abgleich.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Benachrichtigungen merken sich den gemeldeten Zustand je Repository. Vorher " +
+          "verdeckte ein rotes Frontend die rote Pipeline des Backends.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Stillstand bemisst sich am jüngsten Commit über alle Repositories: an einem " +
+          "Vorhaben wird gearbeitet, sobald an einem seiner Teile gearbeitet wird.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Der Verlauf lieferte ohne ausdrückliche Angabe genau einen Eintrag statt dreißig " +
+          "— Number(null) ist 0, nicht „nicht angegeben“.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Die Issue-Übernahme antwortete mit „nicht gefunden“, obwohl gar kein bestimmtes " +
+          "Repository angefragt war.",
+      },
+    ],
+  },
+  {
+    version: "0.9.0",
+    date: "2026-07-26",
+    headline: "Schneller ans Ziel.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Schnellsuche mit Strg+K: Projekte, Notizen und Bereiche, bedienbar allein mit " +
+          "der Tastatur.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Offene Git-Issues als Aufgaben übernehmen, mit Titel, Labels und Link zurück. " +
+          "Bereits übernommene werden übersprungen.",
+      },
+    ],
+  },
+  {
+    version: "0.8.0",
+    date: "2026-07-26",
+    headline: "Der sanfte Stups.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Stillstehende Projekte melden sich, wenn länger kein Commit kam. Die Schwelle " +
+          "steht im Adminbereich.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Der neue Anlass fehlte im Prüfschema — die Oberfläche bot ihn an, der Server " +
+          "lehnte ihn ab. Ein Test hält beide Listen seitdem zusammen.",
+      },
+    ],
+  },
+  {
+    version: "0.7.0",
+    date: "2026-07-26",
+    headline: "Bescheid bekommen, ohne nachzusehen.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Benachrichtigungen über ntfy, Webhook (HMAC-signiert) und E-Mail — bei " +
+          "fehlgeschlagenem Abgleich, roter CI oder neuer Version.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Gemeldet wird nur bei einer Änderung. Sonst käme bei einem Repo mit abgelaufenem " +
+          "Token mit jedem Durchlauf dieselbe Nachricht.",
+      },
+      {
+        kind: "behoben",
+        text: "Im ntfy-Betreff wurden Emojis zu Fragezeichen, weil die Kopfzeile nur Latin-1 kann.",
+      },
+    ],
+  },
+  {
+    version: "0.6.0",
+    date: "2026-07-26",
+    headline: "Prüfen statt behaupten.",
+    changes: [
+      {
+        kind: "neu",
+        text: "Ende-zu-Ende-Tests mit Playwright gegen die gebaute Anwendung und eine eigene Datenbank.",
+      },
+      { kind: "neu", text: "CI-Pipeline für Gitea Actions." },
+    ],
+  },
+  {
+    version: "0.5.0",
+    date: "2026-07-26",
+    headline: "Aufgaben je Projekt.",
+    changes: [
+      {
+        kind: "neu",
+        text: "Aufgabenbrett mit sortierbaren Spalten, Fälligkeitsdatum und Labels.",
+      },
+      { kind: "neu", text: "Fortschritt wahlweise aus dem Verhältnis erledigter Aufgaben." },
+    ],
+  },
+  {
+    version: "0.4.0",
+    date: "2026-07-26",
+    headline: "Ziehen und ablegen.",
+    changes: [
+      { kind: "neu", text: "Kanban-Ansicht: Status per Ziehen ändern." },
+      { kind: "neu", text: "CI-Status je Branch und Commit-Aktivität als Verlaufslinie." },
+      {
+        kind: "behoben",
+        text:
+          "Die Verlaufslinie log: bei 100 Commits innerhalb weniger Tage zeigte sie für die " +
+          "übrigen Tage Nullen, obwohl schlicht keine Daten vorlagen.",
+      },
+    ],
+  },
+  {
+    version: "0.3.0",
+    date: "2026-07-26",
+    headline: "Text und Suche.",
+    changes: [
+      { kind: "neu", text: "Markdown in Beschreibung und Notizen." },
+      { kind: "neu", text: "Volltextsuche über Notizen, mit hervorgehobenen Fundstellen." },
+      { kind: "neu", text: "Listen offener Pull Requests und Issues." },
+      { kind: "behoben", text: "Die Versionsnummer stand an zwei Stellen und lief auseinander." },
+    ],
+  },
+  {
+    version: "0.2.0",
+    date: "2026-07-25",
+    headline: "Konten und Härtung.",
+    changes: [
+      { kind: "neu", text: "Benutzerverwaltung mit Passwort und Passkeys, Einzel- und Mehrbenutzerbetrieb." },
+      { kind: "neu", text: "Export, Import und vollständige Sicherung." },
+      { kind: "neu", text: "Automatischer Abgleich nach Zeitplan, einstellbar im Adminbereich." },
+      {
+        kind: "besser",
+        text:
+          "Härtung: CSRF-Prüfung, Content-Security-Policy mit Nonce, SSRF-Schutz mit " +
+          "Namensauflösung, Ratenbegrenzung und harte Datentrennung je Konto.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Menüs verschwanden hinter den Karten. Ursache war der Weichzeichner der " +
+          "Glasoptik, der einen eigenen Bezugsrahmen aufspannt; Menüs hängen seitdem am " +
+          "Seitenende statt in der Karte.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Eingabefelder überlappten ihre Symbole, weil eigene CSS-Klassen außerhalb der " +
+          "Kaskadenschichten gegen die Hilfsklassen gewannen.",
+      },
+    ],
+  },
+  {
+    version: "0.1.0",
+    date: "2026-07-25",
+    headline: "Der Anfang.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Projekte mit Status, Priorität, Fortschritt, Tags und Notizen — von der reinen " +
+          "Idee bis zum fertigen Repo.",
+      },
+      { kind: "neu", text: "Git-Anbindung an GitHub, GitLab und Gitea über Access Token." },
+      { kind: "neu", text: "Betrieb per Docker oder eigenständig, Daten in einer lokalen PostgreSQL." },
+    ],
+  },
+];

src/lib/git/calendar.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  CALENDAR_MAX_PAGES,
+  CALENDAR_PAGE_SIZE,
+  calendarByPaging,
+  calendarSince,
+  calendarTotal,
+  dayKey,
+} from "./calendar";
+
+/**
+ * Der Kalender darf ueber den Zeitraum nicht luegen. Reichen die geholten
+ * Seiten nur ein paar Monate zurueck, faengt die Heatmap dort an – sie zeigt
+ * dann keine leeren Felder fuer Zeiten, ueber die schlicht nichts bekannt ist.
+ * Genau diesen Fehler hatte die Verlaufslinie schon einmal.
+ */
+
+const JETZT = new Date("2026-07-26T12:00:00.000Z");
+const TAG = 86_400_000;
+
+/** Erzeugt n Commit-Zeitpunkte, beginnend vor `abTagen` Tagen, einer je Tag. */
+function commits(anzahl: number, abTagen: number): string[] {
+  return Array.from({ length: anzahl }, (_, index) =>
+    new Date(JETZT.getTime() - (abTagen + index) * TAG).toISOString(),
+  );
+}
+
+describe("dayKey", () => {
+  it("liefert das Datum ohne Uhrzeit", () => {
+    expect(dayKey(new Date("2026-07-26T23:59:00.000Z"))).toBe("2026-07-26");
+  });
+});
+
+describe("calendarSince", () => {
+  it("liegt ein Jahr zurueck", () => {
+    const seit = calendarSince(JETZT);
+    expect(Math.round((JETZT.getTime() - seit.getTime()) / TAG)).toBe(365);
+  });
+});
+
+describe("calendarByPaging", () => {
+  it("liefert null, wenn es keine Commits gibt", async () => {
+    expect(await calendarByPaging(async () => [], JETZT)).toBeNull();
+  });
+
+  it("zaehlt mehrere Commits desselben Tages zusammen", async () => {
+    const heute = JETZT.toISOString();
+    const kalender = await calendarByPaging(async () => [heute, heute, heute], JETZT);
+    expect(kalender?.days["2026-07-26"]).toBe(3);
+    expect(calendarTotal(kalender!)).toBe(3);
+  });
+
+  it("beginnt beim aeltesten bekannten Commit, nicht vor einem Jahr", async () => {
+    // Nur eine halbe Seite, zehn Tage zurueck: alles davor ist unbekannt.
+    const kalender = await calendarByPaging(async () => commits(10, 0), JETZT);
+    expect(kalender?.from).toBe("2026-07-17");
+    expect(kalender?.to).toBe("2026-07-26");
+    expect(kalender?.truncated).toBe(false);
+  });
+
+  it("hoert auf, sobald eine Seite nicht mehr voll ist", async () => {
+    const ladeSeite = vi.fn(async (seite: number) =>
+      seite === 1 ? commits(CALENDAR_PAGE_SIZE, 0) : commits(5, CALENDAR_PAGE_SIZE),
+    );
+    await calendarByPaging(ladeSeite, JETZT);
+    expect(ladeSeite).toHaveBeenCalledTimes(2);
+  });
+
+  it("deckelt die Zahl der Seiten und sagt es", async () => {
+    // Immer volle Seiten innerhalb des Zeitraums: ohne Deckel liefe das ewig.
+    const ladeSeite = vi.fn(async () =>
+      Array.from({ length: CALENDAR_PAGE_SIZE }, () =>
+        new Date(JETZT.getTime() - 3 * TAG).toISOString(),
+      ),
+    );
+    const kalender = await calendarByPaging(ladeSeite, JETZT);
+    expect(ladeSeite).toHaveBeenCalledTimes(CALENDAR_MAX_PAGES);
+    expect(kalender?.truncated).toBe(true);
+  });
+
+  it("bricht ab, wenn eine ganze Seite aelter ist als der Zeitraum", async () => {
+    const ladeSeite = vi.fn(async (seite: number) =>
+      seite === 1
+        ? commits(CALENDAR_PAGE_SIZE, 0)
+        : Array.from({ length: CALENDAR_PAGE_SIZE }, () =>
+            new Date(JETZT.getTime() - 400 * TAG).toISOString(),
+          ),
+    );
+    await calendarByPaging(ladeSeite, JETZT);
+    expect(ladeSeite).toHaveBeenCalledTimes(2);
+  });
+
+  it("uebergeht Commits mit Datum in der Zukunft", async () => {
+    // Falsch gestellte Uhren gibt es; sie duerfen den Zeitraum nicht verlaengern.
+    const kalender = await calendarByPaging(
+      async () => [
+        new Date(JETZT.getTime() + 5 * TAG).toISOString(),
+        JETZT.toISOString(),
+      ],
+      JETZT,
+    );
+    expect(kalender?.to).toBe("2026-07-26");
+    expect(calendarTotal(kalender!)).toBe(1);
+  });
+
+  it("uebergeht Unbrauchbares, statt daran zu scheitern", async () => {
+    const kalender = await calendarByPaging(
+      async () => [null, "gestern", "", JETZT.toISOString()],
+      JETZT,
+    );
+    expect(calendarTotal(kalender!)).toBe(1);
+  });
+
+  it("laesst Tage ohne Commits weg", async () => {
+    // Ein Jahr als Liste waeren 365 Eintraege, die meisten davon Nullen.
+    const kalender = await calendarByPaging(
+      async () => [JETZT.toISOString(), new Date(JETZT.getTime() - 30 * TAG).toISOString()],
+      JETZT,
+    );
+    expect(Object.keys(kalender!.days)).toHaveLength(2);
+  });
+});

src/lib/git/calendar.ts

@@ -0,0 +1,109 @@
+/**
+ * Commits je Tag ueber ein Jahr – die Grundlage der Heatmap.
+ *
+ * Getrennt vom uebrigen Abgleich, weil es zusaetzliche Aufrufe kostet: der
+ * Kalender wird hoechstens einmal am Tag geholt. Von Stunde zu Stunde
+ * aendert sich an einem Jahresueberblick ohnehin nichts Sichtbares.
+ *
+ * Wichtig ist die Ehrlichkeit ueber den Zeitraum. Wo es keine
+ * Jahresstatistik gibt, reichen die Daten nur so weit zurueck wie die
+ * abgerufenen Seiten – dann faengt die Heatmap dort an und tut nicht so, als
+ * waere ein Jahr lang nichts passiert. Diesen Fehler hatte die Verlaufslinie
+ * schon einmal.
+ */
+
+/** Wie weit die Heatmap hoechstens zurueckreicht. */
+export const CALENDAR_DAYS = 365;
+
+/**
+ * Hoechstzahl Seiten, wo seitenweise geholt werden muss. Fuenf Seiten sind
+ * 500 Commits – genug fuer die allermeisten Repositories und wenig genug,
+ * um kein fremdes Kontingent zu sprengen.
+ */
+export const CALENDAR_MAX_PAGES = 5;
+export const CALENDAR_PAGE_SIZE = 100;
+
+export interface CommitCalendar {
+  /** Erster Tag, fuer den wirklich Daten vorliegen (yyyy-mm-dd). */
+  from: string;
+  /** Letzter beruecksichtigter Tag (yyyy-mm-dd). */
+  to: string;
+  /** Nur Tage mit Commits: { "2026-07-26": 3 }. Die Nullen ergaenzt die Anzeige. */
+  days: Record<string, number>;
+  /**
+   * "stats" = Jahresstatistik des Anbieters, der Zeitraum ist vollstaendig.
+   * "commits" = so weit, wie die Seiten zurueckreichten.
+   */
+  source: "stats" | "commits";
+  /** Der Deckel hat gegriffen; aeltere Commits fehlen. */
+  truncated: boolean;
+}
+
+/** Tag im Format yyyy-mm-dd, in UTC – so liefern es die Anbieter. */
+export function dayKey(value: Date): string {
+  return value.toISOString().slice(0, 10);
+}
+
+/** Der Tag, ab dem der Kalender hoechstens reicht. */
+export function calendarSince(now: Date = new Date()): Date {
+  return new Date(now.getTime() - CALENDAR_DAYS * 86_400_000);
+}
+
+/**
+ * Holt seitenweise Commit-Zeitpunkte und zaehlt sie zu Tagen zusammen.
+ *
+ * Abgebrochen wird, sobald eine Seite nicht mehr voll ist (dann gibt es
+ * nichts weiter), sobald die Seite vollstaendig aus der Zeit vor dem
+ * Zeitraum stammt, oder wenn der Deckel greift.
+ */
+export async function calendarByPaging(
+  ladeSeite: (seite: number) => Promise<Array<string | null>>,
+  now: Date = new Date(),
+): Promise<CommitCalendar | null> {
+  const grenze = calendarSince(now).getTime();
+  const days: Record<string, number> = {};
+  let aeltester: number | null = null;
+  let gedeckelt = false;
+
+  for (let seite = 1; seite <= CALENDAR_MAX_PAGES; seite += 1) {
+    const daten = await ladeSeite(seite);
+    if (daten.length === 0) break;
+
+    let innerhalb = 0;
+    for (const value of daten) {
+      if (!value) continue;
+      const time = Date.parse(value);
+      if (Number.isNaN(time)) continue;
+      // Ein Commit-Datum in der Zukunft kommt vor – falsch gestellte Uhren.
+      if (time > now.getTime()) continue;
+      if (time < grenze) continue;
+
+      innerhalb += 1;
+      const key = dayKey(new Date(time));
+      days[key] = (days[key] ?? 0) + 1;
+      if (aeltester === null || time < aeltester) aeltester = time;
+    }
+
+    // Nicht mehr voll: das war die letzte Seite.
+    if (daten.length < CALENDAR_PAGE_SIZE) break;
+    // Die ganze Seite lag schon vor dem Zeitraum – weiter zurueck lohnt nicht.
+    if (innerhalb === 0) break;
+
+    if (seite === CALENDAR_MAX_PAGES) gedeckelt = true;
+  }
+
+  if (aeltester === null) return null;
+
+  return {
+    from: dayKey(new Date(aeltester)),
+    to: dayKey(now),
+    days,
+    source: "commits",
+    truncated: gedeckelt,
+  };
+}
+
+/** Wie viele Commits der Kalender insgesamt kennt. */
+export function calendarTotal(calendar: CommitCalendar): number {
+  return Object.values(calendar.days).reduce((sum, value) => sum + value, 0);
+}

src/lib/git/gitea.ts

@@ -1,10 +1,18 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
+import {
+  CALENDAR_PAGE_SIZE,
+  calendarByPaging,
+  calendarSince,
+  type CommitCalendar,
+} from "./calendar";
+import { capReadme, decodeBase64, pickReadme, type RepoReadme } from "./readme";
 import type {
   BranchInfo,
   CiInfo,
   CiState,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -37,6 +45,32 @@ 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 check(): Promise<ConnectionCheck> {
     try {
       const version = await getJsonSafe<{ version?: string }>(
@@ -219,6 +253,64 @@ export class GiteaClient implements GitClient {
       commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
     };
   }
+
+  /**
+   * Gitea kennt keine Jahresstatistik ueber die API, also seitenweise.
+   * `stat=false` und `verification=false` sparen dabei spuerbar Rechenzeit
+   * auf der Gegenseite – gebraucht wird nur das Datum.
+   */
+  async fetchCommitCalendar(ref: RepoRef): Promise<CommitCalendar | null> {
+    const base = `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+    const seit = calendarSince().toISOString();
+
+    // getJson und nicht getJsonSafe: ein Rate-Limit darf nicht als "keine
+    // Daten" durchgehen – siehe maybeRefreshCalendar.
+    return calendarByPaging(async (seite) => {
+      const commits = await getJson<GiteaCommit[]>(
+        `${base}/commits?limit=${CALENDAR_PAGE_SIZE}&page=${seite}` +
+          `&stat=false&verification=false&files=false&since=${encodeURIComponent(seit)}`,
+        { headers: this.headers() },
+      );
+      return commits.map((commit) => toIso(commit.commit?.author?.date));
+    });
+  }
+
+  /**
+   * Gitea kennt keinen README-Endpunkt. Erst das Wurzelverzeichnis
+   * auflisten, dann die gefundene Datei holen – zwei Aufrufe.
+   */
+  async fetchReadme(ref: RepoRef): Promise<RepoReadme | null> {
+    const base = `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+    const headers = this.headers();
+
+    const eintraege = await getJsonSafe<Array<{ name: string; type: string }>>(
+      `${base}/contents`,
+      [],
+      { headers },
+    );
+    const name = pickReadme(
+      eintraege.filter((eintrag) => eintrag.type === "file").map((eintrag) => eintrag.name),
+    );
+    if (!name) return null;
+
+    const datei = await getJson<{
+      content?: string;
+      encoding?: string;
+      path?: string;
+      html_url?: string | null;
+    }>(`${base}/contents/${encodeURIComponent(name)}`, { headers });
+    if (!datei?.content || datei.encoding !== "base64") return null;
+
+    const { content, truncated } = capReadme(decodeBase64(datei.content));
+    return {
+      content,
+      path: datei.path ?? name,
+      // html_url zeigt auf die Datei; fuer relative Links braucht es das
+      // Verzeichnis darum herum.
+      baseUrl: datei.html_url ? datei.html_url.replace(/\/[^/]*$/, "/") : null,
+      truncated,
+    };
+  }
 }
 
 function mapCommitStatus(state: string): CiState {

src/lib/git/github.ts

@@ -1,10 +1,12 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
 import type {
   BranchInfo,
   CiInfo,
   CiState,
+  CommitCalendar,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -14,6 +16,8 @@ import type {
   TagInfo,
   TicketInfo,
 } from "./types";
+import { dayKey } from "./calendar";
+import { capReadme, decodeBase64, type RepoReadme } from "./readme";
 import { GitApiError, bucketCommitActivity } from "./types";
 
 /**
@@ -40,6 +44,32 @@ 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 check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {
@@ -206,6 +236,95 @@ export class GitHubClient implements GitClient {
       commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
     };
   }
+
+  /**
+   * GitHub fuehrt die Statistik selbst: /stats/commit_activity liefert 52
+   * Wochen mit Tageswerten in einem einzigen Aufruf. Das ist deutlich
+   * sparsamer, als ein Jahr Commits seitenweise abzuholen.
+   *
+   * Die Statistik wird bei Bedarf erst berechnet; dann antwortet GitHub mit
+   * 202 und einem leeren Rumpf – daher der leere Fall unten.
+   *
+   * Bewusst getJson und nicht getJsonSafe: ein Rate-Limit oder ein Ausfall
+   * darf nicht als "keine Daten" durchgehen. Der Fehler geht nach oben, und
+   * der naechste Abgleich versucht es erneut.
+   */
+  async fetchCommitCalendar(ref: RepoRef): Promise<CommitCalendar | null> {
+    const base = `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+    const wochen = await getJson<GitHubWeek[]>(`${base}/stats/commit_activity`, {
+      headers: this.headers(),
+    });
+
+    if (!Array.isArray(wochen) || wochen.length === 0) {
+      // Entweder rechnet GitHub noch, oder das Repository hat keine Commits.
+      // Ersatzweise aus den geholten Commits zu bauen waere irrefuehrend –
+      // das taete so, als reichte der Zeitraum ein Jahr zurueck.
+      return null;
+    }
+
+    const days: Record<string, number> = {};
+    let von: string | null = null;
+    const heute = dayKey(new Date());
+
+    for (const woche of wochen) {
+      if (!woche?.week || !Array.isArray(woche.days)) continue;
+      woche.days.forEach((anzahl, index) => {
+        const tag = dayKey(new Date((woche.week + index * 86_400) * 1000));
+        if (tag > heute) return;
+        if (von === null || tag < von) von = tag;
+        if (anzahl > 0) days[tag] = anzahl;
+      });
+    }
+
+    if (von === null) return null;
+
+    return { from: von, to: heute, days, source: "stats", truncated: false };
+  }
+
+  /**
+   * GitHub hat einen eigenen Endpunkt, der jede Schreibweise findet – ein
+   * Aufruf genuegt. Ohne README antwortet er mit 404; das ist kein Fehler,
+   * sondern die Auskunft "gibt es nicht".
+   */
+  async fetchReadme(ref: RepoRef): Promise<RepoReadme | null> {
+    const base = `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
+
+    let datei: GitHubContent;
+    try {
+      datei = await getJson<GitHubContent>(`${base}/readme`, { headers: this.headers() });
+    } catch (error) {
+      if (error instanceof GitApiError && error.status === 404) return null;
+      throw error;
+    }
+
+    if (!datei?.content || datei.encoding !== "base64") return null;
+
+    const { content, truncated } = capReadme(decodeBase64(datei.content));
+    return {
+      content,
+      path: datei.path ?? datei.name ?? "README",
+      // html_url zeigt auf die Datei; fuer relative Links braucht es das
+      // Verzeichnis darum herum.
+      baseUrl: datei.html_url ? datei.html_url.replace(/\/[^/]*$/, "/") : null,
+      truncated,
+    };
+  }
+}
+
+interface GitHubContent {
+  name?: string;
+  path?: string;
+  content?: string;
+  encoding?: string;
+  html_url?: string | null;
+}
+
+interface GitHubWeek {
+  /** Unix-Zeit des Wochenanfangs (Sonntag). */
+  week: number;
+  /** Sieben Werte, Sonntag bis Samstag. */
+  days: number[];
+  total: number;
 }
 
 /** GitHub trennt Lauf-Status und Ergebnis; hier auf einen Wert zusammenfuehren. */

src/lib/git/gitlab.ts

@@ -1,10 +1,18 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
+import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
+import {
+  CALENDAR_PAGE_SIZE,
+  calendarByPaging,
+  calendarSince,
+  type CommitCalendar,
+} from "./calendar";
+import { capReadme, decodeBase64, pickReadme, type RepoReadme } from "./readme";
 import type {
   BranchInfo,
   CiInfo,
   CiState,
   CommitInfo,
   ConnectionCheck,
+  CreatedIssue,
   GitClient,
   ProviderConfig,
   ReleaseInfo,
@@ -38,6 +46,30 @@ 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 check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {
@@ -76,10 +108,13 @@ export class GitLabClient implements GitClient {
     });
   }
 
+  /** "gruppe/sub/projekt" URL-kodiert – so adressiert GitLab ein Projekt. */
+  private projectPath(ref: RepoRef): string {
+    return encodeURIComponent([ref.owner, ref.name].filter(Boolean).join("/"));
+  }
+
   async fetchRepo(ref: RepoRef): Promise<RepoSnapshotData> {
-    const path = [ref.owner, ref.name].filter(Boolean).join("/");
+    const base = `${this.apiBase}/projects/${this.projectPath(ref)}`;
-    const encoded = encodeURIComponent(path);
-    const base = `${this.apiBase}/projects/${encoded}`;
     const headers = this.headers();
 
     const project = await getJson<GitLabProject>(`${base}?statistics=true`, { headers });
@@ -198,6 +233,64 @@ export class GitLabClient implements GitClient {
       commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
     };
   }
+
+  /**
+   * GitLab kennt keine fertige Jahresstatistik, also seitenweise mit `since`.
+   * Der Deckel in calendarByPaging begrenzt das auf wenige Aufrufe.
+   */
+  async fetchCommitCalendar(ref: RepoRef): Promise<CommitCalendar | null> {
+    const base = `${this.apiBase}/projects/${this.projectPath(ref)}`;
+    const seit = calendarSince().toISOString();
+
+    // getJson und nicht getJsonSafe: ein Rate-Limit darf nicht als "keine
+    // Daten" durchgehen – siehe maybeRefreshCalendar.
+    return calendarByPaging(async (seite) => {
+      const commits = await getJson<GitLabCommit[]>(
+        `${base}/repository/commits?per_page=${CALENDAR_PAGE_SIZE}&page=${seite}` +
+          `&since=${encodeURIComponent(seit)}`,
+        { headers: this.headers() },
+      );
+      return commits.map((commit) => toIso(commit.committed_date ?? commit.created_at));
+    });
+  }
+
+  /**
+   * GitLab kennt keinen README-Endpunkt. Erst das Wurzelverzeichnis
+   * auflisten, dann die gefundene Datei holen – zwei Aufrufe.
+   */
+  async fetchReadme(ref: RepoRef): Promise<RepoReadme | null> {
+    const base = `${this.apiBase}/projects/${this.projectPath(ref)}`;
+    const headers = this.headers();
+
+    const eintraege = await getJsonSafe<Array<{ name: string; type: string }>>(
+      `${base}/repository/tree?per_page=100`,
+      [],
+      { headers },
+    );
+    const name = pickReadme(
+      eintraege.filter((eintrag) => eintrag.type === "blob").map((eintrag) => eintrag.name),
+    );
+    if (!name) return null;
+
+    const datei = await getJson<{ content?: string; encoding?: string; file_path?: string }>(
+      `${base}/repository/files/${encodeURIComponent(name)}?ref=HEAD`,
+      { headers },
+    );
+    if (!datei?.content || datei.encoding !== "base64") return null;
+
+    const { content, truncated } = capReadme(decodeBase64(datei.content));
+    const projekt = await getJsonSafe<GitLabProject>(base, {} as GitLabProject, { headers });
+
+    return {
+      content,
+      path: datei.file_path ?? name,
+      baseUrl:
+        projekt?.web_url && projekt.default_branch
+          ? `${projekt.web_url}/-/blob/${encodeURIComponent(projekt.default_branch)}/`
+          : null,
+      truncated,
+    };
+  }
 }
 
 function mapPipelineState(status: string | null): CiState {

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/readme.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { README_MAX_CHARS, capReadme, decodeBase64, pickReadme } from "./readme";
+
+describe("pickReadme", () => {
+  it("findet die uebliche Schreibweise", () => {
+    expect(pickReadme(["src", "README.md", "package.json"])).toBe("README.md");
+  });
+
+  it("ist bei der Gross- und Kleinschreibung nachsichtig", () => {
+    expect(pickReadme(["readme.md"])).toBe("readme.md");
+    expect(pickReadme(["ReadMe.MD"])).toBe("ReadMe.MD");
+  });
+
+  it("zieht Markdown den uebrigen Formaten vor", () => {
+    // Beides kommt vor; nur das erste laesst sich wirklich darstellen.
+    expect(pickReadme(["README.rst", "README.md"])).toBe("README.md");
+  });
+
+  it("nimmt auch ein README ohne Endung", () => {
+    expect(pickReadme(["LICENSE", "README"])).toBe("README");
+  });
+
+  it("liefert null, wenn keines dabei ist", () => {
+    expect(pickReadme(["src", "package.json"])).toBeNull();
+    expect(pickReadme([])).toBeNull();
+  });
+
+  it("verwechselt Aehnliches nicht mit dem README", () => {
+    expect(pickReadme(["README-CONTRIBUTING.md", "readme.md.bak"])).toBeNull();
+  });
+});
+
+describe("capReadme", () => {
+  it("laesst Kurzes unangetastet", () => {
+    const { content, truncated } = capReadme("# Titel\n\nEin Satz.");
+    expect(content).toBe("# Titel\n\nEin Satz.");
+    expect(truncated).toBe(false);
+  });
+
+  it("kuerzt Langes an einer Zeilengrenze", () => {
+    // Sonst bliebe womoeglich ein halber Codeblock stehen.
+    const zeile = "x".repeat(80);
+    const lang = Array.from({ length: 2000 }, () => zeile).join("\n");
+    const { content, truncated } = capReadme(lang);
+    expect(truncated).toBe(true);
+    expect(content.length).toBeLessThanOrEqual(README_MAX_CHARS);
+    expect(content.endsWith("x")).toBe(true);
+    expect(content.split("\n").at(-1)).toBe(zeile);
+  });
+
+  it("kuerzt notfalls hart, wenn es gar keine Zeilengrenze gibt", () => {
+    // Eine einzige riesige Zeile: hier waere der letzte Umbruch bei -1.
+    const { content, truncated } = capReadme("y".repeat(README_MAX_CHARS + 500));
+    expect(truncated).toBe(true);
+    expect(content).toHaveLength(README_MAX_CHARS);
+  });
+});
+
+describe("decodeBase64", () => {
+  it("dekodiert UTF-8 richtig", () => {
+    // Ueber Bytes gedacht kaeme hier Kauderwelsch heraus.
+    const kodiert = Buffer.from("# Nebula – Übersicht", "utf8").toString("base64");
+    expect(decodeBase64(kodiert)).toBe("# Nebula – Übersicht");
+  });
+
+  it("uebergeht Zeilenumbrueche in der Kodierung", () => {
+    // GitHub bricht den base64-Block alle 60 Zeichen um.
+    const roh = Buffer.from("Hallo Welt", "utf8").toString("base64");
+    const umgebrochen = `${roh.slice(0, 4)}\n${roh.slice(4)}`;
+    expect(decodeBase64(umgebrochen)).toBe("Hallo Welt");
+  });
+});

src/lib/git/readme.ts

@@ -0,0 +1,78 @@
+/**
+ * Das README eines Repositories – gemeinsame Teile fuer alle drei Anbieter.
+ *
+ * Gezeigt wird es auf der Projektseite, damit man nicht ins Git wechseln
+ * muss, nur um zu sehen, worum ein halbvergessenes Projekt eigentlich ging.
+ */
+
+export interface RepoReadme {
+  /** Roher Markdown-Text. */
+  content: string;
+  /** Dateiname im Repository, etwa "README.md". */
+  path: string;
+  /**
+   * Basis, gegen die relative Links im Text aufzuloesen sind – die
+   * Web-Ansicht des Repositories im Verzeichnis des READMEs.
+   */
+  baseUrl: string | null;
+  /** Wurde am Deckel abgeschnitten? */
+  truncated: boolean;
+}
+
+/**
+ * Hoechstlaenge. Ein README von einem Megabyte gibt es, und es waere in
+ * einer Vorschau ohnehin unlesbar – abgeschnitten wird an einer
+ * Zeilengrenze, damit kein halber Codeblock stehen bleibt.
+ */
+export const README_MAX_CHARS = 60_000;
+
+/**
+ * Dateinamen, die als README gelten – in dieser Reihenfolge. Markdown zuerst,
+ * weil nur das dargestellt werden kann; die uebrigen landen als Klartext in
+ * einem Codeblock, was immer noch besser ist als nichts.
+ */
+const KANDIDATEN = [
+  "readme.md",
+  "readme.markdown",
+  "readme.mdown",
+  "readme",
+  "readme.txt",
+  "readme.rst",
+];
+
+/**
+ * Sucht aus einer Verzeichnisauflistung die README-Datei heraus.
+ * Gross- und Kleinschreibung ist egal; die Reihenfolge oben entscheidet.
+ */
+export function pickReadme(namen: string[]): string | null {
+  const klein = new Map(namen.map((name) => [name.toLowerCase(), name]));
+  for (const kandidat of KANDIDATEN) {
+    const treffer = klein.get(kandidat);
+    if (treffer) return treffer;
+  }
+  return null;
+}
+
+/** Kuerzt am Deckel, aber an einer Zeilengrenze. */
+export function capReadme(text: string): { content: string; truncated: boolean } {
+  if (text.length <= README_MAX_CHARS) return { content: text, truncated: false };
+
+  const roh = text.slice(0, README_MAX_CHARS);
+  const letzterUmbruch = roh.lastIndexOf("\n");
+  return {
+    // Nur wenn der Umbruch nicht ganz am Anfang liegt – sonst bliebe fast
+    // nichts uebrig.
+    content: letzterUmbruch > README_MAX_CHARS / 2 ? roh.slice(0, letzterUmbruch) : roh,
+    truncated: true,
+  };
+}
+
+/**
+ * Dekodiert, was die Anbieter als base64 liefern.
+ *
+ * Bewusst ueber Buffer und nicht ueber atob: der Inhalt ist UTF-8, und atob
+ * gaebe Bytes zurueck, aus denen Umlaute als Kauderwelsch herauskaemen.
+ */
+export function decodeBase64(value: string): string {
+  return Buffer.from(value.replace(/\s/g, ""), "base64").toString("utf8");
+}

src/lib/git/types.ts

@@ -1,4 +1,8 @@
 import type { GitProvider } from "@prisma/client";
+import type { CommitCalendar } from "./calendar";
+import type { RepoReadme } from "./readme";
+
+export type { CommitCalendar, RepoReadme };
 
 export type ProviderKind = GitProvider;
 
@@ -163,14 +167,46 @@ 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>;
   /** Repos, auf die der Token Zugriff hat (fuer die Auswahl beim Verknuepfen). */
   listRepos(query?: string): Promise<RepoListItem[]>;
   /** Vollstaendiger Stand eines Repositories. */
   fetchRepo(ref: RepoRef): Promise<RepoSnapshotData>;
+  /**
+   * Commits je Tag ueber ein Jahr – fuer die Heatmap.
+   *
+   * Getrennt von fetchRepo, weil es zusaetzliche Aufrufe kostet und nur
+   * hoechstens einmal am Tag noetig ist. null heisst: nichts zu holen.
+   */
+  fetchCommitCalendar(ref: RepoRef): Promise<CommitCalendar | null>;
+  /**
+   * Das README des Repositories. Wie der Kalender getrennt, weil es
+   * zusaetzliche Aufrufe kostet und sich selten aendert. null heisst: es
+   * gibt keins.
+   */
+  fetchReadme(ref: RepoRef): Promise<RepoReadme | null>;
 }
 
 /** Fehler mit HTTP-Kontext, damit die UI verstaendliche Meldungen zeigen kann. */

src/lib/projects.ts

@@ -1,4 +1,4 @@
-import { Prisma } from "@prisma/client";
+import { Prisma, type ProjectStatus } from "@prisma/client";
 import { prisma } from "@/lib/db";
 import { slugify } from "@/lib/utils";
 
@@ -28,6 +28,25 @@ export async function uniqueSlug(
   return `${base}-${Date.now()}`;
 }
 
+/**
+ * Naechste freie Position am Ende einer Statusspalte im Brett.
+ *
+ * Muss bei jedem Anlegen und bei jedem Statuswechsel gesetzt werden – sonst
+ * stehen alle auf 0 und das Brett zeigt eine Reihenfolge, die sich bei jedem
+ * Laden anders ergeben kann.
+ */
+export async function nextProjectPosition(
+  ownerId: string,
+  status: ProjectStatus,
+): Promise<number> {
+  const last = await prisma.project.findFirst({
+    where: { ownerId, status },
+    orderBy: { position: "desc" },
+    select: { position: true },
+  });
+  return (last?.position ?? -1) + 1;
+}
+
 /**
  * Verbindungsfelder, die an den Browser gehen duerfen.
  * tokenCipher ist bewusst nicht dabei.
@@ -46,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/sync/index.ts

@@ -2,6 +2,7 @@ import type { Repository } from "@prisma/client";
 import { recordActivity, shorten } from "@/lib/activity";
 import { prisma } from "@/lib/db";
 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 type { RepoSnapshotData } from "@/lib/git/types";
@@ -57,6 +58,10 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
   try {
     const data = await client.fetchRepo(ref);
     await persistSnapshot(repository, data);
+    // Erst nach dem Snapshot: die Zeile muss existieren, bevor Kalender und
+    // README hineingeschrieben werden koennen.
+    await maybeRefreshCalendar(repository.id, client, ref);
+    await maybeRefreshReadme(repository.id, client, ref);
     // Nach dem Speichern, damit die Meldung den neuen Stand sieht.
     await notifyAfterSync(repository.id);
     return {
@@ -141,6 +146,98 @@ export async function syncProject(projectId: string): Promise<ProjectSyncResult>
   };
 }
 
+/** Wie lange ein geholter Kalender genuegt. */
+const CALENDAR_TTL_MS = 20 * 60 * 60 * 1000;
+
+/**
+ * Holt die Jahresuebersicht fuer die Heatmap – hoechstens einmal am Tag.
+ *
+ * Sie kostet zusaetzliche Aufrufe, bei GitLab und Gitea sogar mehrere. An
+ * einem Jahresueberblick aendert sich von Stunde zu Stunde aber nichts
+ * Sichtbares, und der Abgleich laeuft im Zweifel stuendlich.
+ *
+ * Fehler bleiben hier: der Kalender ist Beiwerk. Wenn er nicht zu holen ist,
+ * soll deshalb nicht der ganze Abgleich als gescheitert gelten.
+ */
+async function maybeRefreshCalendar(
+  repositoryId: string,
+  client: GitClient,
+  ref: { owner: string; name: string },
+): Promise<void> {
+  try {
+    const snapshot = await prisma.repoSnapshot.findUnique({
+      where: { repositoryId },
+      select: { commitCalendarAt: true },
+    });
+
+    const zuletzt = snapshot?.commitCalendarAt?.getTime() ?? 0;
+    if (Date.now() - zuletzt < CALENDAR_TTL_MS) return;
+
+    const calendar = await client.fetchCommitCalendar(ref);
+
+    // Nichts erhalten: entweder rechnet GitHub die Statistik gerade erst,
+    // oder das Repository hat keine Commits. Der Zeitstempel bleibt dann
+    // ungesetzt, damit es der naechste Abgleich erneut versucht – ihn hier zu
+    // setzen wuerde die Heatmap fuer einen Tag unterdruecken, obwohl sie
+    // vielleicht schon in Minuten bereitsteht.
+    if (!calendar) return;
+
+    await prisma.repoSnapshot.update({
+      where: { repositoryId },
+      data: {
+        commitCalendar: calendar as unknown as object,
+        commitCalendarAt: new Date(),
+      },
+    });
+  } catch (error) {
+    // Rate-Limit, Zeitueberschreitung, Ausfall: der Kalender ist Beiwerk und
+    // soll den Abgleich nicht scheitern lassen. Ohne Zeitstempel versucht es
+    // der naechste Durchgang von selbst wieder.
+    console.error("[nebula] Commit-Kalender konnte nicht geholt werden:", error);
+  }
+}
+
+/**
+ * Holt das README – wie der Kalender hoechstens einmal am Tag.
+ *
+ * Ein eigener Zeitstempel und nicht der des Kalenders: schlaegt das eine
+ * fehl, soll das andere nicht mit blockiert werden.
+ */
+async function maybeRefreshReadme(
+  repositoryId: string,
+  client: GitClient,
+  ref: { owner: string; name: string },
+): Promise<void> {
+  try {
+    const snapshot = await prisma.repoSnapshot.findUnique({
+      where: { repositoryId },
+      select: { readmeAt: true },
+    });
+
+    const zuletzt = snapshot?.readmeAt?.getTime() ?? 0;
+    if (Date.now() - zuletzt < CALENDAR_TTL_MS) return;
+
+    const readme = await client.fetchReadme(ref);
+
+    // Kein README im Repository: das ist eine Auskunft, kein Fehlschlag.
+    // Der Zeitstempel wird gesetzt, damit nicht jeder Abgleich erneut sucht,
+    // und ein etwaiger alter Stand verschwindet.
+    await prisma.repoSnapshot.update({
+      where: { repositoryId },
+      data: {
+        readme: readme?.content ?? null,
+        readmePath: readme?.path ?? null,
+        readmeBaseUrl: readme?.baseUrl ?? null,
+        readmeAt: new Date(),
+      },
+    });
+  } catch (error) {
+    // Wie beim Kalender: Beiwerk. Ohne Zeitstempel versucht es der naechste
+    // Durchgang von selbst wieder.
+    console.error("[nebula] README konnte nicht geholt werden:", error);
+  }
+}
+
 /** Owner/Name aus den Feldern oder ersatzweise aus der URL bestimmen. */
 export function resolveRepoRef(
   repository: Pick<Repository, "repoOwner" | "repoName" | "repoUrl">,

src/lib/tasks.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { TASK_STATUS_META, TASK_STATUS_ORDER, progressFromTasks } from "./tasks";
+import {
+  DUE_BUCKET_META,
+  DUE_BUCKET_ORDER,
+  TASK_STATUS_META,
+  TASK_STATUS_ORDER,
+  dueBucket,
+  nextDueDate,
+  progressFromTasks,
+} from "./tasks";
 
 describe("progressFromTasks", () => {
   it("rechnet den Anteil erledigter Aufgaben in Prozent um", () => {
@@ -34,3 +42,97 @@ describe("Spaltenreihenfolge", () => {
     }
   });
 });
+
+describe("nextDueDate", () => {
+  const abhaken = (iso: string) => new Date(iso);
+
+  it("rechnet vom bisherigen Termin, nicht vom Abhaken", () => {
+    // Woechentlich, faellig Montag, erledigt erst Mittwoch: der naechste
+    // Termin bleibt der Montag darauf, nicht der uebernaechste Mittwoch.
+    const next = nextDueDate("WEEKLY", new Date("2026-07-06T12:00:00Z"), abhaken("2026-07-08T09:00:00Z"));
+    expect(next.toISOString().slice(0, 10)).toBe("2026-07-13");
+  });
+
+  it("nimmt ohne bisherigen Termin den Zeitpunkt des Abhakens", () => {
+    const next = nextDueDate("DAILY", null, abhaken("2026-07-26T09:00:00Z"));
+    expect(next.toISOString().slice(0, 10)).toBe("2026-07-27");
+  });
+
+  it("schiebt so lange weiter, bis der Termin in der Zukunft liegt", () => {
+    // Ein halbes Jahr liegengeblieben: die naechste Fassung darf nicht
+    // schon bei ihrer Entstehung ueberfaellig sein.
+    const next = nextDueDate("WEEKLY", new Date("2026-01-05T12:00:00Z"), abhaken("2026-07-26T09:00:00Z"));
+    expect(next.getTime()).toBeGreaterThan(abhaken("2026-07-26T09:00:00Z").getTime());
+    // Und es bleibt ein Montag.
+    expect(next.getUTCDay()).toBe(1);
+  });
+
+  it("haelt beim Monatsintervall den Tag im Monat", () => {
+    const next = nextDueDate("MONTHLY", new Date("2026-03-15T12:00:00Z"), abhaken("2026-03-16T09:00:00Z"));
+    expect(next.toISOString().slice(0, 10)).toBe("2026-04-15");
+  });
+
+  it("rollt beim Monatsintervall nicht ueber kurze Monate hinweg", () => {
+    // Der 31. Januar plus ein Monat ist der 28. Februar, nicht der 3. Maerz.
+    const next = nextDueDate("MONTHLY", new Date("2026-01-31T12:00:00Z"), abhaken("2026-02-01T09:00:00Z"));
+    expect(next.toISOString().slice(0, 10)).toBe("2026-02-28");
+  });
+
+  it("kennt zwei Wochen", () => {
+    const next = nextDueDate("BIWEEKLY", new Date("2026-07-01T12:00:00Z"), abhaken("2026-07-02T09:00:00Z"));
+    expect(next.toISOString().slice(0, 10)).toBe("2026-07-15");
+  });
+
+  it("endet auch bei einem absurd alten Termin", () => {
+    // Ohne Deckel liefe die Schleife bei einem taeglichen Intervall und
+    // einem Datum von 1970 sehr lange.
+    const next = nextDueDate("DAILY", new Date("1970-01-01T00:00:00Z"), abhaken("2026-07-26T09:00:00Z"));
+    expect(next instanceof Date).toBe(true);
+    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

@@ -1,4 +1,4 @@
-import type { TaskStatus } from "@prisma/client";
+import type { Recurrence, TaskStatus } from "@prisma/client";
 import { prisma } from "@/lib/db";
 
 /** Spaltenreihenfolge des Aufgabenbretts. */
@@ -64,6 +64,165 @@ export async function refreshDerivedProgress(projectId: string): Promise<void> {
   });
 }
 
+// ── Wiederkehrende Aufgaben ──────────────────────────────────
+
+export const RECURRENCE_META: Record<Recurrence, { label: string; short: string }> = {
+  DAILY: { label: "Täglich", short: "1 T" },
+  WEEKLY: { label: "Wöchentlich", short: "1 W" },
+  BIWEEKLY: { label: "Alle zwei Wochen", short: "2 W" },
+  MONTHLY: { label: "Monatlich", short: "1 M" },
+};
+
+/** Einen Termin um ein Intervall weiterschieben. */
+function addInterval(from: Date, recurrence: Recurrence): Date {
+  const next = new Date(from);
+  switch (recurrence) {
+    case "DAILY":
+      next.setDate(next.getDate() + 1);
+      break;
+    case "WEEKLY":
+      next.setDate(next.getDate() + 7);
+      break;
+    case "BIWEEKLY":
+      next.setDate(next.getDate() + 14);
+      break;
+    case "MONTHLY": {
+      // setMonth rollt ueber: der 31. Januar wuerde zum 3. Maerz. Bei einem
+      // kuerzeren Folgemonat gehoert der Termin auf dessen letzten Tag.
+      const tag = next.getDate();
+      next.setDate(1);
+      next.setMonth(next.getMonth() + 1);
+      const letzterTag = new Date(next.getFullYear(), next.getMonth() + 1, 0).getDate();
+      next.setDate(Math.min(tag, letzterTag));
+      break;
+    }
+  }
+  return next;
+}
+
+/**
+ * Wann die naechste Fassung faellig ist.
+ *
+ * Gerechnet wird vom bisherigen Termin, nicht vom Zeitpunkt des Abhakens:
+ * eine woechentliche Aufgabe soll auf ihrem Montag bleiben, auch wenn sie
+ * einmal erst am Mittwoch erledigt wurde.
+ *
+ * Wurde sie lange liegengelassen, laege der naechste Termin allerdings
+ * immer noch in der Vergangenheit – dann wird so lange weitergeschoben, bis
+ * er in der Zukunft liegt. Sonst entstuende eine Aufgabe, die schon bei
+ * ihrer Entstehung ueberfaellig ist.
+ *
+ * Ohne bisherigen Termin zaehlt der Zeitpunkt des Abhakens.
+ */
+export function nextDueDate(
+  recurrence: Recurrence,
+  previousDue: Date | null,
+  completedAt: Date = new Date(),
+): Date {
+  if (!previousDue) return addInterval(completedAt, recurrence);
+
+  let next = addInterval(previousDue, recurrence);
+  // Deckel gegen eine Endlosschleife bei absurden Datumsangaben.
+  for (let schritt = 0; schritt < 500 && next <= completedAt; schritt += 1) {
+    next = addInterval(next, recurrence);
+  }
+  return next;
+}
+
+/**
+ * Legt die naechste Fassung einer wiederkehrenden Aufgabe an.
+ *
+ * Wird genau beim Uebergang nach ERLEDIGT aufgerufen – aus dem Dialog wie
+ * aus dem Ziehen im Brett. Ein erneutes Speichern einer bereits erledigten
+ * Aufgabe darf keine zweite Fassung erzeugen.
+ *
+ * Gibt die neue Aufgabe zurueck oder null, wenn nichts zu tun war.
+ */
+export async function spawnRecurrence(taskId: string) {
+  const erledigt = await prisma.task.findUnique({ where: { id: taskId } });
+  if (!erledigt?.recurrence) return null;
+
+  const faellig = nextDueDate(erledigt.recurrence, erledigt.dueDate, erledigt.doneAt ?? new Date());
+
+  return prisma.task.create({
+    data: {
+      projectId: erledigt.projectId,
+      title: erledigt.title,
+      description: erledigt.description,
+      status: "TODO",
+      position: await nextPosition(erledigt.projectId, "TODO"),
+      dueDate: faellig,
+      labels: erledigt.labels,
+      recurrence: erledigt.recurrence,
+      recurredFrom: erledigt.id,
+      // Die Herkunft aus einem Issue wandert nicht mit: das Issue ist
+      // abgearbeitet, und die Eindeutigkeit je Repository verboete es ohnehin.
+    },
+  });
+}
+
+// ── 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,70 @@
+import type { TaskStatus } from "@prisma/client";
+import { prisma } from "@/lib/db";
+import { clientForConnection } from "@/lib/git";
+
+/**
+ * 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;
+  }
+}

src/lib/validation.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from "vitest";
 import { NOTIFICATION_EVENTS } from "@/lib/notify/types";
-import { notificationTargetCreateSchema } from "./validation";
+import {
+  notificationTargetCreateSchema,
+  projectBulkSchema,
+  projectReorderSchema,
+} from "./validation";
 
 /**
  * Dieser Test entstand aus einem Fehler: beim Ergaenzen eines neuen
@@ -70,3 +74,60 @@ describe("notificationTargetCreateSchema", () => {
     }
   });
 });
+
+describe("projectReorderSchema", () => {
+  it("nimmt Spalten mit Listen an", () => {
+    const parsed = projectReorderSchema.safeParse({
+      columns: { IDEA: ["a", "b"], DONE: [] },
+    });
+    expect(parsed.success).toBe(true);
+  });
+
+  it("weist unbekannte Spalten ab", () => {
+    expect(
+      projectReorderSchema.safeParse({ columns: { PHANTASIE: ["a"] } }).success,
+    ).toBe(false);
+  });
+
+  it("weist einen leeren Aufruf ab, statt ihn wirkungslos durchzuwinken", () => {
+    expect(projectReorderSchema.safeParse({ columns: {} }).success).toBe(false);
+  });
+});
+
+describe("projectBulkSchema", () => {
+  const ids = ["a", "b"];
+
+  it("verlangt zu jeder Aktion die noetige Angabe", () => {
+    // Ohne diese Pruefungen kaeme die Aktion durch und taete nichts – der
+    // schlimmste Fall, weil niemand merkt, dass nichts passiert ist.
+    expect(projectBulkSchema.safeParse({ ids, action: "status" }).success).toBe(false);
+    expect(projectBulkSchema.safeParse({ ids, action: "tags" }).success).toBe(false);
+    expect(projectBulkSchema.safeParse({ ids, action: "tags", tags: [] }).success).toBe(false);
+    expect(projectBulkSchema.safeParse({ ids, action: "favorite" }).success).toBe(false);
+  });
+
+  it("laesst vollstaendige Aktionen durch", () => {
+    expect(
+      projectBulkSchema.safeParse({ ids, action: "status", status: "DONE" }).success,
+    ).toBe(true);
+    expect(
+      projectBulkSchema.safeParse({ ids, action: "tags", tags: ["archiv"] }).success,
+    ).toBe(true);
+    expect(
+      projectBulkSchema.safeParse({ ids, action: "favorite", favorite: false }).success,
+    ).toBe(true);
+    // Loeschen braucht nichts ausser den IDs.
+    expect(projectBulkSchema.safeParse({ ids, action: "delete" }).success).toBe(true);
+  });
+
+  it("ergaenzt standardmaessig, statt zu entfernen", () => {
+    const parsed = projectBulkSchema.parse({ ids, action: "tags", tags: ["x"] });
+    expect(parsed.tagMode).toBe("add");
+  });
+
+  it("braucht mindestens eine ID und deckelt die Menge", () => {
+    expect(projectBulkSchema.safeParse({ ids: [], action: "delete" }).success).toBe(false);
+    const zuViele = Array.from({ length: 201 }, (_, index) => `id-${index}`);
+    expect(projectBulkSchema.safeParse({ ids: zuViele, action: "delete" }).success).toBe(false);
+  });
+});