feat(sync): geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab

Behebt florian.wilde/nebula#1.

Der Rueckweg "Issue geschlossen -> Aufgabe erledigt" gab es seit v1.7.0
schon, aber nur ueber den Webhook. Ist keiner eingerichtet - und am
Repository war keiner eingetragen -, blieb er ganz aus. Damit hing die
Funktion an einer Voraussetzung, die man ihr von aussen nicht ansieht.

Der Abgleich fragt jetzt den Zustand verknuepfter Issues nach und hakt ab,
was in Git geschlossen ist. Beides ergaenzt sich: der Webhook wirkt sofort,
der Abgleich verlaesslich.

Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen
fuehrt, werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht - die
Liste ist gedeckelt, aus dem Fehlen einer Nummer folgt nichts. Deshalb ein
Deckel von 25 Nachfragen je Durchgang.

**Nur abhaken, nie zuruecknehmen.** Der Abgleich sieht Zustaende, keine
Ereignisse. Ein offenes Issue kann auch bedeuten, dass das Schliessen von
Nebula aus fehlgeschlagen ist; ein symmetrischer Abgleich wuerde dann eine
bewusst erledigte Aufgabe wieder aufmachen. Das Zuruecknehmen bleibt dem
Webhook vorbehalten, der ein echtes "reopened" sieht. Ein geloeschtes Issue
ist ebenfalls kein erledigtes.

Nebenbei eine Unstimmigkeit aus v1.7.0 geradegezogen: der Webhook setzte nur
den Status und liess aus, was die Oberflaeche tut - naechste Fassung einer
wiederkehrenden Aufgabe, Eintrag im Verlauf. Beide Wege gehen jetzt durch
dieselbe Funktion.

Geprueft: 232 Unit-Tests, 31 E2E-Tests. Der neue E2E-Test laeuft als
einziger wirklich nach draussen - er haengt eine Aufgabe an ein seit Jahren
geschlossenes Issue und prueft, dass der Abgleich sie abhakt. Ist GitHub
nicht erreichbar, ueberspringt er sich statt rot zu werden.

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).
@@ -53,9 +69,29 @@ ADMINER_PORT="8080"
 # und Passkeys sind davon nicht betroffen.
 APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
 
-# Lebensdauer einer Anmeldung in Tagen.
+# Absolute Lebensdauer einer Anmeldung in Tagen – ab dem Anmelden gerechnet
+# und nicht verlaengerbar.
 SESSION_TTL_DAYS="30"
 
+# Leerlauffrist in Stunden: so lange darf eine Sitzung unbenutzt bleiben.
+# Wird bei jeder Nutzung neu angestossen. 0 schaltet die Pruefung ab.
+SESSION_IDLE_HOURS="8"
+
+# ── Benachrichtigungen ───────────────────────────────────────
+# ntfy und Webhook brauchen nichts weiter – die Ziele werden in der
+# Anwendung unter "Mein Konto" eingerichtet.
+#
+# E-Mail steht erst zur Verfuegung, wenn SMTP_HOST gesetzt ist:
+# SMTP_HOST="smtp.example.com"
+# SMTP_PORT="587"
+# SMTP_SECURE="false"          # true bei Port 465, sonst STARTTLS
+# SMTP_USER="nebula@example.com"
+# SMTP_PASSWORD="geheim"
+# SMTP_FROM="Nebula <nebula@example.com>"
+
+# Timeout fuer das Zustellen in Millisekunden
+NOTIFY_TIMEOUT_MS="10000"
+
 # ── Ausgehende Git-Zugriffe ──────────────────────────────────
 # Timeout fuer Git-API-Aufrufe in Millisekunden
 GIT_API_TIMEOUT_MS="15000"

.gitea/workflows/ci.yml

@@ -0,0 +1,78 @@
+# Prueft jeden Push und jeden Pull Request.
+#
+# Die Datei liegt unter .gitea/workflows und wird von Gitea Actions gelesen.
+# Die Syntax ist mit GitHub Actions kompatibel – wer das Repo dorthin
+# spiegelt, kopiert sie nach .github/workflows.
+#
+# Voraussetzung: In der Gitea-Instanz muessen Actions aktiviert sein
+# (app.ini: [actions] ENABLED = true) und mindestens ein Runner registriert.
+
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  pruefen:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:17-alpine
+        env:
+          POSTGRES_USER: nebula
+          POSTGRES_PASSWORD: nebula
+          # Der Name muss "test" enthalten – global-setup.ts leert die
+          # Datenbank und weigert sich bei allem anderen.
+          POSTGRES_DB: nebula_e2e_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U nebula"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 20
+
+    env:
+      DATABASE_URL: postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public
+      E2E_DATABASE_URL: postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public
+      # Nur fuer den Lauf – keine echten Daten im Spiel.
+      APP_SECRET: ci-lauf-schluessel-nur-fuer-die-pipeline-0123456789
+      NEXT_TELEMETRY_DISABLED: "1"
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Abhaengigkeiten
+        run: npm ci
+
+      - name: Typen pruefen
+        run: npx tsc --noEmit
+
+      - name: Unit-Tests
+        run: npm test
+
+      - name: Browser fuer die Oberflaechentests
+        run: npx playwright install --with-deps chromium
+
+      # Baut zuerst und startet den Server dann selbst (siehe
+      # playwright.config.ts, webServer).
+      - name: Ende-zu-Ende-Tests
+        run: npm run test:e2e
+
+      - name: Bericht bei Fehlschlag sichern
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-bericht
+          path: |
+            playwright-report/
+            test-results/
+          retention-days: 7

.gitignore

@@ -46,6 +46,12 @@ yarn-error.log*
 # Sicherungen aus scripts/backup.* – enthalten alle Daten der Instanz
 /backups
 
+# Playwright
+/test-results
+/playwright-report
+/blob-report
+/playwright/.cache
+
 # editors
 .idea/
 .vscode/*

CLAUDE.md

@@ -0,0 +1,141 @@
+# Nebula – Hinweise für Claude Code
+
+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) · Server: [DEPLOYMENT.md](DEPLOYMENT.md)
+
+## Womit man arbeitet
+
+```bash
+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
+npm run build                  # Produktionsbau
+docker compose --profile full up -d --build    # alles im Container
+```
+
+**Vor dem `npm run build` einen laufenden `npm start`/`npm run dev` beenden.**
+Sonst hält der Prozess die Prisma-Engine-DLL und der Bau bricht unter Windows
+mit `EPERM … query_engine-windows.dll.node` ab.
+
+## Nicht verhandelbar
+
+**Datentrennung.** Jede Abfrage filtert auf den Besitzer, und zwar an erster
+Stelle in der `where`-Klausel. Schreiben und Löschen laufen über
+`updateMany`/`deleteMany` mit `ownerId`, damit fremde Datensätze gar nicht
+erst getroffen werden. Fremde IDs liefern **404, nicht 403** — die Antwort
+soll nicht bestätigen, dass es den Datensatz gibt.
+
+**Jeder Endpunkt prüft selbst.** `requireUserApi()` bzw. `requireUserPage()`
+sind die Sicherheitsgrenze. Die Middleware schaut nur, ob überhaupt ein
+Cookie mitkommt — im Edge-Runtime gibt es keine Datenbank.
+
+**Eingaben validieren.** Zod an jeder API-Grenze, Body über `readJsonBody`
+(erzwingt `application/json` und begrenzt die Größe).
+
+**Keine Geheimnisse nach außen.** Git-Tokens verlassen den Server nie;
+Verbindungen werden über `connectionSafeSelect` geladen. Projekt-Exporte
+enthalten grundsätzlich keine Tokens.
+
+**Ausgehende Aufrufe nur über `lib/git/http.ts`** — dort greift der
+SSRF-Schutz (`lib/security/ssrf.ts`).
+
+## Fallstricke, die schon zugeschlagen haben
+
+- **`node:`-Module in Client-Komponenten.** `lib/crypto`, `lib/auth/password`,
+  `lib/git/index` ziehen `node:crypto`/`node:net` nach. Client-Komponenten
+  importieren stattdessen `lib/git/meta` bzw. `lib/auth/constants`.
+- **`instrumentation.ts` wird auch für Edge übersetzt.** Der dynamische Import
+  muss *innerhalb* von `if (process.env.NEXT_RUNTIME === "nodejs")` stehen,
+  sonst scheitert der Bau an `node:crypto`.
+- **Eigene CSS-Klassen gehören in `app/components.css`** und dort in
+  `@layer components`. Außerhalb eines Layers gewinnen sie gegen
+  Tailwind-Utilities — dann greift `pl-9` neben `.field` nicht mehr.
+- **Menüs und Dialoge über Portal.** Karten setzen `overflow-hidden` und
+  `backdrop-filter`; Letzteres erzeugt einen neuen Bezugsrahmen, in dem
+  `position: fixed` und `z-index` nicht mehr wie erwartet wirken. Dafür gibt
+  es `components/ui/Popover.tsx` und `components/ui/Modal.tsx`.
+- **Overlays brauchen einen deckenden Hintergrund** (`.popover`), nicht
+  `.glass` — dessen 3,5 % Deckkraft lassen alles durchscheinen.
+- **Datumsangaben** über `lib/utils` formatieren (feste Zeitzone), sonst
+  weichen Server-Render und Hydration voneinander ab. Relative Zeiten
+  bekommen `suppressHydrationWarning`.
+
+## Migrationen
+
+`prisma migrate dev` ist hier nicht benutzbar (interaktiv). Stattdessen:
+
+```bash
+docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_shadow"
+npx prisma migrate diff --from-migrations prisma/migrations \
+  --to-schema-datamodel prisma/schema.prisma \
+  --shadow-database-url postgresql://nebula:nebula@localhost:5432/nebula_shadow \
+  --script --output prisma/migrations/<stempel>_<name>/migration.sql
+npx prisma migrate deploy
+```
+
+**`--from-migrations`, nicht `--from-schema-datasource`.** Letzteres
+vergleicht mit der *laufenden* Datenbank. Ist eine eben erzeugte Migration
+dort noch nicht eingespielt, steht ihr Inhalt in der nächsten gleich noch
+einmal.
+
+**Die erzeugte SQL vor dem Anwenden lesen.** Der Volltextindex
+`Note_fulltext_idx` ist ein Ausdrucksindex, den Prisma nicht kennt (er wird
+bislang in Ruhe gelassen, aber das ist nicht garantiert).
+
+**Datenmigrationen von Hand schreiben.** `migrate diff` kennt nur den
+Zielzustand: Spalten, die woandershin wandern, würde es ersatzlos löschen.
+Vorgehen wie in `20260726230000_repositories`: neue Tabelle anlegen, Bestand
+per `INSERT … SELECT` übernehmen, dann erst die alten Spalten entfernen.
+Danach `migrate diff` erneut laufen lassen — kommt „empty migration“ heraus,
+stimmt das Ergebnis mit dem Schema überein. Und gegen eine Kopie mit echten
+Daten prüfen, nicht nur gegen eine leere Datenbank.
+
+## Prüfen, nicht behaupten
+
+Vor „fertig": `npx tsc --noEmit`, `npm test`, `npm run build`.
+
+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
+sich nativ ab. Das sieht aus wie ein Anwendungsfehler, ist aber keiner:
+
+```bash
+cp -r .next/static .next/standalone/.next/ && cp -r public .next/standalone/
+```
+
+`pkill` gibt es in dieser Git-Bash nicht. Prozesse über PowerShell beenden
+(`Get-CimInstance Win32_Process … | Stop-Process`) — sonst läuft der alte
+Server weiter, hält die Prisma-DLL und blockiert den nächsten Bau.
+
+**Niemals gegen die echte Datenbank testen.** Eine Wegwerf-Datenbank anlegen
+und danach löschen:
+
+```bash
+docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
+DATABASE_URL=postgresql://nebula:nebula@localhost:5432/nebula_test npx prisma migrate deploy
+```
+
+## Sprache
+
+Code-Kommentare, Commit-Nachrichten und Oberfläche auf Deutsch, **ohne
+Umlaute in Bezeichnern und Commit-Nachrichten** (bestehende Konvention).
+In Markdown-Dateien und in der Oberfläche sind Umlaute erwünscht.
+
+Commits: Conventional Commits, Betreff deutsch, Rumpf erklärt **warum** —
+nicht was der Diff ohnehin zeigt.

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

@@ -22,11 +22,30 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
 
 ### 0.2 Anmeldung
 
-- **Benutzername und Passwort.** Mindestens 10 Zeichen, offensichtliche Passwörter werden
+- **Benutzername und Passwort.** Mindestens 10 Zeichen. Abgelehnt werden naheliegende
-  abgelehnt. Hashing mit scrypt.
+  Passwörter, reine Ziffernfolgen, zu wenig verschiedene Zeichen (`abababab`),
+  durchlaufende Folgen (`abcdefgh`) und alles, was den eigenen Benutzernamen enthält.
+  **Keine Zusammensetzungsregeln** — ASVS 2.1.9 rät ausdrücklich davon ab, weil sie zu
+  `Passwort1!` führen statt zu Entropie.
+- **Hashing mit scrypt**, `N = 2^17, r = 8, p = 1` nach dem OWASP Password Storage Cheat
+  Sheet (rund 0,5 s und 128 MiB je Prüfung). Die Parameter stehen im Hash, ältere bleiben
+  also lesbar — und werden bei der nächsten Anmeldung still auf den aktuellen Stand
+  gehoben. Das ist der einzige Moment, in dem das Klartextpasswort vorliegt.
+- **Gleiche Antwort für alles Fehlgeschlagene.** Ob ein Konto existiert, gesperrt,
+  deaktiviert oder reines Passkey-Konto ist, sagt die Anmeldung erst, wenn das Passwort
+  stimmt. Davor gibt es genau einen Text und eine vergleichbare Antwortzeit
+  (`fakeVerifyDelay`), damit sich Benutzernamen nicht durchprobieren lassen.
 - **Passkey (WebAuthn).** Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel. Die
   Anmeldung läuft über auffindbare Credentials, ein Benutzername ist also nicht nötig.
   Mehrere Passkeys pro Konto, benennbar und einzeln entfernbar.
+- **Zwei-Faktor per TOTP.** Zeitbasiertes Einmalkennwort zusätzlich zum Passwort, für jede
+  gängige Authenticator-App. Einrichtung über QR-Code oder abgetippten Schlüssel; scharf
+  wird er erst nach einem bestätigten Code, damit sich niemand aussperrt, der den Scan
+  nicht hinbekommt. Dazu zehn **Wiederherstellungscodes**, jeder genau einmal gültig —
+  sie werden nur bei der Ausgabe angezeigt. Abschalten und Neuerzeugen verlangen das
+  Passwort, nicht bloß eine offene Sitzung.
+- Die Passkey-Anmeldung fragt **nicht** nach dem zweiten Faktor: der Passkey ist bereits an
+  ein Gerät gebunden und damit selbst der zweite Faktor.
 - Ein Konto kann **ausschließlich** per Passkey nutzbar sein. Der letzte Passkey lässt sich
   dann nicht entfernen, solange kein Passwort gesetzt ist.
 - Fehlversuche werden gezählt; nach acht sperrt sich das Konto für 15 Minuten.
@@ -35,9 +54,9 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
 
 ### 0.3 Mein Konto
 
-Anzeigename und E-Mail ändern · Passwort setzen oder wechseln · Passkeys verwalten ·
+Anzeigename und E-Mail ändern · Passwort setzen oder wechseln · Zwei-Faktor einrichten und
-aktive Sitzungen einsehen (Browser, Betriebssystem, IP, letzte Aktivität) · überall
+abschalten · Passkeys verwalten · aktive Sitzungen einsehen (Browser, Betriebssystem, IP,
-abmelden, wobei das eigene Gerät angemeldet bleibt.
+letzte Aktivität) · überall abmelden, wobei das eigene Gerät angemeldet bleibt.
 
 ### 0.4 Benutzerverwaltung (Administratoren)
 
@@ -101,13 +120,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
@@ -117,6 +154,63 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
 - **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
 - **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.
 
+### Schnellsuche
+
+**`Strg+K`** (auf dem Mac `Cmd+K`) öffnet überall eine Palette:
+
+- **Projekte** nach Name, Kurzbeschreibung und Tags — ohne Eingabe stehen die letzten
+  gleich bereit
+- **Notizen** über dieselbe Volltextsuche wie im Board, entprellt ab zwei Zeichen
+- **Bereiche**: Dashboard, Git-Verbindungen, Mein Konto, Admin-Einstellungen
+
+Bedienung über Tastatur: Pfeile wählen, `Enter` öffnet, `Esc` schließt. Die Projektliste
+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
@@ -126,8 +220,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
 
@@ -137,6 +238,109 @@ Anzahl Notizen · Warnung bei Sync-Fehler · Tags · Statusauswahl · Priorität
 
 ---
 
+## 2a. Aufgaben je Projekt
+
+Jedes Projekt hat ein eigenes Aufgabenbrett mit vier Spalten: **Offen · In Arbeit ·
+Blockiert · Erledigt**.
+
+- **Ziehen und Ablegen** zwischen den Spalten **und innerhalb** einer Spalte. Anders als
+  beim Projektbrett ist die Reihenfolge hier bedeutsam, deshalb wird sie gespeichert.
+- Gezogen wird am Griff links, damit ein Klick auf die Karte weiter den Dialog öffnet.
+- Eine Aufgabe braucht nur einen Titel. Optional: Beschreibung (Markdown),
+  Fälligkeitsdatum und Labels.
+- **Fälligkeiten** färben sich mit: überfällig rot, heute gelb, in den nächsten Tagen
+  gedämpft.
+- 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,
+Labels und ein Link zurück ins Git-System.
+
+- Grundlage ist der **zuletzt geholte Stand**, hier wird nichts nachgeladen. Ein Klick
+  soll nicht ungefragt fremde APIs ansprechen; wer den neuesten Stand will, gleicht
+  vorher ab.
+- Die Issue-Nummer bleibt an der Aufgabe und ist je Projekt eindeutig. Ein zweiter Klick
+  legt deshalb **keine Dubletten** an, auch wenn die Aufgabe inzwischen verschoben oder
+  umbenannt wurde.
+- Ohne Repo-Stand meldet der Server das mit einem Hinweis statt still nichts zu tun.
+
+### Fortschritt aus Aufgaben
+
+Pro Projekt umschaltbar. Ist es an, ergibt sich der Fortschritt aus dem Anteil erledigter
+Aufgaben und wird bei jeder Änderung neu berechnet — der Regler ist dann gesperrt, statt
+einen Wert anzubieten, der gleich wieder überschrieben würde.
+
+Auf der Projektkarte im Dashboard steht das Verhältnis als `3/8`.
+
+### Wie die Reihenfolge gespeichert wird
+
+Beim Ablegen schickt die Oberfläche je Spalte die **vollständige Liste** der Aufgaben in
+ihrer neuen Reihenfolge; der Server vergibt daraus Position und Status. Das ist
+wiederholbar, kommt ohne Positionsrechnerei im Browser aus, und ein verlorener Aufruf
+lässt sich einfach erneut senden. IDs, die nicht zum Projekt gehören, werden ignoriert
+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.
@@ -156,6 +360,54 @@ Anzahl Notizen · Warnung bei Sync-Fehler · Tags · Statusauswahl · Priorität
 
 ## 4. Git-Anbindung
 
+### 4.0 Mehrere Repositories je Projekt
+
+Ein Vorhaben besteht oft aus mehreren Repositories — Frontend und Backend etwa, oder
+App und Infrastruktur. Sie gehören trotzdem in **eine** Karte.
+
+- Im Git-Panel steht eine Leiste mit allen Repositories des Projekts, sobald es mehr als
+  eines gibt. Jedes hat eigene Kennzahlen, Listen, CI und eigenen Abgleich; „Alle" gleicht
+  sie nacheinander ab — nicht gleichzeitig, denn ein Schwung Anfragen an denselben Anbieter
+  ist genau das, worauf Rate-Limits reagieren.
+- Eine frei wählbare **Bezeichnung** („Frontend") tritt an die Stelle von `owner/name`.
+- Das erste Repository ist das **führende**. Wo nur eines dargestellt werden kann — auf der
+  Karte im Dashboard, im Kanban —, ist es dieses. Die Karte zeigt daneben `+2 Repos`.
+  Ein Abgleichsfehler an *irgendeinem* Repository erscheint auf der Karte, sonst bliebe er
+  unbemerkt.
+- **Stillstand** bemisst sich am jüngsten Commit über alle Repositories: an einem Vorhaben
+  wird gearbeitet, sobald an einem seiner Teile gearbeitet wird.
+- Benachrichtigungen merken sich den gemeldeten Zustand **je Repository**. Sonst verdeckte
+  ein rotes Frontend die rote Pipeline des Backends. Der Betreff nennt das Repository nur,
+  wenn es nicht ohnehin so heißt wie das Projekt.
+- Übernommene Issues merken sich, aus welchem Repository sie stammen — Frontend und Backend
+  haben beide ein Issue Nummer 5, und das sind zwei Aufgaben.
+
+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 |
@@ -193,6 +445,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 |
 
@@ -219,9 +472,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
@@ -251,6 +514,103 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 - **Zeitlimit** pro Aufruf über `GIT_API_TIMEOUT_MS` einstellbar; die Teilabfragen laufen
   parallel, eine fehlschlagende Liste bricht den restlichen Sync nicht ab.
 
+### 4.6 Aufgabe ↔ Git-Issue
+
+Die Verbindung geht in beide Richtungen — mit einer bewussten Grenze.
+
+**Nebula → Git.** Ein Knopf im Aufgabendialog legt zur Aufgabe ein Issue im
+verknüpften Repository an. Nummer und Adresse landen an der Aufgabe (`sourceIssue`,
+`sourceUrl`, `sourceRepositoryId` — dieselben Felder, die die Übernahme aus Issues seit
+v0.9.0 füllt, samt Eindeutigkeit je Repository gegen Dubletten). In den Rumpf kommt ein
+Rückverweis auf das Projekt.
+
+Ausdrücklich **per Knopf und nie nebenbei**: was in ein fremdes System geschrieben wird,
+soll jemand gewollt haben. Danach wandert der Zustand allerdings mit — erledigt schließt
+das Issue, ein Zurückziehen öffnet es wieder. Schlägt der Aufruf fehl, zieht die Aufgabe
+trotzdem um; ein nicht erreichbares Git-System darf das Abhaken nicht verhindern.
+
+**Git → Nebula** auf zwei Wegen, die sich ergänzen:
+
+- **Webhook** — sofort, sobald das Issue geschlossen wird. Setzt voraus, dass die Instanz
+  von außen erreichbar ist und der Haken eingetragen wurde (siehe 4.7).
+- **Beim Abgleich** — verzögert, aber verlässlich. Der Abgleich fragt den Zustand
+  verknüpfter Issues nach und hakt ab, was in Git geschlossen ist. Damit funktioniert der
+  Rückweg auch ohne Webhook, ohne öffentliche Erreichbarkeit und selbst dann, wenn ein
+  Haken einmal ausfällt.
+
+  Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen führt,
+  werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht — die Liste der offenen
+  Issues ist gedeckelt, aus dem Fehlen einer Nummer folgt also nichts. Pro Durchgang
+  fragt der Abgleich höchstens 25 Issues nach.
+
+  **Der Abgleich hakt nur ab, er nimmt nie zurück.** Er sieht Zustände, keine Ereignisse:
+  ein offenes Issue kann auch bedeuten, dass das Schließen von Nebula aus fehlgeschlagen
+  ist. Ein symmetrischer Abgleich würde dann eine bewusst erledigte Aufgabe wieder
+  aufmachen. Das Zurücknehmen bleibt dem Webhook vorbehalten, der ein echtes „reopened“
+  sieht.
+
+  Ein gelöschtes Issue ist kein erledigtes — die Aufgabe bleibt stehen.
+
+In beiden Fällen bewirkt ein geschlossenes Issue dasselbe wie ein Haken in der
+Oberfläche: bei einer wiederkehrenden Aufgabe entsteht die nächste Fassung, und der
+Vorgang landet im Projektverlauf (ohne Benutzer — das hat nicht jemand in Nebula getan,
+sondern das Git-System gemeldet).
+
+**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
+`Offen · In Arbeit · Blockiert · Erledigt`, ein Issue nur offen oder geschlossen. Nach
+außen geht deshalb nur die Grenze um „erledigt“; ein Rundlauf verliert *In Arbeit* und
+*Blockiert*. Labels wie `nebula:doing` wären die Alternative, würden aber den
+Issue-Tracker mit Zuständen füllen, die dort niemand pflegt. Die feine Abstufung bleibt
+in Nebula.
+
+Eine echte beidseitige Synchronisation mit Konfliktauflösung gibt es **nicht** — das ist
+der klassische Ort für stillen Datenverlust.
+
+**Kein Widerspruch zu „keine eigenen Git-Operationen“:** Issues laufen über die HTTP-API
+der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`, SSRF-Schutz
+inklusive). Kein Klon, kein Arbeitsverzeichnis. Schreibende Aufrufe folgen dabei
+**keinen Umleitungen** — ein 307 auf eine interne Adresse nähme den Rumpf und den Token
+im Header mit.
+
+### 4.7 Webhooks
+
+Ein Push aktualisiert den Stand sofort, statt bis zum nächsten Durchlauf des Zeitgebers
+zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Der Zeitplan bleibt als
+Rückfalllösung bestehen.
+
+Einzurichten am Repository (Funksymbol im Git-Bereich): Nebula erzeugt URL und
+Geheimnis, eingetragen wird der Haken im Git-System von Hand. Über die API anzulegen
+wäre machbar, verlangte aber Administrationsrechte am Repository — deutlich mehr, als
+Nebula sonst braucht.
+
+Das Geheimnis ist **genau einmal** zu sehen; danach liegt es verschlüsselt in der
+Datenbank, wie die Zugangstoken, und verlässt den Server nicht mehr.
+
+| System | Ausweis | Kopfzeile |
+| --- | --- | --- |
+| GitHub | HMAC-SHA256 über den Rumpf | `X-Hub-Signature-256: sha256=…` |
+| Gitea | dieselbe Rechnung, ohne Präfix | `X-Gitea-Signature` (ältere: `X-Hub-Signature-256`) |
+| GitLab | das Geheimnis im Klartext | `X-Gitlab-Token` |
+
+GitLabs Verfahren ist schwächer: es beweist nur, dass der Absender das Geheimnis kennt,
+nicht dass der Rumpf unverändert ist. Mehr gibt die Plattform nicht her; verglichen wird
+trotzdem zeitkonstant.
+
+Geprüft wird gegen den **rohen** Rumpf — durch `JSON.parse` und `JSON.stringify` gedreht
+käme eine andere Zeichenfolge heraus und die Signatur passte nie.
+
+Was der Endpunkt bewusst **nicht** tut: den Rumpf als Quelle für Inhalte benutzen. Titel,
+Beschreibung und Zustand kommen weiter aus Nebula beziehungsweise beim nächsten Abgleich
+aus der API. Wer das Geheimnis kennt, kann also höchstens eine Aufgabe auf- oder zumachen
+und einen Abgleich auslösen — keine beliebigen Daten einschleusen.
+
+Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler brächte das
+Git-System zum Wiederholen und irgendwann zum Abschalten des Hakens.
+
+Der Endpunkt ist der einzige ohne Anmeldung, der schreibt. Deshalb: Ratenbegrenzung je
+Repository (60/Minute), Deckel auf die Rumpfgröße, und ein unbekanntes Repository
+antwortet wie ein nicht eingerichtetes — mit 404, damit die ID nicht bestätigt wird.
+
 ---
 
 ## 4a. Export, Import und Sicherung
@@ -289,6 +649,75 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 
 ---
 
+## 4b. Benachrichtigungen
+
+Einzurichten unter *Mein Konto → Benachrichtigungen*, pro Konto und beliebig viele Ziele.
+
+### Anlässe
+
+| Anlass | Wann |
+| --- | --- |
+| ⚠️ **Abgleich fehlgeschlagen** | Das Git-System war nicht erreichbar oder hat abgelehnt |
+| 🔴 **CI rot** | Der letzte Lauf auf dem Default-Branch ist fehlgeschlagen |
+| 🏷️ **Neues Release** | Ein neuer Tag oder ein neues Release ist aufgetaucht |
+| 🕸️ **Projekt steht still** | Seit längerem kein Commit — Schwelle einstellbar, Vorgabe 60 Tage |
+
+### Nur bei Änderung
+
+Der entscheidende Punkt: Gemeldet wird **ausschließlich, wenn sich etwas ändert**
+gegenüber dem, worüber zuletzt benachrichtigt wurde. Ein Repository mit abgelaufenem
+Token meldet sich also **einmal**, nicht bei jedem stündlichen Durchlauf. Wird der Fehler
+ein anderer, kommt eine neue Meldung; ist er behoben und tritt später erneut auf, ebenso.
+
+Zwei Feinheiten:
+
+- **Beim allerersten Abgleich** eines Repositories wird kein Release gemeldet — sonst
+  wäre jede bereits vorhandene Version eine „Neuigkeit".
+- Der Merkstand wird auch dann fortgeschrieben, wenn **kein** Ziel eingerichtet ist. Sonst
+  käme beim ersten eingerichteten Ziel die ganze Vergangenheit hinterher.
+
+### Stillstand
+
+Der einzige Anlass, der an keinem Ereignis hängt — es passiert ja gerade nichts. Deshalb
+ein eigener Durchlauf, **höchstens einmal am Tag**, unabhängig vom automatischen Abgleich.
+Hört niemand auf diesen Anlass, läuft die Prüfung gar nicht erst.
+
+Maßstab ist ausschließlich der **letzte Commit** im verknüpften Repository. Das
+Änderungsdatum des Projekts taugt nicht: jeder Abgleich fasst es an und würde den
+Stillstand immer wieder zurücksetzen. Projekte **ohne Repository** bleiben deshalb außen
+vor, ebenso fertige und archivierte.
+
+Gemeldet wird je Projekt einmal. Erneut erst, wenn danach wieder ein Commit kam und es
+seitdem wieder still geworden ist — ein Projekt, das aufwacht und wieder einschläft, meldet
+sich also ein zweites Mal.
+
+Die Schwelle setzt ein Administrator unter *Admin-Einstellungen → Stillstand* (14 Tage bis
+ein Jahr). Eine Änderung wirkt sofort, nicht erst nach 24 Stunden.
+
+### Zustellwege
+
+| Weg | Details |
+| --- | --- |
+| **ntfy** | Vollständige Themen-URL. Titel, Priorität und Symbol als Kopfzeilen; optionales Bearer-Token für geschützte Themen. Läuft auch gegen ein selbst gehostetes ntfy im eigenen Netz. |
+| **Webhook** | JSON per POST mit Anlass, Titel, Text, Projektbezug und Tieflink. Mit hinterlegtem Geheimnis wird der Rumpf per HMAC-SHA256 signiert (`X-Nebula-Signature`), damit der Empfänger die Herkunft prüfen kann. |
+| **E-Mail** | Über SMTP. Steht erst zur Verfügung, wenn `SMTP_HOST` in der `.env` gesetzt ist — sonst ist die Auswahl in der Oberfläche gesperrt und erklärt, warum. |
+
+Jedes Ziel lässt sich einzeln **testen** und **pausieren**; Ergebnis und Zeitpunkt der
+letzten Zustellung stehen an der Karte.
+
+### Absicherung
+
+- Zieladressen sind Benutzereingaben, die der Server abruft — sie laufen deshalb durch
+  denselben **SSRF-Schutz** wie die Git-Verbindungen. Ein ntfy im eigenen Netz bleibt
+  erlaubt, Loopback und Cloud-Metadaten nicht.
+- Redirects werden **nicht verfolgt**: ein Umleitungsziel wäre nicht geprüft.
+- Geheimnisse liegen AES-256-GCM-verschlüsselt und verlassen den Server nie; die
+  Oberfläche zeigt nur einen Hinweis wie `test…mnis`.
+- Eine fehlgeschlagene Zustellung lässt den Abgleich nicht scheitern — der Fehler landet
+  am Ziel, nicht im Sync.
+
+---
+
 ## 5. Oberfläche
 
 - **Dark Glassmorphism**: milchige Glasflächen, driftende Nebel im Hintergrund, feines
@@ -296,10 +725,24 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 - **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.
 
 ---
 
@@ -313,11 +756,18 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 | `Session` | Serverseitige Sitzungen (nur der Token-Hash) |
 | `Credential` | Passkeys inkl. öffentlichem Schlüssel und Signaturzähler |
 | `WebAuthnChallenge` | Kurzlebige, einmalig verwendbare Challenges |
+| `RecoveryCode` | Wiederherstellungscodes für die Zwei-Faktor-Anmeldung (nur der Hash) |
+| `PendingLogin` | Zwischenzustand zwischen Passwort und zweitem Faktor, fünf Minuten gültig |
 | `AppSettings` | Betriebsart und Registrierung (eine Zeile) |
-| `Project` | Projektstammdaten, Status, Fortschritt, Repo-Verknüpfung, Besitzer |
+| `Project` | Projektstammdaten, Status, Fortschritt, Besitzer |
+| `Repository` | Repositories eines Projekts inkl. Abgleichstand (n:1 zu Projekt) |
+| `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) |
 | `GitConnection` | Git-Systeme inkl. verschlüsseltem Token, Besitzer |
-| `RepoSnapshot` | Zwischengespeicherter Repo-Stand (1:1 zu Projekt) |
+| `RepoSnapshot` | Zwischengespeicherter Repo-Stand (1:1 zu Repository) |
 
 `Project.ownerId` und `GitConnection.ownerId` sind bewusst optional: so überleben Daten aus
 der Zeit vor der Benutzerverwaltung die Migration und werden beim Anlegen des ersten Kontos
@@ -346,6 +796,16 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
   `GIT_BLOCK_PRIVATE` und `GIT_ALLOWED_HOSTS`.
 - **Rate-Limiting** für Anmeldung (je IP und je Konto), ausgehende Git-Aufrufe und
   WebAuthn-Optionen.
+- **Sitzungen**: Zufallstoken mit 256 Bit, in der Datenbank nur als SHA-256-Hash — wer die
+  Datenbank liest, kann keine Sitzung übernehmen. Geprüft wird bei jeder Anfrage, Abmelden
+  und Sperren wirken also sofort. Zwei Fristen nach ASVS 3.3.2: **absolut** 30 Tage ab
+  Anmeldung (`SESSION_TTL_DAYS`) und **im Leerlauf** 8 Stunden (`SESSION_IDLE_HOURS`).
+  Ein Passwortwechsel entwertet alle Sitzungen und stellt für das eigene Gerät eine neue
+  aus.
+- **Cookies**: `HttpOnly`, `SameSite=Strict`, `Secure` sobald die App über HTTPS läuft, und
+  dann zusätzlich mit dem Präfix `__Host-`. Der Präfix lässt den Browser selbst erzwingen,
+  dass kein `Domain` gesetzt ist — eine andere Subdomain kann den Cookie damit nicht
+  überschreiben und keine Sitzung unterschieben.
 - Access Tokens verschlüsselt mit **AES-256-GCM**, Schlüssel per **scrypt** aus
   `APP_SECRET` abgeleitet, Chiffrat versioniert (`v1.<iv>.<tag>.<data>`).
 - Tokens werden nie an den Browser gesendet — alle API-Antworten nutzen eine Feldauswahl
@@ -368,8 +828,10 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
 
 ### 6.4 Tests
 
-`npm test` führt die Unit-Tests aus — reine Logik, kein DOM, keine Datenbank, unter einer
+Zwei Ebenen. `npm run test:all` führt beide aus.
-Sekunde:
+
+**`npm test` — Unit-Tests** (Vitest, 56 Stück, unter einer Sekunde, ohne DOM und ohne
+Datenbank):
 
 | Bereich | Was geprüft wird |
 | --- | --- |
@@ -377,11 +839,45 @@ Sekunde:
 | `git/parse` | URL-Zerlegung für https, SSH, verschachtelte GitLab-Gruppen und Oberflächenpfade; Provider-Erkennung; Bildung der Aktivitätskurve |
 | `security/ssrf` | Sperrlisten für Loopback, Link-Local, Metadaten-Endpunkt, CGNAT und Multicast; Formprüfung; die drei Umgebungsschalter |
 | `auth/password` | scrypt-Rundlauf, unterschiedliches Salz, Ablageformat, Verhalten bei kaputten Hashes, Passwortregeln |
+| `tasks` | Berechnung des abgeleiteten Fortschritts, Spaltenreihenfolge |
+| `notify/pending` | Wann eine Benachrichtigung fällig ist: neuer Fehler ja, gleicher Fehler nein; CI-Wechsel nach rot; Release erst ab dem zweiten Abgleich |
+| `notify/stale` | Stillstandsschwelle, keine Zweitmeldung, aber erneute Meldung nach zwischenzeitlicher Aktivität |
+| `validation` | Dass jeder Anlass, den die Oberfläche anbietet, auch vom Schema akzeptiert wird — entstanden aus genau diesem Fehler |
 
-Bewusst ohne Datenbank- und Browsertests: die brauchen Infrastruktur und gehören in eine
+**`npm run test:e2e` — Ende-zu-Ende** (Playwright, 13 Stück, rund 20 Sekunden). Läuft
-CI-Pipeline. Das steht in der [ROADMAP](ROADMAP.md).
+gegen die gebaute Anwendung mit eigener Datenbank auf Port 3111 — also durch Middleware,
+Authentifizierung, Validierung und Datenbank hindurch:
 
-### 6.5 API
+| Datei | Was geprüft wird |
+| --- | --- |
+| `e2e/api.spec.ts` | Einrichtung sperrt sich nach dem ersten Konto · kein Zugriff ohne Anmeldung · fremdes Origin und falscher Content-Type abgewiesen · SSRF geblockt · **Datentrennung zwischen zwei Konten** · Aufgaben-Reihenfolge, abgeleiteter Fortschritt und untergeschobene IDs · Export ohne Geheimnisse, Import je Strategie |
+| `e2e/ui.spec.ts` | Anmelden · Projekt anlegen · Aufgaben anlegen und **per Ziehen verschieben** (inklusive Prüfung nach dem Neuladen) · Volltextsuche · Abmelden sperrt geschützte Seiten wieder |
+
+Zwei Dinge sind bewusst so gebaut:
+
+- **Die Testdatenbank kann nicht die echte sein.** `e2e/global-setup.ts` bricht ab, wenn
+  der Datenbankname nicht `test` enthält — vor dem `TRUNCATE`. Der teuerste denkbare
+  Fehler wäre eine Testreihe, die die Produktivdaten leert.
+- **Playwright startet den Server selbst** (`webServer` in `playwright.config.ts`) mit
+  eigener `DATABASE_URL` und eigenem Port. Eine laufende Instanz auf 3000 stört nicht.
+
+Einmalig vorbereiten:
+
+```bash
+docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_e2e_test"
+```
+
+### 6.5 Fortlaufende Prüfung
+
+`.gitea/workflows/ci.yml` prüft jeden Push und jeden Pull Request: Typen, Unit-Tests,
+Bau und Ende-zu-Ende-Tests gegen einen frischen PostgreSQL-Dienst. Schlägt etwas fehl,
+wird der Playwright-Bericht als Artefakt abgelegt.
+
+Dafür müssen in der Gitea-Instanz Actions aktiviert sein (`app.ini`: `[actions] ENABLED
+= true`) und ein Runner registriert. Die Syntax ist GitHub-kompatibel — für GitHub die
+Datei nach `.github/workflows/` kopieren.
+
+### 6.6 API
 
 Zehn REST-Endpunkte für Projekte, Notizen, Verbindungen, Sync, Repo-Listen und Health.
 Alles, was die Oberfläche kann, ist damit auch scriptbar. Übersicht in der

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
@@ -117,16 +118,19 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `APP_URL` | Öffentliche Adresse — bestimmt die WebAuthn-RP-ID | `http://localhost:3000` |
 | `DATABASE_URL` | PostgreSQL-Verbindung (Prisma) | `postgresql://nebula:nebula@localhost:5432/nebula` |
 | `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
-| `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_TTL_DAYS` | Absolute Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_IDLE_HOURS` | Nach so vielen Stunden ohne Nutzung läuft die Sitzung ab (`0` = aus) | `8` |
 | `PORT` | Port der Anwendung | `3000` |
-| `APP_PORT` | Host-Port-Mapping des App-Containers | `3000` |
+| `APP_PORT` | Host-Port-Mapping des App-Containers | `127.0.0.1:3000` |
 | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |
-| `POSTGRES_PORT` | Host-Port der Datenbank | `5432` |
+| `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` |
 | `GIT_ALLOWED_HOSTS` | Strengster Modus: nur diese Hosts erlauben | leer |
+| `NOTIFY_TIMEOUT_MS` | Timeout beim Zustellen von Benachrichtigungen | `10000` |
+| `SMTP_HOST` … `SMTP_FROM` | SMTP-Zugang; ohne `SMTP_HOST` steht der Weg „E-Mail" nicht zur Verfügung | leer |
 
 `APP_NAME`, `APP_TAGLINE` und `APP_URL` werden **zur Laufzeit** gelesen. Dasselbe
 Docker-Image lässt sich also ohne Neubau umbenennen oder unter einer anderen Adresse
@@ -301,7 +305,10 @@ nebula/
 | `npm test` | Unit-Tests (Vitest), unter einer Sekunde |
 | `npm run test:watch` | Tests im Beobachtungsmodus |
 | `npm run typecheck` | TypeScript prüfen |
-| `npm run docker:db` | Nur die Datenbank starten |
+| `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, 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` |
 
@@ -319,12 +326,15 @@ ausschließlich Daten des angemeldeten Kontos.
 | `GET` | `/api/health` | Status inkl. Datenbankverbindung (Docker-Healthcheck) |
 | `POST` | `/api/auth/setup` | Administratorkonto anlegen (nur beim ersten Mal) |
 | `POST` | `/api/auth/login` `/api/auth/logout` `/api/auth/register` | Anmeldung |
+| `POST` | `/api/auth/mfa` | Zweiter Faktor: Einmalkennwort oder Wiederherstellungscode |
 | `GET` | `/api/auth/session` | Aktuelle Sitzung und Instanzzustand |
 | `POST` | `/api/auth/passkey/{login,register}/{options,verify}` | WebAuthn |
 | `PATCH` | `/api/account/profile` | Eigenes Profil |
 | `POST` | `/api/account/password` | Eigenes Passwort setzen |
 | `GET` `DELETE` | `/api/account/sessions` | Eigene Sitzungen / überall abmelden |
 | `PATCH` `DELETE` | `/api/account/passkeys/:id` | Passkey umbenennen / entfernen |
+| `GET` `POST` `PUT` `DELETE` | `/api/account/totp` | Zwei-Faktor: Zustand, einrichten, aktivieren, abschalten |
+| `POST` | `/api/account/totp/recovery` | Neue Wiederherstellungscodes |
 | `GET` `PATCH` | `/api/admin/settings` | Betriebsart, Registrierung, Abgleich (Admin) |
 | `POST` | `/api/admin/sync/run` | Abgleich sofort anstoßen (Admin) |
 | `GET` `POST` | `/api/admin/users` | Konten auflisten / anlegen (Admin) |
@@ -333,10 +343,26 @@ 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 |
+| `PATCH` `DELETE` | `/api/notifications/:id` | Ziel ändern / entfernen |
+| `POST` | `/api/notifications/:id/test` | Testnachricht senden |
 | `GET` `PATCH` `DELETE` | `/api/projects/:id` | Projekt lesen / ändern / löschen |
-| `POST` | `/api/projects/:id/sync` | Repo-Daten vom Git-System holen |
+| `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 |
+| `POST` | `/api/repositories/:id/sync` | Ein einzelnes Repository abgleichen |
+| `GET` `POST` | `/api/projects/:id/tasks` | Aufgaben des Projekts |
+| `PATCH` | `/api/projects/:id/tasks/reorder` | Neue Reihenfolge nach dem Ziehen |
+| `POST` | `/api/projects/:id/tasks/from-issues` | Offene Issues als Aufgaben übernehmen |
+| `PATCH` `DELETE` | `/api/tasks/:id` | Aufgabe ändern / löschen |
 | `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
 | `PATCH` `DELETE` | `/api/notes/:id` | Notiz ändern / löschen |
 | `GET` `POST` | `/api/connections` | Git-Verbindungen |
@@ -391,7 +417,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,105 +11,98 @@ Was bereits steht, listet [FEATURES.md](FEATURES.md).
 
 ## 1 · Als Nächstes empfohlen
 
-### 1.1 Tests ausbauen: Datenbank und Browser `L`
+### 1.0 Rest aus v1.6.0: persönliche API-Token `M`
 
-Das Fundament steht — 51 Unit-Tests der reinen Logik laufen in unter einer
+Schnellerfassung und die projektübergreifende Aufgabenseite sind mit v1.6.0
-Sekunde. Was fehlt, ist die Schicht darüber:
+ausgeliefert. Offen bleibt der dritte Teil — siehe 1.3. Er gehört sachlich
+dazu: erfassen am Telefon, überblicken an einer Stelle, ansprechen per
+Shortcut.
 
-- **Integrationstests** gegen eine Wegwerf-Datenbank: Datentrennung zwischen
+Bewusst nicht mitgeliefert wurde ein **Index für die übergreifende
-  Konten, Import-Strategien, Backoff des Abgleichs
+Aufgabenabfrage**. `Task` hat kein `ownerId`, die Trennung läuft über
-- **Playwright** für die Wege durch die App: Einrichtung, Anmeldung, Kanban
+`project: { ownerId }`, und `[projectId, status, position]` greift dafür
-- **CI-Pipeline** bei GitHub oder Gitea Actions
+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
-Ich prüfe bislang alles von Hand, inklusive Screenshots. Das trägt nicht
+Migration wert.
-dauerhaft und macht jede weitere Änderung teurer als nötig.
-
-### 1.2 Benachrichtigungen `M`
-
-Bei Sync-Fehlern, roter CI, neuen Releases oder Projekten, die lange
-stillstehen. Kanäle: E-Mail (SMTP), ntfy, generischer Webhook. Zusammen mit
-dem automatischen Abgleich und dem CI-Status ergibt das ein brauchbares
-Frühwarnsystem — die Daten liegen bereits vor.
-
-### 1.3 Aufgaben und Checklisten `M`
-
-Eigene Entität statt Freitext, mit Häkchen und automatisch berechnetem
-Fortschritt. Ersetzt das manuelle Schieben des Reglers. Die Markdown-
-Checklisten in Notizen sind ein Vorgeschmack, aber nicht auswertbar.
 
 ---
 
-## 2 · Danach
+### 1.2 Läuft es noch? `M`
 
-### 2.1 Webhooks statt Polling `M`
+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.
 
-Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
+### 1.3 Persönliche API-Token `M`
-zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
-Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
-erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
 
-### 2.2 Commit-Aktivität als Heatmap `S`
+Derzeit geht die API nur mit Sitzungscookie. Ein Token je Konto würde
-
+`curl`-Aufrufe und Handy-Shortcuts erlauben — Idee aus dem Terminal anlegen,
-Die Sparkline gibt es auf Karte und Projektseite. Eine Heatmap über ein Jahr
+ohne den Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den
-wäre die nächste Ausbaustufe — dafür braucht es allerdings mehr als eine
+Sitzungen.
-Seite Commits, also Paginierung oder die Statistik-Endpunkte.
-
-### 2.3 Kanban mit freier Reihenfolge `M`
-
-Heute folgt die Reihenfolge innerhalb einer Spalte der gewählten Sortierung.
-Frei sortieren hieße, eine Position je Projekt zu speichern.
 
 ---
 
-## 3 · Größere Brocken
+### 1.4 Aufgaben ↔ Issues: was noch fehlt `S`
 
-### 3.1 Mehrere Repositories je Projekt `M`
+Mit v1.7.0 stehen beide Richtungen: „als Issue anlegen“ und der Rückweg über
+Webhooks. Offen geblieben ist Kleinkram:
 
-Frontend und Backend getrennt, aber ein Projekt. Erfordert eine Zwischen­tabelle
+- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
-und Anpassungen in der Anzeige.
+  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.
 
-### 3.2 Zwei-Faktor per TOTP `M`
+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.
 
-Als Alternative zum Passkey — nützlich, wenn die Instanz aus dem Internet
+---
-erreichbar ist und nicht jedes Gerät Passkeys kann.
 
-### 3.3 Passwort-Zurücksetzen per E-Mail `M`
+## 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 |
 | --- | --- | --- |
-| Schnellsuche per `Strg+K` | `S` | Springt direkt zu Projekt oder Aktion |
+| 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 |
-| Aktivitätsverlauf je Projekt | `S` | Wer hat wann was geändert |
+| 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.
@@ -132,6 +125,19 @@ Damit klar ist, was **nicht** kommt und warum:
 | Export, Import und Sicherung | ✓ |
 | **v0.3.0** Markdown, Volltextsuche über Notizen, PR- und Issue-Listen, Testfundament | ✓ |
 | **v0.4.0** Kanban mit Drag & Drop, CI-Status je Branch, Commit-Aktivität | ✓ |
+| **v0.5.0** Aufgabenbrett je Projekt mit sortierbaren Spalten, Fortschritt aus Aufgaben | ✓ |
+| **v0.6.0** Ende-zu-Ende-Tests mit Playwright, CI-Pipeline für Gitea Actions | ✓ |
+| **v0.7.0** Benachrichtigungen über ntfy, Webhook und E-Mail | ✓ |
+| **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:
@@ -59,6 +67,13 @@ services:
       APP_URL: ${APP_URL:-http://localhost:3000}
       SESSION_TTL_DAYS: ${SESSION_TTL_DAYS:-30}
       GIT_API_TIMEOUT_MS: ${GIT_API_TIMEOUT_MS:-15000}
+      NOTIFY_TIMEOUT_MS: ${NOTIFY_TIMEOUT_MS:-10000}
+      SMTP_HOST: ${SMTP_HOST:-}
+      SMTP_PORT: ${SMTP_PORT:-587}
+      SMTP_SECURE: ${SMTP_SECURE:-}
+      SMTP_USER: ${SMTP_USER:-}
+      SMTP_PASSWORD: ${SMTP_PASSWORD:-}
+      SMTP_FROM: ${SMTP_FROM:-}
       GIT_ALLOW_LOOPBACK: ${GIT_ALLOW_LOOPBACK:-false}
       GIT_BLOCK_PRIVATE: ${GIT_BLOCK_PRIVATE:-false}
       GIT_ALLOWED_HOSTS: ${GIT_ALLOWED_HOSTS:-}
@@ -66,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"]
@@ -80,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

@@ -0,0 +1,858 @@
+import { expect, test, type APIRequestContext } from "@playwright/test";
+import { PrismaClient } from "@prisma/client";
+
+/**
+ * Dieselbe Datenbank wie global-setup.ts. Gebraucht fuer den einen Fall, in
+ * dem ein Zustand herzustellen ist, den die API bewusst nicht anbietet.
+ */
+const DATABASE_URL =
+  process.env.E2E_DATABASE_URL ??
+  "postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
+
+/**
+ * Tests ueber HTTP gegen die laufende Anwendung – also durch Middleware,
+ * Authentifizierung, Validierung und Datenbank hindurch. Genau die Dinge,
+ * die Unit-Tests nicht erreichen.
+ *
+ * Die Tests bauen aufeinander auf und laufen in dieser Reihenfolge, weil sie
+ * sich eine Datenbank teilen (siehe playwright.config.ts, workers: 1).
+ */
+
+const ADMIN = { username: "chefin", password: "ein-langes-testpasswort" };
+const ZWEITER = { username: "zweiter", password: "noch-ein-langes-passwort" };
+
+async function login(request: APIRequestContext, user: { username: string; password: string }) {
+  const response = await request.post("/api/auth/login", { data: user });
+  expect(response.ok(), `Anmeldung als ${user.username}`).toBeTruthy();
+}
+
+test.describe.configure({ mode: "serial" });
+
+test("Einrichtung legt das erste Konto an und sperrt sich danach", async ({ request }) => {
+  const response = await request.post("/api/auth/setup", {
+    data: { ...ADMIN, mode: "MULTI_USER" },
+  });
+  expect(response.status()).toBe(200);
+  expect((await response.json()).user.role).toBe("ADMIN");
+
+  // Ein zweiter Aufruf darf kein weiteres Adminkonto erzeugen.
+  const wieder = await request.post("/api/auth/setup", {
+    data: { username: "eindringling", password: "ein-langes-testpasswort" },
+  });
+  expect(wieder.status()).toBe(409);
+});
+
+test("ohne Anmeldung ist nichts zu holen", async ({ playwright }) => {
+  const anonym = await playwright.request.newContext({ baseURL: test.info().project.use.baseURL });
+  for (const pfad of ["/api/projects", "/api/connections", "/api/admin/users"]) {
+    expect((await anonym.get(pfad)).status(), pfad).toBe(401);
+  }
+  await anonym.dispose();
+});
+
+test("Fremdes Origin wird abgewiesen", async ({ request }) => {
+  await login(request, ADMIN);
+  const response = await request.post("/api/projects", {
+    data: { name: "Von woanders" },
+    headers: { Origin: "https://boese.example" },
+  });
+  expect(response.status()).toBe(403);
+});
+
+test("Content-Type wird erzwungen", async ({ request }) => {
+  await login(request, ADMIN);
+  const response = await request.post("/api/projects", {
+    headers: { "Content-Type": "text/plain" },
+    data: JSON.stringify({ name: "Umgehung" }),
+  });
+  expect(response.status()).toBe(415);
+});
+
+test("SSRF: interne Adressen werden geblockt", async ({ request }) => {
+  await login(request, ADMIN);
+  for (const ziel of ["http://127.0.0.1:5432", "http://169.254.169.254", "http://0.0.0.0"]) {
+    const response = await request.post("/api/connections", {
+      data: { name: `ssrf-${ziel}`, provider: "GITEA", baseUrl: ziel },
+    });
+    expect(response.status(), ziel).toBe(422);
+  }
+});
+
+test("Datentrennung zwischen zwei Konten", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const angelegt = await request.post("/api/projects", {
+    data: { name: "Geheimprojekt", status: "IN_DEVELOPMENT" },
+  });
+  expect(angelegt.status()).toBe(201);
+  const projektId = (await angelegt.json()).project.id;
+
+  const aufgabe = await request.post(`/api/projects/${projektId}/tasks`, {
+    data: { title: "Nicht fuer fremde Augen" },
+  });
+  expect(aufgabe.status()).toBe(201);
+  const aufgabenId = (await aufgabe.json()).task.id;
+
+  // Zweites Konto anlegen und in einem eigenen Kontext anmelden.
+  const neu = await request.post("/api/admin/users", {
+    data: { ...ZWEITER, role: "USER" },
+  });
+  expect(neu.status()).toBe(201);
+
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+
+  expect((await (await fremd.get("/api/projects")).json()).projects).toHaveLength(0);
+
+  // Fremde IDs muessen 404 liefern, nicht 403 – sonst waere die Existenz
+  // des Datensatzes bestaetigt.
+  expect((await fremd.get(`/api/projects/${projektId}`)).status()).toBe(404);
+  expect(
+    (await fremd.patch(`/api/projects/${projektId}`, { data: { name: "uebernommen" } })).status(),
+  ).toBe(404);
+  expect((await fremd.delete(`/api/projects/${projektId}`)).status()).toBe(404);
+  expect((await fremd.get(`/api/projects/${projektId}/tasks`)).status()).toBe(404);
+  expect((await fremd.patch(`/api/tasks/${aufgabenId}`, { data: { title: "x" } })).status()).toBe(
+    404,
+  );
+
+  // Adminwege bleiben zu.
+  expect((await fremd.get("/api/admin/users")).status()).toBe(403);
+  expect(
+    (await fremd.patch("/api/admin/settings", { data: { mode: "SINGLE_USER" } })).status(),
+  ).toBe(403);
+
+  // Und das Original ist unveraendert.
+  const danach = await (await request.get(`/api/projects/${projektId}`)).json();
+  expect(danach.project.name).toBe("Geheimprojekt");
+  expect(danach.project.tasks).toHaveLength(1);
+
+  await fremd.dispose();
+});
+
+test("Aufgaben: Reihenfolge, abgeleiteter Fortschritt, fremde IDs", async ({ request }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Aufgabenprojekt" } })).json()
+  ).project;
+
+  const titel = ["eins", "zwei", "drei"];
+  const ids: string[] = [];
+  for (const title of titel) {
+    const response = await request.post(`/api/projects/${projekt.id}/tasks`, {
+      data: { title, status: "TODO" },
+    });
+    ids.push((await response.json()).task.id);
+  }
+
+  // Neue Aufgaben haengen sich hinten an.
+  const angelegt = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(angelegt.map((task: { position: number }) => task.position)).toEqual([0, 1, 2]);
+
+  // Umdrehen.
+  const gedreht = [...ids].reverse();
+  const reorder = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
+    data: { columns: { TODO: gedreht } },
+  });
+  expect(reorder.ok()).toBeTruthy();
+  const nachher = (await (await request.get(`/api/projects/${projekt.id}/tasks`)).json()).tasks;
+  expect(nachher.map((task: { title: string }) => task.title)).toEqual(["drei", "zwei", "eins"]);
+
+  // Eine nach DONE – Fortschritt folgt, sobald eingeschaltet.
+  await request.patch(`/api/projects/${projekt.id}`, { data: { progressFromTasks: true } });
+  await request.patch(`/api/tasks/${ids[0]}`, { data: { status: "DONE" } });
+
+  const mitFortschritt = (
+    await (await request.get(`/api/projects/${projekt.id}`)).json()
+  ).project;
+  expect(mitFortschritt.progress).toBe(33);
+
+  // Eine ID aus einem anderen Projekt darf nicht verschoben werden.
+  const anderes = (
+    await (await request.post("/api/projects", { data: { name: "Anderes" } })).json()
+  ).project;
+  const fremdeAufgabe = (
+    await (
+      await request.post(`/api/projects/${anderes.id}/tasks`, { data: { title: "fremd" } })
+    ).json()
+  ).task;
+
+  const untergeschoben = await request.patch(`/api/projects/${projekt.id}/tasks/reorder`, {
+    data: { columns: { DOING: [fremdeAufgabe.id] } },
+  });
+  const ergebnis = await untergeschoben.json();
+  expect(ergebnis.updated).toBe(0);
+  expect(ergebnis.ignored).toBe(1);
+
+  const unveraendert = (
+    await (await request.get(`/api/projects/${anderes.id}/tasks`)).json()
+  ).tasks[0];
+  expect(unveraendert.status).toBe("TODO");
+});
+
+test("Issues als Aufgaben uebernehmen, ohne Dubletten", async ({ request }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Issue-Projekt" } })).json()
+  ).project;
+
+  // Ohne verknuepftes Repository gibt es nichts zu uebernehmen.
+  const ohneRepo = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
+    data: {},
+  });
+  expect(ohneRepo.status()).toBe(409);
+
+  // Mit Repository, aber ohne geholten Stand ebenfalls nicht – der Server
+  // laedt hier bewusst nichts nach.
+  await request.patch(`/api/projects/${projekt.id}`, {
+    data: { repoUrl: "https://github.com/vercel/swr" },
+  });
+  const ohneStand = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
+    data: {},
+  });
+  expect(ohneStand.status()).toBe(409);
+
+  // Nach einem bestimmten, das es nicht gibt, ist dagegen 404 richtig.
+  const fremdesRepo = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
+    data: { repositoryId: "gibt-es-nicht" },
+  });
+  expect(fremdesRepo.status()).toBe(404);
+});
+
+test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Beim Anlegen setzen die Git-Felder das fuehrende Repository.
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Zwei Teile", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+
+  expect(projekt.repositories).toHaveLength(1);
+  expect(projekt.repositories[0].repoOwner).toBe("vercel");
+  expect(projekt.repositories[0].repoName).toBe("swr");
+
+  // Ein zweites dazu.
+  const zweites = await request.post(`/api/projects/${projekt.id}/repositories`, {
+    data: { label: "Backend", repoUrl: "https://github.com/vercel/next.js" },
+  });
+  expect(zweites.status()).toBe(201);
+  const backendId = (await zweites.json()).repository.id;
+
+  // Dasselbe Repo zweimal ist immer ein Versehen.
+  const doppelt = await request.post(`/api/projects/${projekt.id}/repositories`, {
+    data: { repoUrl: "https://github.com/vercel/next.js" },
+  });
+  expect(doppelt.status()).toBe(409);
+
+  // Halbe Angaben ergeben kein Repository.
+  const leer = await request.post(`/api/projects/${projekt.id}/repositories`, {
+    data: { label: "Nur ein Name" },
+  });
+  expect(leer.status()).toBe(422);
+
+  const geladen = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
+  expect(geladen.repositories).toHaveLength(2);
+  // Das fuehrende steht vorn.
+  expect(geladen.repositories[0].repoName).toBe("swr");
+  expect(geladen.repositories[1].label).toBe("Backend");
+
+  // Der Projekt-PATCH bearbeitet weiterhin nur das fuehrende.
+  await request.patch(`/api/projects/${projekt.id}`, { data: { autoSync: false } });
+  const danach = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
+  expect(danach.repositories[0].autoSync).toBe(false);
+  expect(danach.repositories[1].autoSync).toBe(true);
+
+  // Fremde Konten kommen an kein Repository.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await fremd.get(`/api/projects/${projekt.id}/repositories`)).status()).toBe(404);
+  expect((await fremd.patch(`/api/repositories/${backendId}`, { data: {} })).status()).toBe(404);
+  expect((await fremd.delete(`/api/repositories/${backendId}`)).status()).toBe(404);
+  expect((await fremd.post(`/api/repositories/${backendId}/sync`)).status()).toBe(404);
+  await fremd.dispose();
+
+  // Entfernen laesst das andere stehen.
+  expect((await request.delete(`/api/repositories/${backendId}`)).ok()).toBeTruthy();
+  const zumSchluss = (await (await request.get(`/api/projects/${projekt.id}`)).json()).project;
+  expect(zumSchluss.repositories).toHaveLength(1);
+  expect(zumSchluss.repositories[0].repoName).toBe("swr");
+});
+
+test("Die Anmeldung verraet nicht, welche Konten es gibt", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Ein Konto anlegen und stilllegen.
+  const angelegt = await request.post("/api/admin/users", {
+    data: {
+      username: "stillgelegt",
+      password: "ein-ausreichend-langes-passwort",
+      role: "USER",
+    },
+  });
+  expect(angelegt.status()).toBe(201);
+  const id = (await angelegt.json()).user.id;
+  expect((await request.patch(`/api/admin/users/${id}`, { data: { isActive: false } })).ok())
+    .toBeTruthy();
+
+  const anonym = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+
+  // Falsches Passwort auf dem stillgelegten Konto ...
+  const stillgelegt = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "falsches-passwort-hier" },
+  });
+  // ... und auf einem Konto, das es gar nicht gibt.
+  const erfunden = await anonym.post("/api/auth/login", {
+    data: { username: "gibtesnicht", password: "falsches-passwort-hier" },
+  });
+
+  // Beides muss ununterscheidbar sein – sonst laesst sich durchprobieren,
+  // welche Benutzernamen vergeben sind. Frueher kam hier 403 gegen 401.
+  expect(stillgelegt.status()).toBe(erfunden.status());
+  expect(stillgelegt.status()).toBe(401);
+  expect(await stillgelegt.json()).toEqual(await erfunden.json());
+
+  // Mit dem richtigen Passwort darf die Anwendung dann Klartext reden.
+  const mitPasswort = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "ein-ausreichend-langes-passwort" },
+  });
+  expect(mitPasswort.status()).toBe(403);
+  expect((await mitPasswort.json()).error).toMatch(/deaktiviert/);
+
+  await anonym.dispose();
+  await request.delete(`/api/admin/users/${id}`);
+});
+
+test("Abgleich hakt Aufgaben ab, deren Issue geschlossen wurde", async ({ request }) => {
+  await login(request, ADMIN);
+
+  // Ein oeffentliches Repository mit sicher geschlossenen Issues. Der
+  // Abgleich laeuft anonym gegen die GitHub-API – kein Token noetig.
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Rueckweg", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  const angelegt = await request.post(`/api/projects/${projekt.id}/tasks`, {
+    data: { title: "Haengt an einem geschlossenen Issue" },
+  });
+  const taskId = (await angelegt.json()).task.id;
+
+  /**
+   * Die Verknuepfung direkt in der Datenbank setzen.
+   *
+   * Ueber die API gibt es dafuer keinen Weg, und das ist richtig so: "als
+   * Issue anlegen" wuerde ein neues Issue in einem fremden Repository
+   * erzeugen. Ein Endpunkt nur fuer Tests waere eine Hintertuer im
+   * Produktionscode – dafuer greift der Test lieber selbst zur Datenbank.
+   *
+   * Issue 1 von vercel/swr ist seit Jahren geschlossen.
+   */
+  const prisma = new PrismaClient({
+    datasources: { db: { url: DATABASE_URL } },
+  });
+  try {
+    await prisma.task.update({
+      where: { id: taskId },
+      data: { sourceRepositoryId: repoId, sourceIssue: 1 },
+    });
+  } finally {
+    await prisma.$disconnect();
+  }
+
+  const vorher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const alsAngelegt = vorher.project.tasks.find(
+    (t: { id: string }) => t.id === taskId,
+  );
+  expect(alsAngelegt.sourceIssue).toBe(1);
+  expect(alsAngelegt.status).toBe("TODO");
+
+  // Abgleich anstossen – er fragt den Zustand des Issues nach.
+  const sync = await request.post(`/api/repositories/${repoId}/sync`);
+  const syncBody = await sync.json();
+
+  /**
+   * Dieser Test greift als einziger wirklich nach draussen. Ist GitHub nicht
+   * erreichbar oder das anonyme Rate-Limit ausgeschoepft, sagt er das statt
+   * rot zu werden – ein fremder Dienst darf die Testreihe nicht bestimmen.
+   */
+  if (!sync.ok()) {
+    test.skip(true, `GitHub nicht erreichbar: ${syncBody.message ?? sync.status()}`);
+    return;
+  }
+
+  const nachher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const abgehakt = nachher.project.tasks.find((t: { id: string }) => t.id === taskId);
+  expect(abgehakt.status).toBe("DONE");
+  expect(abgehakt.doneAt).not.toBeNull();
+
+  // Und ein zweiter Lauf aendert nichts mehr – abgehakt bleibt abgehakt,
+  // ohne dass erneut nachgefragt wird.
+  const nochmal = await request.post(`/api/repositories/${repoId}/sync`);
+  expect((await nochmal.json()).message ?? "").not.toMatch(/abgehakt/);
+});
+
+test("Webhook: Signatur entscheidet, sonst passiert nichts", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Hakenprojekt", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  // Ohne eingerichteten Webhook ist der Endpunkt stumm – und zwar mit 404,
+  // damit die ID nicht bestaetigt wird.
+  const ohne = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json" },
+    data: { action: "closed", issue: { number: 1 } },
+  });
+  expect(ohne.status()).toBe(404);
+
+  // Einrichten liefert das Geheimnis genau einmal zurueck.
+  const eingerichtet = await request.post(`/api/repositories/${repoId}/webhook`);
+  expect(eingerichtet.status()).toBe(200);
+  const { secret, url } = await eingerichtet.json();
+  expect(typeof secret).toBe("string");
+  expect(secret.length).toBeGreaterThanOrEqual(64);
+  expect(url).toContain(`/api/webhooks/${repoId}`);
+
+  // Und danach nirgends mehr: weder im Projekt noch am Repository.
+  const geladen = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  expect(JSON.stringify(geladen)).not.toContain(secret);
+  expect(geladen.project.repositories[0].webhookSecret).toBeUndefined();
+
+  // Eine Aufgabe, die an einem Issue haengt – von Hand gesetzt gibt es
+  // nicht, also ueber die Uebernahme aus dem Snapshot. Stattdessen prueft
+  // dieser Test die Grenze selbst: ohne gueltige Signatur passiert nichts.
+  const rumpf = JSON.stringify({ action: "closed", issue: { number: 4242 } });
+
+  const falsch = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": "sha256=00",
+    },
+    data: rumpf,
+  });
+  expect(falsch.status()).toBe(401);
+
+  const gar_keine = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json", "X-GitHub-Event": "issues" },
+    data: rumpf,
+  });
+  expect(gar_keine.status()).toBe(401);
+
+  // Mit richtiger Signatur wird der Aufruf angenommen. Zu Issue 4242 gibt
+  // es keine Aufgabe – erwartet ist also "angenommen, nichts zugeordnet".
+  const { createHmac } = await import("node:crypto");
+  const signatur = createHmac("sha256", secret).update(rumpf, "utf8").digest("hex");
+  const richtig = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(richtig.status()).toBe(200);
+  const antwort = await richtig.json();
+  expect(antwort).toMatchObject({ ok: true, handled: "issue", matched: false });
+
+  // Dieselbe Signatur zu einem anderen Rumpf gilt nicht.
+  const veraendert = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: JSON.stringify({ action: "closed", issue: { number: 9999 } }),
+  });
+  expect(veraendert.status()).toBe(401);
+
+  // Fremde Konten koennen den Haken weder einrichten noch zuruecknehmen.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await fremd.post(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  expect((await fremd.delete(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  await fremd.dispose();
+
+  // Zuruecknehmen schliesst den Endpunkt wieder.
+  expect((await request.delete(`/api/repositories/${repoId}/webhook`)).ok()).toBeTruthy();
+  const danach = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(danach.status()).toBe(404);
+});
+
+test("Brett: Reihenfolge und Mehrfachauswahl", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  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);
+
+  await request.post("/api/connections", {
+    data: {
+      name: "Mit Token",
+      provider: "GITEA",
+      baseUrl: "https://gitea.example.com",
+      token: "streng-geheimes-token",
+    },
+  });
+
+  const roh = await (await request.get("/api/projects/export")).text();
+  expect(roh).not.toContain("streng-geheimes-token");
+  expect(roh).not.toContain("tokenCipher");
+  expect(roh).not.toContain("ownerId");
+
+  const datei = JSON.parse(roh);
+  const vorher = datei.projects.length;
+
+  // Version 2: die Repositories stehen als Liste in der Datei.
+  expect(datei.version).toBe(2);
+  const mitRepo = datei.projects.find((entry: { name: string }) => entry.name === "Zwei Teile");
+  expect(mitRepo.repositories).toHaveLength(1);
+  expect(mitRepo.repositories[0].repoName).toBe("swr");
+
+  // Ueberspringen aendert nichts.
+  const uebersprungen = await request.post("/api/projects/import", {
+    data: { data: datei, strategy: "skip", dryRun: false },
+  });
+  expect((await uebersprungen.json()).summary.skipped).toBe(vorher);
+
+  // Zusaetzlich anlegen verdoppelt.
+  const zusaetzlich = await request.post("/api/projects/import", {
+    data: { data: datei, strategy: "rename", dryRun: false },
+  });
+  expect((await zusaetzlich.json()).summary.renamed).toBe(vorher);
+
+  const jetzt = (await (await request.get("/api/projects")).json()).projects;
+  expect(jetzt).toHaveLength(vorher * 2);
+
+  // Muell wird abgewiesen.
+  const muell = await request.post("/api/projects/import", {
+    data: { data: { irgendwas: true }, strategy: "skip", dryRun: true },
+  });
+  expect(muell.status()).toBe(422);
+});
+
+test("Dateien der Version 1 bleiben lesbar", async ({ request }) => {
+  await login(request, ADMIN);
+
+  // Damals stand genau ein Repository flach am Projekt. Wer eine solche
+  // Sicherung liegen hat, soll sie weiterhin einspielen koennen.
+  const alt = {
+    kind: "nebula.projects",
+    version: 1,
+    projects: [
+      {
+        name: "Aus Version eins",
+        repoUrl: "https://github.com/vercel/swr",
+        repoOwner: "vercel",
+        repoName: "swr",
+        autoSync: false,
+      },
+    ],
+  };
+
+  const gelesen = await request.post("/api/projects/import", {
+    data: { data: alt, strategy: "rename", dryRun: false },
+  });
+  expect(gelesen.ok()).toBeTruthy();
+
+  const projekte = (await (await request.get("/api/projects")).json()).projects;
+  const uebernommen = projekte.find(
+    (entry: { name: string }) => entry.name === "Aus Version eins",
+  );
+  expect(uebernommen.repositories).toHaveLength(1);
+  expect(uebernommen.repositories[0].repoOwner).toBe("vercel");
+  expect(uebernommen.repositories[0].autoSync).toBe(false);
+});

e2e/global-setup.ts

@@ -0,0 +1,62 @@
+import { execFileSync } from "node:child_process";
+import { PrismaClient } from "@prisma/client";
+
+/**
+ * Bereitet die Testdatenbank vor: Schema einspielen und leeren.
+ *
+ * Die Datenbank muss vorher existieren. Anlegen ist bewusst nicht Teil des
+ * Setups – in CI erzeugt sie der Postgres-Dienst, oertlich einmalig:
+ *
+ *   docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_e2e_test"
+ */
+
+const DATABASE_URL =
+  process.env.E2E_DATABASE_URL ??
+  "postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
+
+/**
+ * Reihenfolge egal, weil CASCADE – aber vollstaendig muss sie sein, sonst
+ * schleppen Laeufe Reste mit.
+ */
+const TABLES = [
+  "Task",
+  "Note",
+  "RepoSnapshot",
+  "Project",
+  "Credential",
+  "Session",
+  "WebAuthnChallenge",
+  "GitConnection",
+  "User",
+  "AppSettings",
+];
+
+export default async function globalSetup() {
+  const name = new URL(DATABASE_URL).pathname.replace(/^\//, "");
+
+  // Schutz vor dem teuersten aller Fehler: eine Testreihe, die die echte
+  // Datenbank leert. Der Name muss "test" enthalten, sonst passiert nichts.
+  if (!name.includes("test")) {
+    throw new Error(
+      `Die Testdatenbank heisst "${name}" und enthaelt nicht "test". ` +
+        "Aus Sicherheitsgruenden abgebrochen – E2E_DATABASE_URL pruefen.",
+    );
+  }
+
+  console.log(`[e2e] Datenbank: ${name}`);
+
+  execFileSync("npx", ["prisma", "migrate", "deploy"], {
+    env: { ...process.env, DATABASE_URL },
+    stdio: "pipe",
+    shell: process.platform === "win32",
+  });
+
+  const prisma = new PrismaClient({ datasources: { db: { url: DATABASE_URL } } });
+  try {
+    const list = TABLES.map((table) => `"${table}"`).join(", ");
+    await prisma.$executeRawUnsafe(`TRUNCATE TABLE ${list} RESTART IDENTITY CASCADE`);
+    console.log("[e2e] Datenbank geleert.");
+  } finally {
+    await prisma.$disconnect();
+  }
+}

e2e/ui.spec.ts

@@ -0,0 +1,322 @@
+import { expect, test } from "@playwright/test";
+
+/**
+ * Ein Weg durch die Oberflaeche, wie ihn ein Mensch geht: anmelden, Projekt
+ * anlegen, Aufgaben verwalten. Keine Vollabdeckung – die Wege, die kaputt
+ * gehen duerfen, ohne dass es jemand merkt.
+ *
+ * Setzt voraus, dass api.spec.ts das Konto bereits angelegt hat; laeuft
+ * alphabetisch danach.
+ */
+
+const KONTO = { username: "chefin", password: "ein-langes-testpasswort" };
+
+test.describe.configure({ mode: "serial" });
+
+test.beforeEach(async ({ page }) => {
+  await page.goto("/login");
+  await page.fill("#login-username", KONTO.username);
+  await page.fill("#login-password", KONTO.password);
+  await page.click('button[type="submit"]');
+  await expect(page.getByText("Vibe Coding Kontrollzentrum")).toBeVisible();
+});
+
+test("Dashboard zeigt Kennzahlen und Projekte", async ({ page }) => {
+  await expect(page.getByRole("heading", { name: /Deine Projekte/ })).toBeVisible();
+  await expect(page.getByText("Projekte", { exact: false }).first()).toBeVisible();
+  // Keine unbeabsichtigten Fehler in der Konsole.
+  expect(page.url()).toContain("/");
+});
+
+test("Projekt anlegen und wiederfinden", async ({ page }) => {
+  await page.getByRole("button", { name: /Neues Projekt/ }).click();
+  await expect(page.getByRole("dialog")).toBeVisible();
+
+  await page.fill("#project-name", "Oberflaechentest");
+  await page.fill("#project-summary", "Von Playwright angelegt.");
+  await page.getByRole("button", { name: "Projekt anlegen" }).click();
+
+  await expect(page.getByRole("dialog")).toBeHidden();
+  await expect(page.getByText("Oberflaechentest")).toBeVisible();
+});
+
+test("Aufgaben anlegen und per Ziehen verschieben", async ({ page }) => {
+  await page.getByRole("link", { name: /Projekt Oberflaechentest/ }).click();
+  await expect(page.getByRole("heading", { name: "Oberflaechentest" })).toBeVisible();
+
+  // Zwei Aufgaben ueber den Dialog anlegen.
+  for (const titel of ["Erste Aufgabe", "Zweite Aufgabe"]) {
+    await page.getByRole("button", { name: "Aufgabe", exact: true }).click();
+    await expect(page.getByRole("dialog")).toBeVisible();
+    await page.fill("#task-title", titel);
+    await page.getByRole("button", { name: "Anlegen" }).click();
+    await expect(page.getByRole("dialog")).toBeHidden();
+  }
+
+  const offen = page.locator('[data-task-column="TODO"]');
+  const inArbeit = page.locator('[data-task-column="DOING"]');
+  await expect(offen.getByText("Erste Aufgabe")).toBeVisible();
+  await expect(offen.getByText("Zweite Aufgabe")).toBeVisible();
+
+  // Erste Aufgabe nach "In Arbeit" ziehen.
+  const griff = offen.locator('button[aria-label$="verschieben"]').first();
+  const von = await griff.boundingBox();
+  const nach = await inArbeit.boundingBox();
+  expect(von && nach).toBeTruthy();
+
+  await page.mouse.move(von!.x + von!.width / 2, von!.y + von!.height / 2);
+  await page.mouse.down();
+  // Erst ueber die Aktivierungsschwelle des Sensors (5 Pixel) hinaus.
+  await page.mouse.move(von!.x + 30, von!.y + 10, { steps: 6 });
+  await page.mouse.move(nach!.x + nach!.width / 2, nach!.y + 60, { steps: 20 });
+  // 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();
+  await expect(
+    page.locator('[data-task-column="DOING"]').getByText("Erste Aufgabe"),
+  ).toBeVisible();
+});
+
+test("Volltextsuche findet Notizen", async ({ page }) => {
+  await page.getByRole("link", { name: /Projekt Oberflaechentest/ }).click();
+  await page.getByRole("button", { name: "Notiz", exact: true }).click();
+
+  await page.getByPlaceholder(/Gedanken/).fill("Suchbegriff Zaunkoenig steht hier.");
+  await page.getByRole("button", { name: "Speichern" }).click();
+  await expect(page.getByText("Zaunkoenig", { exact: false })).toBeVisible();
+
+  // exact, sonst trifft es auch "Zurueck zum Dashboard".
+  await page.getByRole("link", { name: "Dashboard", exact: true }).click();
+  await page.getByPlaceholder(/durchsuchen/).fill("Zaunkoenig");
+
+  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();
+
+  // Ohne Eingabe stehen Projekte und Bereiche bereit.
+  await expect(page.getByRole("dialog").getByText("Oberflaechentest")).toBeVisible();
+
+  await page.getByPlaceholder(/Projekt, Notiz oder Bereich/).fill("Zaunkoenig");
+  await expect(page.getByRole("dialog").getByText(/in Oberflaechentest/)).toBeVisible();
+
+  // Enter springt zum ersten Treffer.
+  await page.keyboard.press("Enter");
+  await expect(page.getByRole("heading", { name: "Oberflaechentest" })).toBeVisible();
+
+  // Escape schliesst wieder.
+  await page.keyboard.press("Control+k");
+  await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  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();
+  await expect(page).toHaveURL(/\/login/);
+
+  // Und die geschuetzte Seite ist wieder zu.
+  await page.goto("/");
+  await expect(page).toHaveURL(/\/login/);
+});

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.1.0",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "nebula",
-      "version": "0.1.0",
+      "version": "1.2.0",
       "hasInstallScript": true,
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",
@@ -17,6 +17,8 @@
         "@simplewebauthn/server": "^13.3.2",
         "lucide-react": "^0.511.0",
         "next": "^15.3.3",
+        "nodemailer": "^9.0.3",
+        "qrcode": "^1.5.4",
         "react": "^19.1.0",
         "react-dom": "^19.1.0",
         "react-markdown": "^10.1.0",
@@ -25,10 +27,15 @@
         "zod": "^3.25.28"
       },
       "devDependencies": {
+        "@playwright/test": "^1.62.0",
         "@tailwindcss/postcss": "^4.1.7",
         "@types/node": "^22.15.21",
+        "@types/nodemailer": "^8.0.1",
+        "@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",
@@ -1513,6 +1520,22 @@
         "node": ">=20.0.0"
       }
     },
+    "node_modules/@playwright/test": {
+      "version": "1.62.0",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.62.0.tgz",
+      "integrity": "sha512-9zOJ6ZQRAena31MpOH9VSzIz8Ou3YJ/wtY/eQm5T2uhfhG7/U3COrMS8xOtUrZrp9OgdmzEnIYODye3nY1VqzA==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.62.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/@prisma/client": {
       "version": "6.19.3",
       "resolved": "https://registry.npmjs.org/@prisma/client/-/client-6.19.3.tgz",
@@ -2302,6 +2325,26 @@
         "undici-types": "~6.21.0"
       }
     },
+    "node_modules/@types/nodemailer": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/@types/nodemailer/-/nodemailer-8.0.1.tgz",
+      "integrity": "sha512-PxpaInm8V1JQDd4j0ds5HfvWQk8JupS1C0Picb96QJsrrRDjBH+DlK7L4ZdNSqNULhiZRQHc40nLVShaGxXAMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/qrcode": {
+      "version": "1.5.6",
+      "resolved": "https://registry.npmjs.org/@types/qrcode/-/qrcode-1.5.6.tgz",
+      "integrity": "sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
     "node_modules/@types/react": {
       "version": "19.2.17",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.17.tgz",
@@ -2446,6 +2489,30 @@
         "url": "https://opencollective.com/vitest"
       }
     },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/asn1js": {
       "version": "3.0.10",
       "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
@@ -2470,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",
@@ -2509,6 +2586,28 @@
         }
       }
     },
+    "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",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/caniuse-lite": {
       "version": "1.0.30001806",
       "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001806.tgz",
@@ -2621,6 +2720,35 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
+    "node_modules/cliui": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz",
+      "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^6.2.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
     "node_modules/comma-separated-tokens": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
@@ -2678,6 +2806,15 @@
         }
       }
     },
+    "node_modules/decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/decode-named-character-reference": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
@@ -2747,11 +2884,17 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/dijkstrajs": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/dijkstrajs/-/dijkstrajs-1.0.3.tgz",
+      "integrity": "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==",
+      "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"
@@ -2771,6 +2914,12 @@
         "fast-check": "^3.23.1"
       }
     },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
     "node_modules/empathic": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/empathic/-/empathic-2.0.0.tgz",
@@ -2940,6 +3089,19 @@
         }
       }
     },
+    "node_modules/find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2955,6 +3117,15 @@
         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
       }
     },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
     "node_modules/giget": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/giget/-/giget-2.0.0.tgz",
@@ -3085,6 +3256,15 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-hexadecimal": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
@@ -3390,6 +3570,18 @@
         "url": "https://opencollective.com/parcel"
       }
     },
+    "node_modules/locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/longest-streak": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
@@ -4373,6 +4565,15 @@
       "devOptional": true,
       "license": "MIT"
     },
+    "node_modules/nodemailer": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-9.0.3.tgz",
+      "integrity": "sha512-n+YP+NKwR5zRWa60k3GiQ6Q3B4KXCoAw40dAKeCtYn020iNN74aWK2liXIC3ZEATeGql7we3tE3t8QwhY0eskw==",
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/nypm": {
       "version": "0.6.8",
       "resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.8.tgz",
@@ -4419,6 +4620,42 @@
       "devOptional": true,
       "license": "MIT"
     },
+    "node_modules/p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "license": "MIT",
+      "dependencies": {
+        "p-try": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/parse-entities": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
@@ -4444,6 +4681,15 @@
       "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
       "license": "MIT"
     },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/pathe": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
@@ -4489,6 +4735,61 @@
         "pathe": "^2.0.3"
       }
     },
+    "node_modules/playwright": {
+      "version": "1.62.0",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.62.0.tgz",
+      "integrity": "sha512-Z14dG305dgaLu6foB1TXQagFiW8JfSUIUaUuPaKQ6NtBPKF1P/qXcqfh6c6K/icPqdy37JmjbiBXf6JNg6Sylw==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.62.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.62.0",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.62.0.tgz",
+      "integrity": "sha512-nsNRyq0r2zsG8AcRHWknc9QRA5XCueC7gWMrs+Gx2tlZn9hcl8zudfh00lhJPY1DE7NmZ6bDsT9g2yey8mXljA==",
+      "devOptional": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/playwright/node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/pngjs": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-5.0.0.tgz",
+      "integrity": "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
     "node_modules/postcss": {
       "version": "8.5.23",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.23.tgz",
@@ -4589,6 +4890,23 @@
         "node": ">=16.0.0"
       }
     },
+    "node_modules/qrcode": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz",
+      "integrity": "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg==",
+      "license": "MIT",
+      "dependencies": {
+        "dijkstrajs": "^1.0.1",
+        "pngjs": "^5.0.0",
+        "yargs": "^15.3.1"
+      },
+      "bin": {
+        "qrcode": "bin/qrcode"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
     "node_modules/rc9": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/rc9/-/rc9-2.1.2.tgz",
@@ -4748,6 +5066,21 @@
         "url": "https://opencollective.com/unified"
       }
     },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "license": "ISC"
+    },
     "node_modules/rolldown": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.5.tgz",
@@ -4801,6 +5134,12 @@
         "node": ">=10"
       }
     },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
     "node_modules/sharp": {
       "version": "0.34.5",
       "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz",
@@ -4886,6 +5225,20 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/stringify-entities": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
@@ -4900,6 +5253,18 @@
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/style-to-js": {
       "version": "1.1.21",
       "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
@@ -5373,6 +5738,12 @@
         }
       }
     },
+    "node_modules/which-module": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz",
+      "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==",
+      "license": "ISC"
+    },
     "node_modules/why-is-node-running": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
@@ -5390,6 +5761,61 @@
         "node": ">=8"
       }
     },
+    "node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==",
+      "license": "ISC"
+    },
+    "node_modules/yargs": {
+      "version": "15.4.1",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz",
+      "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^6.0.0",
+        "decamelize": "^1.2.0",
+        "find-up": "^4.1.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^4.2.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^18.1.2"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "18.1.3",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz",
+      "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
+      "license": "ISC",
+      "dependencies": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/zod": {
       "version": "3.25.76",
       "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nebula",
-  "version": "0.5.0",
+  "version": "1.9.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",
@@ -25,10 +25,10 @@
     "setup": "node scripts/setup.mjs",
     "postinstall": "prisma generate",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
-  },
+    "test:e2e": "npm run build && playwright test",
-  "prisma": {
+    "test:e2e:ui": "playwright test --ui",
-    "seed": "tsx prisma/seed.ts"
+    "test:all": "npm test && npm run test:e2e"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -39,6 +39,8 @@
     "@simplewebauthn/server": "^13.3.2",
     "lucide-react": "^0.511.0",
     "next": "^15.3.3",
+    "nodemailer": "^9.0.3",
+    "qrcode": "^1.5.4",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-markdown": "^10.1.0",
@@ -47,10 +49,15 @@
     "zod": "^3.25.28"
   },
   "devDependencies": {
+    "@playwright/test": "^1.62.0",
     "@tailwindcss/postcss": "^4.1.7",
     "@types/node": "^22.15.21",
+    "@types/nodemailer": "^8.0.1",
+    "@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",

playwright.config.ts

@@ -0,0 +1,63 @@
+import { defineConfig } from "@playwright/test";
+
+/**
+ * Ende-zu-Ende-Tests gegen die echte Anwendung.
+ *
+ * Playwright startet den Produktionsserver selbst und richtet ihn auf eine
+ * eigene Datenbank. Der Port ist bewusst ein anderer als 3000 und 3100,
+ * damit eine laufende Instanz nicht stoert.
+ *
+ * Voraussetzung: ein Bau (`npm run build`) und eine leere Datenbank, deren
+ * Name "test" enthaelt – siehe global-setup.ts. Beides erledigt
+ * `npm run test:e2e`.
+ */
+
+const PORT = Number(process.env.E2E_PORT ?? 3111);
+const BASE_URL = `http://localhost:${PORT}`;
+
+const DATABASE_URL =
+  process.env.E2E_DATABASE_URL ??
+  "postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
+
+export default defineConfig({
+  testDir: "./e2e",
+  // Die Tests teilen sich eine Datenbank, deshalb nacheinander.
+  fullyParallel: false,
+  workers: 1,
+  forbidOnly: Boolean(process.env.CI),
+  retries: process.env.CI ? 1 : 0,
+  reporter: process.env.CI ? [["list"], ["html", { open: "never" }]] : [["list"]],
+  timeout: 60_000,
+  expect: { timeout: 10_000 },
+
+  globalSetup: "./e2e/global-setup.ts",
+
+  use: {
+    baseURL: BASE_URL,
+    locale: "de-DE",
+    timezoneId: "Europe/Berlin",
+    trace: "retain-on-failure",
+    screenshot: "only-on-failure",
+    // Oertlich der installierte Chrome, damit kein Browser geladen werden
+    // muss. In CI gibt es keinen – dort das mitgelieferte Chromium
+    // (siehe "playwright install chromium" im Arbeitsablauf).
+    ...(process.env.CI ? {} : { channel: "chrome" as const }),
+  },
+
+  webServer: {
+    command: "npm start",
+    url: `${BASE_URL}/api/health`,
+    reuseExistingServer: false,
+    timeout: 120_000,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      DATABASE_URL,
+      PORT: String(PORT),
+      APP_URL: BASE_URL,
+      NODE_ENV: "production",
+      // Fester Schluessel, damit Laeufe vergleichbar bleiben.
+      APP_SECRET: "e2e-test-secret-nur-fuer-die-testlaeufe-1234567890",
+    },
+  },
+});

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/20260726140000_notifications/migration.sql

@@ -0,0 +1,39 @@
+-- CreateEnum
+CREATE TYPE "NotificationChannel" AS ENUM ('WEBHOOK', 'NTFY', 'EMAIL');
+
+-- CreateEnum
+CREATE TYPE "NotificationEvent" AS ENUM ('SYNC_FAILED', 'CI_FAILED', 'NEW_RELEASE');
+
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN     "notifiedCiState" TEXT,
+ADD COLUMN     "notifiedRelease" TEXT,
+ADD COLUMN     "notifiedSyncError" TEXT;
+
+-- CreateTable
+CREATE TABLE "NotificationTarget" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "channel" "NotificationChannel" NOT NULL,
+    "target" TEXT NOT NULL,
+    "secretCipher" TEXT,
+    "secretHint" TEXT,
+    "events" "NotificationEvent"[] DEFAULT ARRAY[]::"NotificationEvent"[],
+    "isActive" BOOLEAN NOT NULL DEFAULT true,
+    "lastSentAt" TIMESTAMP(3),
+    "lastOk" BOOLEAN,
+    "lastMessage" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "NotificationTarget_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "NotificationTarget_userId_idx" ON "NotificationTarget"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "NotificationTarget_userId_name_key" ON "NotificationTarget"("userId", "name");
+
+-- AddForeignKey
+ALTER TABLE "NotificationTarget" ADD CONSTRAINT "NotificationTarget_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20260726160000_stale_projects/migration.sql

@@ -0,0 +1,9 @@
+-- AlterEnum
+ALTER TYPE "NotificationEvent" ADD VALUE 'PROJECT_STALE';
+
+-- AlterTable
+ALTER TABLE "AppSettings" ADD COLUMN     "lastStaleCheckAt" TIMESTAMP(3),
+ADD COLUMN     "staleAfterDays" INTEGER NOT NULL DEFAULT 60;
+
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN     "notifiedStaleAt" TIMESTAMP(3);

prisma/migrations/20260726180000_task_source_issue/migration.sql

@@ -0,0 +1,6 @@
+-- AlterTable
+ALTER TABLE "Task" ADD COLUMN     "sourceIssue" INTEGER,
+ADD COLUMN     "sourceUrl" TEXT;
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Task_projectId_sourceIssue_key" ON "Task"("projectId", "sourceIssue");

prisma/migrations/20260726210000_activity/migration.sql

@@ -0,0 +1,24 @@
+-- CreateEnum
+CREATE TYPE "ActivityKind" AS ENUM ('PROJECT_CREATED', 'PROJECT_UPDATED', 'STATUS_CHANGED', 'NOTE_ADDED', 'NOTE_UPDATED', 'NOTE_DELETED', 'TASK_ADDED', 'TASK_MOVED', 'TASK_DELETED', 'TASKS_IMPORTED', 'REPO_LINKED', 'REPO_COMMITS', 'SYNC_FAILED');
+
+-- CreateTable
+CREATE TABLE "Activity" (
+    "id" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "userId" TEXT,
+    "kind" "ActivityKind" NOT NULL,
+    "summary" TEXT NOT NULL,
+    "meta" JSONB,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Activity_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "Activity_projectId_createdAt_idx" ON "Activity"("projectId", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "Activity" ADD CONSTRAINT "Activity_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Activity" ADD CONSTRAINT "Activity_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE SET NULL ON UPDATE CASCADE;

prisma/migrations/20260726220000_totp/migration.sql

@@ -0,0 +1,47 @@
+-- AlterTable
+ALTER TABLE "User" ADD COLUMN     "totpEnabledAt" TIMESTAMP(3),
+ADD COLUMN     "totpSecretCipher" TEXT;
+
+-- CreateTable
+CREATE TABLE "RecoveryCode" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "codeHash" TEXT NOT NULL,
+    "usedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "RecoveryCode_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "PendingLogin" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "tokenHash" TEXT NOT NULL,
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "PendingLogin_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "RecoveryCode_codeHash_key" ON "RecoveryCode"("codeHash");
+
+-- CreateIndex
+CREATE INDEX "RecoveryCode_userId_idx" ON "RecoveryCode"("userId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "PendingLogin_tokenHash_key" ON "PendingLogin"("tokenHash");
+
+-- CreateIndex
+CREATE INDEX "PendingLogin_userId_idx" ON "PendingLogin"("userId");
+
+-- CreateIndex
+CREATE INDEX "PendingLogin_expiresAt_idx" ON "PendingLogin"("expiresAt");
+
+-- AddForeignKey
+ALTER TABLE "RecoveryCode" ADD CONSTRAINT "RecoveryCode_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "PendingLogin" ADD CONSTRAINT "PendingLogin_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20260726230000_repositories/migration.sql

@@ -0,0 +1,113 @@
+-- Mehrere Repositories je Projekt.
+--
+-- Die Git-Felder wandern vom Projekt in eine eigene Tabelle. Bestehende
+-- Projekte bekommen daraus genau ein Repository, damit nichts verlorengeht;
+-- der Snapshot haengt danach am Repository statt am Projekt.
+--
+-- Von Hand geschrieben: prisma migrate diff wuerde die Spalten am Projekt
+-- ersatzlos loeschen und die Snapshots gleich mit.
+
+-- ── 1. Neue Tabelle ─────────────────────────────────────────
+CREATE TABLE "Repository" (
+    "id" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "label" TEXT,
+    "repoUrl" TEXT,
+    "repoOwner" TEXT,
+    "repoName" TEXT,
+    "defaultBranch" TEXT,
+    "connectionId" TEXT,
+    "position" INTEGER NOT NULL DEFAULT 0,
+    "lastSyncedAt" TIMESTAMP(3),
+    "syncError" TEXT,
+    "autoSync" BOOLEAN NOT NULL DEFAULT true,
+    "syncFailureCount" INTEGER NOT NULL DEFAULT 0,
+    "notifiedSyncError" TEXT,
+    "notifiedCiState" TEXT,
+    "notifiedRelease" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "Repository_pkey" PRIMARY KEY ("id")
+);
+
+CREATE INDEX "Repository_projectId_position_idx" ON "Repository"("projectId", "position");
+CREATE INDEX "Repository_connectionId_idx" ON "Repository"("connectionId");
+
+ALTER TABLE "Repository" ADD CONSTRAINT "Repository_projectId_fkey"
+    FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Repository" ADD CONSTRAINT "Repository_connectionId_fkey"
+    FOREIGN KEY ("connectionId") REFERENCES "GitConnection"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- ── 2. Bestand uebernehmen ──────────────────────────────────
+-- Nur Projekte, an denen wirklich etwas haengt. Ein Projekt, das bloss eine
+-- Verbindung ausgewaehlt hatte, ohne je ein Repo zu nennen, braucht keine
+-- leere Zeile.
+INSERT INTO "Repository" (
+    "id", "projectId", "repoUrl", "repoOwner", "repoName", "defaultBranch",
+    "connectionId", "position", "lastSyncedAt", "syncError", "autoSync",
+    "syncFailureCount", "notifiedSyncError", "notifiedCiState", "notifiedRelease",
+    "createdAt", "updatedAt"
+)
+SELECT
+    gen_random_uuid()::text, "id", "repoUrl", "repoOwner", "repoName", "defaultBranch",
+    "connectionId", 0, "lastSyncedAt", "syncError", "autoSync",
+    "syncFailureCount", "notifiedSyncError", "notifiedCiState", "notifiedRelease",
+    "createdAt", CURRENT_TIMESTAMP
+FROM "Project"
+WHERE "repoUrl" IS NOT NULL
+   OR ("repoOwner" IS NOT NULL AND "repoName" IS NOT NULL);
+
+-- ── 3. Snapshots umhaengen ──────────────────────────────────
+ALTER TABLE "RepoSnapshot" ADD COLUMN "repositoryId" TEXT;
+
+UPDATE "RepoSnapshot" AS s
+SET "repositoryId" = r."id"
+FROM "Repository" AS r
+WHERE r."projectId" = s."projectId";
+
+-- Ein Snapshot ohne zugehoeriges Repository kann nur entstanden sein, wenn
+-- jemand die Repo-Angaben nachtraeglich geleert hat. Er ist ohnehin nicht
+-- mehr zuzuordnen und beim naechsten Abgleich neu geholt.
+DELETE FROM "RepoSnapshot" WHERE "repositoryId" IS NULL;
+
+ALTER TABLE "RepoSnapshot" ALTER COLUMN "repositoryId" SET NOT NULL;
+ALTER TABLE "RepoSnapshot" DROP CONSTRAINT "RepoSnapshot_projectId_fkey";
+DROP INDEX "RepoSnapshot_projectId_key";
+ALTER TABLE "RepoSnapshot" DROP COLUMN "projectId";
+
+CREATE UNIQUE INDEX "RepoSnapshot_repositoryId_key" ON "RepoSnapshot"("repositoryId");
+ALTER TABLE "RepoSnapshot" ADD CONSTRAINT "RepoSnapshot_repositoryId_fkey"
+    FOREIGN KEY ("repositoryId") REFERENCES "Repository"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- ── 4. Herkunft uebernommener Aufgaben ──────────────────────
+-- Bisher war die Issue-Nummer je Projekt eindeutig. Mit mehreren Repos
+-- reicht das nicht mehr: Frontend und Backend haben beide ein Issue 5.
+ALTER TABLE "Task" ADD COLUMN "sourceRepositoryId" TEXT;
+
+UPDATE "Task" AS t
+SET "sourceRepositoryId" = r."id"
+FROM "Repository" AS r
+WHERE r."projectId" = t."projectId" AND t."sourceIssue" IS NOT NULL;
+
+DROP INDEX "Task_projectId_sourceIssue_key";
+CREATE UNIQUE INDEX "Task_projectId_sourceRepositoryId_sourceIssue_key"
+    ON "Task"("projectId", "sourceRepositoryId", "sourceIssue");
+
+-- ── 5. Projekt aufraeumen ───────────────────────────────────
+ALTER TABLE "Project" DROP CONSTRAINT "Project_connectionId_fkey";
+DROP INDEX "Project_connectionId_idx";
+
+ALTER TABLE "Project"
+    DROP COLUMN "repoUrl",
+    DROP COLUMN "repoOwner",
+    DROP COLUMN "repoName",
+    DROP COLUMN "defaultBranch",
+    DROP COLUMN "connectionId",
+    DROP COLUMN "lastSyncedAt",
+    DROP COLUMN "syncError",
+    DROP COLUMN "autoSync",
+    DROP COLUMN "syncFailureCount",
+    DROP COLUMN "notifiedSyncError",
+    DROP COLUMN "notifiedCiState",
+    DROP COLUMN "notifiedRelease";

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

@@ -33,6 +33,54 @@ enum GitProvider {
   GITEA
 }
 
+/// Zustellwege fuer Benachrichtigungen.
+enum NotificationChannel {
+  WEBHOOK
+  NTFY
+  EMAIL
+}
+
+/// Anlaesse, ueber die benachrichtigt werden kann.
+enum NotificationEvent {
+  /// Ein Abgleich mit dem Git-System ist fehlgeschlagen.
+  SYNC_FAILED
+  /// Der letzte CI-Lauf auf dem Default-Branch ist rot.
+  CI_FAILED
+  /// Im Repository ist ein neuer Tag oder ein neues Release aufgetaucht.
+  NEW_RELEASE
+  /// Seit laengerem kein Commit mehr – der sanfte Stups.
+  PROJECT_STALE
+}
+
+/// Was im Verlauf eines Projekts festgehalten wird. Bewusst grob: der
+/// Verlauf soll erzaehlen, was passiert ist, und nicht jede Feldaenderung
+/// mitschreiben.
+enum ActivityKind {
+  PROJECT_CREATED
+  PROJECT_UPDATED
+  STATUS_CHANGED
+  NOTE_ADDED
+  NOTE_UPDATED
+  NOTE_DELETED
+  TASK_ADDED
+  TASK_MOVED
+  TASK_DELETED
+  TASKS_IMPORTED
+  REPO_LINKED
+  REPO_COMMITS
+  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
@@ -74,10 +122,26 @@ model User {
   failedLoginCount Int       @default(0)
   lockedUntil      DateTime?
 
+  /// TOTP-Schluessel, AES-256-GCM-verschluesselt (siehe src/lib/crypto.ts).
+  /// Hinterlegt heisst noch nicht scharf: erst ein bestaetigter Code setzt
+  /// totpEnabledAt. Bis dahin darf die Anmeldung nicht danach fragen, sonst
+  /// 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[]
   projects    Project[]
   connections GitConnection[]
+  notificationTargets NotificationTarget[]
+  activities    Activity[]
+  recoveryCodes RecoveryCode[]
+  pendingLogins PendingLogin[]
+  templates     ProjectTemplate[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -122,6 +186,45 @@ model Credential {
   @@index([userId])
 }
 
+/// Ein Wiederherstellungscode fuer den Fall, dass der Authenticator weg ist.
+/// Jeder Code gilt genau einmal.
+model RecoveryCode {
+  id     String @id @default(cuid())
+  userId String
+  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  /// SHA-256 des Codes. Kein langsames Verfahren wie bei Passwoertern: die
+  /// Codes sind zufaellig erzeugt und lang genug, dass Raten aussichtslos
+  /// ist – und bei einer Anmeldung waeren sonst zehn teure Vergleiche noetig.
+  codeHash String @unique
+
+  usedAt    DateTime?
+  createdAt DateTime  @default(now())
+
+  @@index([userId])
+}
+
+/// Zwischenzustand einer Anmeldung: Passwort stimmt, der zweite Faktor fehlt
+/// noch. Bewusst eine eigene Zeile und keine halbfertige Sitzung – so kann
+/// aus diesem Zustand nichts entstehen, was einer Anmeldung aehnelt.
+model PendingLogin {
+  id     String @id @default(cuid())
+  userId String
+  user   User   @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  /// Wie bei der Sitzung liegt nur der SHA-256-Hash des Cookie-Tokens hier.
+  tokenHash String @unique
+  /// Fehlversuche. Nach zu vielen wird der Vorgang verworfen, damit die
+  /// sechs Stellen nicht in Ruhe durchprobiert werden koennen.
+  attempts  Int    @default(0)
+
+  expiresAt DateTime
+  createdAt DateTime @default(now())
+
+  @@index([userId])
+  @@index([expiresAt])
+}
+
 /// Kurzlebige WebAuthn-Challenge. Wird nach Gebrauch geloescht, damit sie
 /// kein zweites Mal verwendet werden kann.
 model WebAuthnChallenge {
@@ -163,6 +266,12 @@ model AppSettings {
   /// Kurzbericht des letzten Durchlaufs: { synced, failed, skipped, ms }
   lastAutoSyncReport Json?
 
+  // ── Stillstand ─────────────────────────────────────────────
+  /// Ab wie vielen Tagen ohne Commit ein Projekt als stillstehend gilt.
+  staleAfterDays   Int       @default(60)
+  /// Die Pruefung laeuft hoechstens einmal am Tag.
+  lastStaleCheckAt DateTime?
+
   updatedAt DateTime @updatedAt
 }
 
@@ -192,7 +301,7 @@ model GitConnection {
   ownerId String?
   owner   User?   @relation(fields: [ownerId], references: [id], onDelete: Cascade)
 
-  projects  Project[]
+  repositories Repository[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
@@ -221,24 +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
-  // ── Git-Anbindung ──────────────────────────────────────────
+  /// uebrigen Ansichten folgen der gewaehlten Sortierung.
-  repoUrl       String?
+  position    Int           @default(0)
-  /// Owner bzw. Namespace/Gruppe (bei GitLab auch verschachtelt: "gruppe/subgruppe")
-  repoOwner     String?
-  repoName      String?
-  defaultBranch String?
-  connectionId  String?
-  connection    GitConnection? @relation(fields: [connectionId], references: [id], onDelete: SetNull)
-
-  lastSyncedAt DateTime?
-  syncError    String?
-  /// Am automatischen Abgleich teilnehmen. Einzeln abschaltbar, etwa bei
-  /// einem Repo, dessen Token staendig Fehler wirft.
-  autoSync     Boolean   @default(true)
-  /// Aufeinanderfolgende Fehlversuche. Steuert das Zurueckhalten: nach
-  /// jedem Fehlschlag wird der naechste Versuch weiter hinausgezoegert.
-  syncFailureCount Int   @default(0)
 
   /// Besitzer. Nullable wie bei GitConnection, damit Bestandsdaten beim
   /// Einrichten des ersten Kontos uebernommen werden koennen.
@@ -249,18 +343,117 @@ model Project {
   /// von Hand zu schieben. Nur sinnvoll, wenn es ueberhaupt Aufgaben gibt.
   progressFromTasks Boolean @default(false)
 
+  /// Wann zuletzt wegen Stillstands gemeldet wurde. Erneut gemeldet wird
+  /// erst, wenn danach wieder ein Commit kam und es dann wieder still wurde.
+  /// Bleibt am Projekt: Stillstand ist eine Aussage ueber das Vorhaben, nicht
+  /// ueber ein einzelnes Repository.
+  notifiedStaleAt DateTime?
+
   notes        Note[]
   tasks        Task[]
-  snapshot RepoSnapshot?
+  activities   Activity[]
+  repositories Repository[]
 
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
   @@unique([ownerId, slug])
   @@index([status])
-  @@index([connectionId])
   @@index([updatedAt])
   @@index([ownerId])
+  @@index([ownerId, status, position])
+}
+
+/// Ein Repository eines Projekts. Ein Vorhaben besteht oft aus mehreren –
+/// Frontend und Backend etwa –, gehoert aber in eine Karte.
+///
+/// Das erste Repository (position 0) ist das fuehrende: seine Kennzahlen
+/// stehen auf der Projektkarte, wo fuer mehrere kein Platz ist.
+model Repository {
+  id        String  @id @default(cuid())
+  projectId String
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
+
+  /// Frei waehlbare Bezeichnung wie "Frontend". Leer heisst: der Repo-Name
+  /// steht fuer sich.
+  label String?
+
+  repoUrl String?
+  /// Owner bzw. Namespace/Gruppe (bei GitLab auch verschachtelt: "gruppe/subgruppe")
+  repoOwner     String?
+  repoName      String?
+  defaultBranch String?
+
+  connectionId String?
+  connection   GitConnection? @relation(fields: [connectionId], references: [id], onDelete: SetNull)
+
+  /// Reihenfolge in der Anzeige.
+  position Int @default(0)
+
+  lastSyncedAt DateTime?
+  syncError    String?
+  /// Am automatischen Abgleich teilnehmen. Einzeln abschaltbar, etwa bei
+  /// einem Repo, dessen Token staendig Fehler wirft.
+  autoSync Boolean @default(true)
+  /// Aufeinanderfolgende Fehlversuche. Steuert das Zurueckhalten: nach
+  /// jedem Fehlschlag wird der naechste Versuch weiter hinausgezoegert.
+  syncFailureCount Int @default(0)
+
+  /// Woruber zuletzt benachrichtigt wurde. Gemeldet wird nur bei einer
+  /// Aenderung – sonst kaeme bei einem dauerhaft kaputten Repo mit jedem
+  /// Abgleich dieselbe Nachricht. Je Repository, nicht je Projekt: sonst
+  /// verdeckt ein rotes Frontend die rote Pipeline des Backends.
+  notifiedSyncError String?
+  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())
+  updatedAt DateTime @updatedAt
+
+  @@index([projectId, position])
+  @@index([connectionId])
+}
+
+/// Ein Zustellweg fuer Benachrichtigungen, gehoert genau einem Konto.
+model NotificationTarget {
+  id      String              @id @default(cuid())
+  userId  String
+  user    User                @relation(fields: [userId], references: [id], onDelete: Cascade)
+  name    String
+  channel NotificationChannel
+
+  /// Webhook-URL, ntfy-Themen-URL oder E-Mail-Adresse.
+  target  String
+  /// Optionales Geheimnis, AES-256-GCM verschluesselt: Bearer-Token fuer
+  /// ntfy oder ein Signaturschluessel fuer den Webhook.
+  secretCipher String?
+  secretHint   String?
+
+  /// Worueber dieses Ziel benachrichtigt werden will.
+  events   NotificationEvent[] @default([])
+  isActive Boolean             @default(true)
+
+  lastSentAt  DateTime?
+  lastOk      Boolean?
+  lastMessage String?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([userId, name])
+  @@index([userId])
 }
 
 /// Eine Aufgabe innerhalb eines Projekts – die Karten des Aufgabenbretts.
@@ -281,12 +474,93 @@ 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?
+  sourceUrl   String?
+  /// Aus welchem Repository. Muss mit in die Eindeutigkeit: Frontend und
+  /// Backend haben beide ein Issue Nummer 5, und das sind zwei Aufgaben.
+  sourceRepositoryId String?
+
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
+  /// Verhindert Dubletten beim erneuten Uebernehmen. Mehrere Aufgaben ohne
+  /// Herkunft sind erlaubt: NULL gilt in Postgres als verschieden.
+  @@unique([projectId, sourceRepositoryId, sourceIssue])
   @@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())
+  projectId String
+  project   Project      @relation(fields: [projectId], references: [id], onDelete: Cascade)
+
+  /// Wer. null bedeutet: die Anwendung selbst, also der Zeitgeber beim
+  /// automatischen Abgleich.
+  userId String?
+  user   User?   @relation(fields: [userId], references: [id], onDelete: SetNull)
+
+  kind ActivityKind
+  /// Fertig formulierter Einzeiler. Die Formulierung beim Schreiben
+  /// festzuhalten spart der Anzeige das Nachschlagen von Namen, die es
+  /// spaeter womoeglich nicht mehr gibt – etwa den einer geloeschten Notiz.
+  summary String
+  /// Zusatzangaben wie { from: "IDEA", to: "DONE" }. Fuer die Anzeige nicht
+  /// noetig, aber nuetzlich, falls spaeter ausgewertet werden soll.
+  meta Json?
+
+  createdAt DateTime @default(now())
+
+  /// Absteigend gelesen, immer je Projekt.
+  @@index([projectId, createdAt])
+}
+
 /// Freie Notizen zu einem Projekt.
 model Note {
   id        String   @id @default(cuid())
@@ -302,12 +576,12 @@ model Note {
   @@index([pinned])
 }
 
-/// Zwischengespeicherter Stand des verknuepften Repositories. Wird beim
+/// Zwischengespeicherter Stand eines Repositories. Wird beim Sync
-/// Sync ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
+/// ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
 model RepoSnapshot {
   id           String     @id @default(cuid())
-  projectId String  @unique
+  repositoryId String     @unique
-  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
+  repository   Repository @relation(fields: [repositoryId], references: [id], onDelete: Cascade)
 
   fullName      String?
   description   String?
@@ -345,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/account/page.tsx

@@ -1,5 +1,10 @@
 import type { Metadata } from "next";
 import { AccountManager, type AccountData } from "@/components/account/AccountManager";
+import {
+  NotificationSection,
+  type NotificationTargetEntry,
+} from "@/components/account/NotificationSection";
+import { emailAvailable } from "@/lib/notify";
 import { requireUserPage } from "@/lib/auth/guard";
 import { WEBAUTHN_AVAILABLE } from "@/lib/config";
 import { prisma } from "@/lib/db";
@@ -13,7 +18,7 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AccountPage() {
   const user = await requireUserPage();
 
-  const [passkeys, sessions] = await Promise.all([
+  const [passkeys, sessions, targets, konto, offeneCodes] = await Promise.all([
     prisma.credential.findMany({
       where: { userId: user.id },
       select: {
@@ -37,6 +42,27 @@ export default async function AccountPage() {
       },
       orderBy: { lastSeenAt: "desc" },
     }),
+    prisma.notificationTarget.findMany({
+      where: { userId: user.id },
+      select: {
+        id: true,
+        name: true,
+        channel: true,
+        target: true,
+        secretHint: true,
+        events: true,
+        isActive: true,
+        lastSentAt: true,
+        lastOk: true,
+        lastMessage: true,
+      },
+      orderBy: { name: "asc" },
+    }),
+    prisma.user.findUniqueOrThrow({
+      where: { id: user.id },
+      select: { totpEnabledAt: true },
+    }),
+    prisma.recoveryCode.count({ where: { userId: user.id, usedAt: null } }),
   ]);
 
   const data: AccountData = {
@@ -48,6 +74,11 @@ export default async function AccountPage() {
     passkeys,
     sessions,
     passkeysAvailable: WEBAUTHN_AVAILABLE,
+    totp: {
+      enabled: Boolean(konto.totpEnabledAt),
+      enabledAt: konto.totpEnabledAt,
+      recoveryCodesLeft: offeneCodes,
+    },
   };
 
   return (
@@ -60,6 +91,11 @@ export default async function AccountPage() {
       </header>
 
       <AccountManager data={data} />
+
+      <NotificationSection
+        targets={targets as unknown as NotificationTargetEntry[]}
+        emailAvailable={emailAvailable()}
+      />
     </div>
   );
 }

src/app/admin/page.tsx

@@ -19,7 +19,7 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AdminPage() {
   const admin = await requireAdminPage();
 
-  const [settings, users, eligible] = await Promise.all([
+  const [settings, users, eligible, staleListeners] = await Promise.all([
     getAppSettings(),
     prisma.user.findMany({
       select: userSafeSelect,
@@ -27,7 +27,9 @@ export default async function AdminPage() {
     }),
     // Bewusst ueber alle Konten: der Abgleich ist ein Serverauftrag, keine
     // Dateneinsicht. Gezaehlt wird nur, nicht gelesen.
-    prisma.project.count({
+    // Gezaehlt werden Repositories, nicht Projekte: sie sind die Einheit, in
+    // der abgeglichen und begrenzt wird.
+    prisma.repository.count({
       where: {
         autoSync: true,
         OR: [
@@ -36,6 +38,9 @@ export default async function AdminPage() {
         ],
       },
     }),
+    prisma.notificationTarget.count({
+      where: { isActive: true, events: { has: "PROJECT_STALE" } },
+    }),
   ]);
 
   const data: AdminData = {
@@ -54,6 +59,11 @@ export default async function AdminPage() {
       lastReport: (settings.lastAutoSyncReport as AutoSyncReport | null) ?? null,
       eligible,
     },
+    stale: {
+      afterDays: settings.staleAfterDays,
+      lastCheckAt: settings.lastStaleCheckAt,
+      listeners: staleListeners,
+    },
   };
 
   return (

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

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

src/app/api/account/totp/recovery/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { requireUserApi } from "@/lib/auth/guard";
+import { verifyPassword } from "@/lib/auth/password";
+import { issueRecoveryCodes } from "@/lib/auth/recovery";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+
+export const dynamic = "force-dynamic";
+
+const schema = z.object({ password: z.string().min(1).max(200) });
+
+/**
+ * Neue Wiederherstellungscodes. Die alten verfallen dabei – sonst waeren
+ * Zettel im Umlauf, von denen niemand mehr weiss, welche noch gelten.
+ *
+ * Verlangt das Passwort, wie das Abschalten auch: die Codes sind gleichwertig
+ * zum zweiten Faktor.
+ */
+export async function POST(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = schema.safeParse(body.data);
+  if (!parsed.success) return jsonError("Bitte das Passwort angeben.", 422);
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: auth.user.id },
+    select: { passwordHash: true, totpEnabledAt: true },
+  });
+
+  if (!user.totpEnabledAt) {
+    return jsonError("Die Zwei-Faktor-Anmeldung ist nicht aktiv.", 409);
+  }
+  if (!(await verifyPassword(parsed.data.password, user.passwordHash))) {
+    return jsonError("Das Passwort stimmt nicht.", 401);
+  }
+
+  return NextResponse.json({ recoveryCodes: await issueRecoveryCodes(auth.user.id) });
+}

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

@@ -0,0 +1,170 @@
+import { NextResponse } from "next/server";
+import QRCode from "qrcode";
+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, matchTotp, otpauthUri } from "@/lib/auth/totp";
+import { APP_NAME } from "@/lib/config";
+import { encryptSecret, tryDecryptSecret } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { formatZodError } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Zwei-Faktor-Anmeldung per Einmalkennwort.
+ *
+ * Die Einrichtung laeuft in zwei Schritten: POST legt einen Schluessel an und
+ * zeigt ihn als QR-Code, PUT schaltet ihn nach einem bestaetigten Code scharf.
+ * Erst dann fragt die Anmeldung danach. Wer die Einrichtung abbricht oder den
+ * QR-Code nie scannt, sperrt sich so nicht aus.
+ */
+
+/** Zustand fuer die Anzeige. */
+export async function GET() {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: auth.user.id },
+    select: { totpEnabledAt: true },
+  });
+
+  return NextResponse.json({
+    enabled: Boolean(user.totpEnabledAt),
+    enabledAt: user.totpEnabledAt,
+    recoveryCodesLeft: user.totpEnabledAt
+      ? await countUnusedRecoveryCodes(auth.user.id)
+      : 0,
+  });
+}
+
+/** Schritt 1: Schluessel erzeugen und als QR-Code zurueckgeben. */
+export async function POST() {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: auth.user.id },
+    select: { totpEnabledAt: true, username: true },
+  });
+
+  if (user.totpEnabledAt) {
+    return jsonError(
+      "Die Zwei-Faktor-Anmeldung ist bereits aktiv. Bitte zuerst abschalten.",
+      409,
+    );
+  }
+
+  // Bei jedem Anlauf ein frischer Schluessel: ein halb eingerichteter aus
+  // einem frueheren Versuch koennte in einer Authenticator-App liegen, ohne
+  // dass hier bekannt waere, in welcher.
+  const secret = generateTotpSecret();
+  await prisma.user.update({
+    where: { id: auth.user.id },
+    data: { totpSecretCipher: encryptSecret(secret) },
+  });
+
+  const uri = otpauthUri({ secret, account: user.username, issuer: APP_NAME });
+
+  return NextResponse.json({
+    // Das Bild als data:-URI, damit die Content-Security-Policy nichts
+    // nachladen muss. img-src erlaubt data: bereits.
+    qr: await QRCode.toDataURL(uri, { margin: 1, width: 320 }),
+    uri,
+    /** Zum Abtippen, falls die Kamera nicht mitspielt. */
+    secret: groupSecret(secret),
+  });
+}
+
+const enableSchema = z.object({ code: z.string().min(6).max(10) });
+
+/** Schritt 2: Code bestaetigen, scharfschalten, Wiederherstellungscodes ausgeben. */
+export async function PUT(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = enableSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: auth.user.id },
+    select: { totpSecretCipher: true, totpEnabledAt: true },
+  });
+
+  if (user.totpEnabledAt) return jsonError("Die Zwei-Faktor-Anmeldung ist bereits aktiv.", 409);
+
+  const secret = tryDecryptSecret(user.totpSecretCipher);
+  if (!secret) {
+    return jsonError("Es liegt kein Schluessel vor. Bitte die Einrichtung neu starten.", 409);
+  }
+
+  const fenster = matchTotp(secret, parsed.data.code);
+  if (fenster === null) {
+    return jsonError(
+      "Der Code stimmt nicht. Geht die Uhr des Geraets richtig?",
+      401,
+    );
+  }
+
+  await prisma.user.update({
+    where: { id: auth.user.id },
+    // 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({
+    ok: true,
+    // Einmalige Ausgabe: gespeichert wird nur ihr Hash.
+    recoveryCodes: await issueRecoveryCodes(auth.user.id),
+  });
+}
+
+const disableSchema = z.object({ password: z.string().min(1).max(200) });
+
+/** Abschalten. Verlangt das Passwort, nicht nur eine offene Sitzung. */
+export async function DELETE(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = disableSchema.safeParse(body.data);
+  if (!parsed.success) return jsonError("Bitte das Passwort angeben.", 422);
+
+  const user = await prisma.user.findUniqueOrThrow({
+    where: { id: auth.user.id },
+    select: { passwordHash: true, totpEnabledAt: true },
+  });
+
+  if (!user.totpEnabledAt) return jsonError("Die Zwei-Faktor-Anmeldung ist nicht aktiv.", 409);
+
+  // Ein unbeaufsichtigter Rechner mit offener Sitzung soll den zweiten Faktor
+  // nicht im Vorbeigehen entfernen koennen.
+  if (!(await verifyPassword(parsed.data.password, user.passwordHash))) {
+    return jsonError("Das Passwort stimmt nicht.", 401);
+  }
+
+  await prisma.$transaction([
+    prisma.user.update({
+      where: { id: auth.user.id },
+      data: { totpSecretCipher: null, totpEnabledAt: null, totpLastCounter: null },
+    }),
+    prisma.recoveryCode.deleteMany({ where: { userId: auth.user.id } }),
+    prisma.pendingLogin.deleteMany({ where: { userId: auth.user.id } }),
+  ]);
+
+  return NextResponse.json({ ok: true });
+}

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

@@ -37,6 +37,7 @@ export async function PATCH(request: Request) {
     autoSyncIntervalMinutes,
     autoSyncActiveOnly,
     autoSyncBatchSize,
+    staleAfterDays,
   } = parsed.data;
 
   // Der Wechsel in den Einzelbetrieb wuerde weitere Konten aussperren –
@@ -57,6 +58,11 @@ export async function PATCH(request: Request) {
     ...(autoSyncIntervalMinutes !== undefined ? { autoSyncIntervalMinutes } : {}),
     ...(autoSyncActiveOnly !== undefined ? { autoSyncActiveOnly } : {}),
     ...(autoSyncBatchSize !== undefined ? { autoSyncBatchSize } : {}),
+    // Neue Schwelle: die Pruefung soll beim naechsten Tick greifen, nicht
+    // erst in 24 Stunden.
+    ...(staleAfterDays !== undefined
+      ? { staleAfterDays, lastStaleCheckAt: null }
+      : {}),
   };
 
   const settings = await prisma.appSettings.upsert({

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

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

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

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

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

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

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

@@ -0,0 +1,117 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  clearMfaCookie,
+  discardPendingLogin,
+  noteMfaFailure,
+  readPendingLogin,
+} from "@/lib/auth/mfa";
+import { redeemRecoveryCode } from "@/lib/auth/recovery";
+import { createSession, setSessionCookie } from "@/lib/auth/session";
+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";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Der zweite Schritt der Anmeldung: Einmalkennwort oder
+ * Wiederherstellungscode.
+ *
+ * Der Vorgang steckt im kurzlebigen Cookie aus Schritt eins. Wer hier ohne
+ * diesen Cookie ankommt, hat kein Passwort vorgezeigt und bekommt nichts.
+ */
+
+const schema = z.object({
+  code: z.string().min(1).max(40),
+});
+
+const GENERIC = "Der Code stimmt nicht.";
+
+export async function POST(request: Request) {
+  const ip = clientIp(request);
+  const limited = rateLimit(`mfa:${ip}`, LIMITS.login.limit, LIMITS.login.windowMs);
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = schema.safeParse(body.data);
+  if (!parsed.success) return jsonError(GENERIC, 401);
+
+  const pending = await readPendingLogin();
+  if (!pending) {
+    const response = jsonError(
+      "Die Anmeldung ist abgelaufen. Bitte melde dich neu an.",
+      401,
+    );
+    clearMfaCookie(response);
+    return response;
+  }
+
+  if (!pending.user.isActive) {
+    await discardPendingLogin(pending.id);
+    const response = jsonError("Dieses Konto ist deaktiviert.", 403);
+    clearMfaCookie(response);
+    return response;
+  }
+
+  const eingabe = parsed.data.code.trim();
+
+  // Sechs Ziffern sind ein Einmalkennwort, alles andere ein
+  // Wiederherstellungscode. Beide Wege zu probieren waere unnoetig – die
+  // Formate ueberschneiden sich nicht.
+  const istZiffern = /^[\d\s]+$/.test(eingabe);
+
+  // Bei den Ziffern zaehlt zusaetzlich, dass das Zeitfenster neuer ist als
+  // 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);
+    if (!weiterMoeglich) {
+      const response = jsonError(
+        "Zu viele Fehlversuche. Bitte melde dich neu an.",
+        429,
+      );
+      clearMfaCookie(response);
+      return response;
+    }
+    return jsonError(GENERIC, 401);
+  }
+
+  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,
+  });
+
+  const response = NextResponse.json({
+    ok: true,
+    user: { id: pending.user.id, username: pending.user.username, role: pending.user.role },
+  });
+  setSessionCookie(response, session.token, session.expiresAt);
+  clearMfaCookie(response);
+  return response;
+}

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

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

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

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

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

@@ -14,7 +14,7 @@ type Params = { params: Promise<{ id: string }> };
 
 const safeSelect = {
   ...connectionSafeSelect,
-  _count: { select: { projects: true } },
+  _count: { select: { repositories: true } },
 };
 
 export async function PATCH(request: Request, { params }: Params) {

src/app/api/connections/route.ts

@@ -14,7 +14,7 @@ export const dynamic = "force-dynamic";
 /** Verbindungen ohne Token-Chiffrat – das verlaesst den Server nie. */
 const safeSelect = {
   ...connectionSafeSelect,
-  _count: { select: { projects: true } },
+  _count: { select: { repositories: true } },
 };
 
 export async function GET() {

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

@@ -1,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { recordActivity, shorten } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { jsonError, readJsonBody } from "@/lib/security/request";
@@ -44,6 +45,18 @@ export async function PATCH(request: Request, { params }: Params) {
     },
   });
 
+  // Nur Anheften ist keine inhaltliche Aenderung und kommt nicht in den
+  // Verlauf – sonst steht dort dreimal dieselbe Notiz, weil jemand unschluessig war.
+  if (parsed.data.title !== undefined || parsed.data.content !== undefined) {
+    await recordActivity({
+      projectId: note.projectId,
+      userId: auth.user.id,
+      kind: "NOTE_UPDATED",
+      summary: `Notiz bearbeitet: ${shorten(updated.title || updated.content)}`,
+      meta: { noteId: id },
+    });
+  }
+
   return NextResponse.json({ note: updated });
 }
 
@@ -53,10 +66,25 @@ export async function DELETE(_request: Request, { params }: Params) {
 
   const { id } = await params;
 
+  // Vor dem Loeschen lesen: danach ist nicht mehr feststellbar, worum es ging.
+  const vorher = await prisma.note.findFirst({
+    where: { id, project: { ownerId: auth.user.id } },
+    select: { projectId: true, title: true, content: true },
+  });
+
   const result = await prisma.note.deleteMany({
     where: { id, project: { ownerId: auth.user.id } },
   });
   if (result.count === 0) return jsonError("Notiz nicht gefunden", 404);
 
+  if (vorher) {
+    await recordActivity({
+      projectId: vorher.projectId,
+      userId: auth.user.id,
+      kind: "NOTE_DELETED",
+      summary: `Notiz gelöscht: ${shorten(vorher.title || vorher.content)}`,
+    });
+  }
+
   return NextResponse.json({ ok: true });
 }

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

@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { encryptSecret, tokenHint } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { BlockedHostError, assertAllowedUrl } from "@/lib/security/ssrf";
+import { targetSafeSelect } from "@/lib/notify/types";
+import { formatZodError, notificationTargetUpdateSchema } 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.notificationTarget.findFirst({
+    where: { id, userId: auth.user.id },
+  });
+  if (!existing) return jsonError("Ziel nicht gefunden", 404);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = notificationTargetUpdateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const data = parsed.data;
+  const update: Record<string, unknown> = {};
+
+  if (data.name !== undefined) update.name = data.name;
+  if (data.events !== undefined) update.events = data.events;
+  if (data.isActive !== undefined) update.isActive = data.isActive;
+
+  if (data.target !== undefined) {
+    if (existing.channel !== "EMAIL") {
+      try {
+        await assertAllowedUrl(data.target);
+      } catch (error) {
+        if (error instanceof BlockedHostError) {
+          return NextResponse.json(
+            { error: error.message, fields: { target: error.message } },
+            { status: 422 },
+          );
+        }
+        throw error;
+      }
+    }
+    update.target = data.target;
+  }
+
+  // Leeres Feld heisst "unveraendert", null heisst "entfernen".
+  if (data.secret !== undefined) {
+    if (data.secret) {
+      update.secretCipher = encryptSecret(data.secret);
+      update.secretHint = tokenHint(data.secret);
+    } else {
+      update.secretCipher = null;
+      update.secretHint = null;
+    }
+  }
+
+  try {
+    const target = await prisma.notificationTarget.update({
+      where: { id },
+      data: update,
+      select: targetSafeSelect,
+    });
+    return NextResponse.json({ target });
+  } catch {
+    return jsonError("Name bereits vergeben.", 409);
+  }
+}
+
+export async function DELETE(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const result = await prisma.notificationTarget.deleteMany({
+    where: { id, userId: auth.user.id },
+  });
+  if (result.count === 0) return jsonError("Ziel nicht gefunden", 404);
+
+  return NextResponse.json({ ok: true });
+}

src/app/api/notifications/[id]/test/route.ts

@@ -0,0 +1,40 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { deliver } from "@/lib/notify/channels";
+import { testMessage } from "@/lib/notify";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, jsonError, tooManyRequests } from "@/lib/security/request";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/** Schickt eine Testnachricht an genau dieses Ziel. */
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  // Loest einen ausgehenden Aufruf aus – entsprechend begrenzt.
+  const limited = rateLimit(
+    `notify-test:${auth.user.id}:${clientIp(request)}`,
+    LIMITS.outbound.limit,
+    LIMITS.outbound.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const { id } = await params;
+  const target = await prisma.notificationTarget.findFirst({
+    where: { id, userId: auth.user.id },
+  });
+  if (!target) return jsonError("Ziel nicht gefunden", 404);
+
+  const result = await deliver(target, testMessage());
+
+  await prisma.notificationTarget.update({
+    where: { id },
+    data: { lastSentAt: new Date(), lastOk: result.ok, lastMessage: result.message },
+  });
+
+  return NextResponse.json(result, { status: result.ok ? 200 : 502 });
+}

src/app/api/notifications/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { encryptSecret, tokenHint } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+import { readJsonBody } from "@/lib/security/request";
+import { targetSafeSelect } from "@/lib/notify/types";
+import { BlockedHostError, assertAllowedUrl } from "@/lib/security/ssrf";
+import { formatZodError, notificationTargetCreateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const targets = await prisma.notificationTarget.findMany({
+    where: { userId: auth.user.id },
+    select: targetSafeSelect,
+    orderBy: { name: "asc" },
+  });
+  return NextResponse.json({ targets });
+}
+
+export async function POST(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = notificationTargetCreateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const { name, channel, target, secret, events, isActive } = parsed.data;
+
+  // Webhook und ntfy ruft der Server spaeter selbst auf – gleiche Pruefung
+  // wie bei den Git-Verbindungen.
+  if (channel !== "EMAIL") {
+    try {
+      await assertAllowedUrl(target);
+    } catch (error) {
+      if (error instanceof BlockedHostError) {
+        return NextResponse.json(
+          { error: error.message, fields: { target: error.message } },
+          { status: 422 },
+        );
+      }
+      throw error;
+    }
+  }
+
+  const duplicate = await prisma.notificationTarget.findFirst({
+    where: { userId: auth.user.id, name },
+    select: { id: true },
+  });
+  if (duplicate) {
+    return NextResponse.json(
+      { error: "Name bereits vergeben.", fields: { name: "Name bereits vergeben" } },
+      { status: 409 },
+    );
+  }
+
+  const created = await prisma.notificationTarget.create({
+    data: {
+      userId: auth.user.id,
+      name,
+      channel,
+      target,
+      secretCipher: secret ? encryptSecret(secret) : null,
+      secretHint: secret ? tokenHint(secret) : null,
+      events,
+      isActive,
+    },
+    select: targetSafeSelect,
+  });
+
+  return NextResponse.json({ target: created }, { status: 201 });
+}

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

@@ -0,0 +1,44 @@
+import { NextResponse } from "next/server";
+import { ACTIVITY_LIMIT } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError } from "@/lib/security/request";
+import { ownedProject } from "@/lib/tasks";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/** Der Verlauf eines Projekts, neueste Eintraege zuerst. */
+export async function GET(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  // Number(null) waere 0 und damit endlich – ohne die Pruefung auf den
+  // fehlenden Parameter kaeme genau ein Eintrag zurueck.
+  const roh = new URL(request.url).searchParams.get("limit");
+  const angefragt = roh === null ? Number.NaN : Number(roh);
+  const take = Number.isFinite(angefragt)
+    ? Math.min(Math.max(angefragt, 1), ACTIVITY_LIMIT)
+    : 30;
+
+  const activities = await prisma.activity.findMany({
+    where: { projectId: id },
+    orderBy: { createdAt: "desc" },
+    take,
+    select: {
+      id: true,
+      kind: true,
+      summary: true,
+      createdAt: true,
+      user: { select: { username: true, displayName: true } },
+    },
+  });
+
+  return NextResponse.json({ activities });
+}

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

@@ -1,7 +1,7 @@
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { exportFileName } from "@/lib/export/format";
-import { buildExportFile, toMarkdown } from "@/lib/export/project";
+import { buildExportFile, exportInclude, toMarkdown } from "@/lib/export/project";
 import { jsonError } from "@/lib/security/request";
 
 export const dynamic = "force-dynamic";
@@ -24,11 +24,17 @@ export async function GET(request: Request, { params }: Params) {
   const project = await prisma.project.findFirst({
     where: { id, ownerId: auth.user.id },
     include: {
-      notes: { orderBy: [{ pinned: "desc" }, { createdAt: "asc" }] },
+      ...exportInclude,
-      tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
+      // Fuer die Markdown-Fassung zusaetzlich der gespeicherte Stand, damit
+      // die Datei auch ohne Netz vollstaendig ist.
+      repositories: {
+        include: {
           connection: { select: { name: true, provider: true, baseUrl: true } },
           snapshot: true,
         },
+        orderBy: [{ position: "asc" }, { createdAt: "asc" }],
+      },
+    },
   });
 
   if (!project) return jsonError("Projekt nicht gefunden", 404);

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

@@ -1,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { recordActivity, shorten } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { jsonError, readJsonBody } from "@/lib/security/request";
@@ -64,5 +65,13 @@ export async function POST(request: Request, { params }: Params) {
   // Projekt "anfassen", damit die Sortierung nach Aktivitaet stimmt.
   await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
 
+  await recordActivity({
+    projectId: id,
+    userId: auth.user.id,
+    kind: "NOTE_ADDED",
+    summary: `Notiz angelegt: ${shorten(note.title || note.content)}`,
+    meta: { noteId: note.id },
+  });
+
   return NextResponse.json({ note }, { status: 201 });
 }

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

@@ -0,0 +1,122 @@
+import { NextResponse } from "next/server";
+import { recordActivity, shorten } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { connectionSafeSelect } from "@/lib/projects";
+import {
+  completeRepoInput,
+  namesRepository,
+  nextRepoPosition,
+  repoTitle,
+} from "@/lib/repositories";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { ownedProject } from "@/lib/tasks";
+import { formatZodError, repositoryCreateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/** Hoechstzahl je Projekt. Wer mehr braucht, hat mehrere Vorhaben. */
+const MAX_REPOS = 20;
+
+const include = {
+  connection: { select: connectionSafeSelect },
+  snapshot: true,
+} as const;
+
+export async function GET(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const repositories = await prisma.repository.findMany({
+    where: { projectId: id },
+    include,
+    orderBy: [{ position: "asc" }, { createdAt: "asc" }],
+  });
+
+  return NextResponse.json({ repositories });
+}
+
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = repositoryCreateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const eingabe = completeRepoInput(parsed.data);
+  if (!namesRepository(eingabe)) {
+    return jsonError("Bitte eine Repo-URL oder Owner und Name angeben.", 422);
+  }
+
+  // Eine fremde Verbindung darf nicht untergeschoben werden.
+  if (eingabe.connectionId) {
+    const connection = await prisma.gitConnection.findFirst({
+      where: { id: eingabe.connectionId, ownerId: auth.user.id },
+      select: { id: true },
+    });
+    if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
+  }
+
+  const vorhanden = await prisma.repository.count({ where: { projectId: id } });
+  if (vorhanden >= MAX_REPOS) {
+    return jsonError(`Mehr als ${MAX_REPOS} Repositories je Projekt sind nicht vorgesehen.`, 409);
+  }
+
+  // Dasselbe Repo zweimal am selben Projekt ist immer ein Versehen.
+  if (eingabe.repoOwner && eingabe.repoName) {
+    const doppelt = await prisma.repository.findFirst({
+      where: { projectId: id, repoOwner: eingabe.repoOwner, repoName: eingabe.repoName },
+      select: { id: true },
+    });
+    if (doppelt) {
+      return jsonError(
+        `${eingabe.repoOwner}/${eingabe.repoName} ist mit diesem Projekt bereits verknuepft.`,
+        409,
+      );
+    }
+  }
+
+  const repository = await prisma.repository.create({
+    data: {
+      projectId: id,
+      label: eingabe.label ?? null,
+      repoUrl: eingabe.repoUrl ?? null,
+      repoOwner: eingabe.repoOwner ?? null,
+      repoName: eingabe.repoName ?? null,
+      connectionId: eingabe.connectionId ?? null,
+      autoSync: eingabe.autoSync ?? true,
+      position: await nextRepoPosition(id),
+    },
+    include,
+  });
+
+  await recordActivity({
+    projectId: id,
+    userId: auth.user.id,
+    kind: "REPO_LINKED",
+    summary: `Repository verknüpft: ${shorten(repoTitle(repository))}`,
+    meta: { repositoryId: repository.id },
+  });
+
+  return NextResponse.json({ repository }, { status: 201 });
+}

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

@@ -1,9 +1,17 @@
+import type { ProjectStatus } from "@prisma/client";
 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 { parseRepoUrl } from "@/lib/git";
+import {
-import { projectDetailInclude, projectListInclude, uniqueSlug } from "@/lib/projects";
+  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";
 import { formatZodError, projectUpdateSchema } from "@/lib/validation";
 
 export const dynamic = "force-dynamic";
@@ -74,35 +82,104 @@ export async function PATCH(request: Request, { params }: Params) {
     "accent",
     "tags",
     "favorite",
-    "autoSync",
+    "progressFromTasks",
-    "connectionId",
   ] as const) {
     if (data[key] !== undefined) update[key] = data[key];
   }
 
-  if (data.repoUrl !== undefined) {
+  // Beim Statuswechsel ans Ende der neuen Spalte – sonst behielte das Projekt
-    update.repoUrl = data.repoUrl;
+  // seinen alten Rang und saesse mitten in einer Spalte, in der es eben erst
-    const parsedUrl = data.repoUrl ? parseRepoUrl(data.repoUrl) : null;
+  // angekommen ist.
-    if (parsedUrl) {
+  if (data.status !== undefined && data.status !== existing.status) {
-      update.repoOwner = data.repoOwner ?? parsedUrl.owner;
+    update.position = await nextProjectPosition(auth.user.id, data.status);
-      update.repoName = data.repoName ?? parsedUrl.name;
-    } else if (!data.repoUrl) {
-      update.repoOwner = null;
-      update.repoName = null;
   }
-  }
-  if (data.repoOwner !== undefined) update.repoOwner = data.repoOwner;
-  if (data.repoName !== undefined) update.repoName = data.repoName;
 
-  const project = await prisma.project.update({
+  await prisma.project.update({ where: { id }, data: update });
+
+  // Die Git-Felder gehen an das fuehrende Repository. Sie hier weiterhin
+  // anzunehmen erspart der Oberflaeche zwei Aufrufe fuer einen Speichervorgang.
+  const repoFelder = {
+    repoUrl: data.repoUrl,
+    repoOwner: data.repoOwner,
+    repoName: data.repoName,
+    connectionId: data.connectionId,
+    autoSync: data.autoSync,
+  };
+  const repoBeruehrt = Object.values(repoFelder).some((value) => value !== undefined);
+  if (repoBeruehrt) await applyLeadingRepo(id, repoFelder);
+
+  await noteChanges(id, auth.user.id, existing, update, repoBeruehrt ? repoFelder : null);
+
+  // Wird die Ableitung eingeschaltet, soll der Wert sofort stimmen und nicht
+  // erst beim naechsten Aufgabenwechsel.
+  if (data.progressFromTasks === true) {
+    await refreshDerivedProgress(id);
+  }
+
+  const project = await prisma.project.findUniqueOrThrow({
     where: { id },
-    data: update,
     include: projectListInclude,
   });
 
   return NextResponse.json({ project });
 }
 
+/**
+ * Haelt fest, was sich geaendert hat. Status und Repo-Verknuepfung bekommen
+ * einen eigenen Eintrag – sie sind die Vorgaenge, die man spaeter sucht. Alles
+ * uebrige fasst ein Eintrag zusammen, sonst ertraenkt eine Feinjustage der
+ * Farbe den Verlauf.
+ */
+async function noteChanges(
+  projectId: string,
+  userId: string,
+  before: { status: ProjectStatus },
+  update: Record<string, unknown>,
+  repo: RepoInput | null,
+) {
+  const rest = Object.keys(update).filter((key) => key !== "status" && key !== "slug");
+  const entries: Parameters<typeof recordActivities>[0] = [];
+
+  if (update.status !== undefined && update.status !== before.status) {
+    const to = update.status as ProjectStatus;
+    entries.push({
+      projectId,
+      userId,
+      kind: "STATUS_CHANGED",
+      summary: describeStatus(before.status, to),
+      meta: { from: before.status, to },
+    });
+  }
+
+  // Nur die Verknuepfung selbst ist eine Nachricht wert. Ob der automatische
+  // Abgleich an oder aus ist, gehoert zu den uebrigen Feldern.
+  if (repo && (repo.repoUrl !== undefined || repo.repoName !== undefined)) {
+    const ziel = repo.repoUrl ?? (repo.repoOwner ? `${repo.repoOwner}/${repo.repoName}` : null);
+    entries.push({
+      projectId,
+      userId,
+      kind: "REPO_LINKED",
+      summary: ziel ? `Repository verknüpft: ${shorten(ziel)}` : "Repository-Angaben geleert",
+      meta: { repoUrl: repo.repoUrl ?? null },
+    });
+  }
+  if (repo?.autoSync !== undefined) rest.push("autoSync");
+  if (repo?.connectionId !== undefined) rest.push("connectionId");
+
+  const felder = describeFields(rest);
+  if (felder) {
+    entries.push({
+      projectId,
+      userId,
+      kind: "PROJECT_UPDATED",
+      summary: felder,
+      meta: { fields: rest },
+    });
+  }
+
+  await recordActivities(entries);
+}
+
 export async function DELETE(_request: Request, { params }: Params) {
   const auth = await requireUserApi();
   if (!auth.ok) return auth.response;

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

@@ -0,0 +1,147 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { recordActivity } from "@/lib/activity";
+import { repoTitle } from "@/lib/repositories";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { nextPosition, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
+import { asArray, type TicketInfo } from "@/types";
+import { formatZodError } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+const schema = z.object({
+  /** Leer heisst: alle offenen Issues aus dem Snapshot. */
+  numbers: z.array(z.number().int()).max(200).optional(),
+  /** Aus welchem Repository. Leer heisst: dem fuehrenden. */
+  repositoryId: z.string().optional(),
+});
+
+/**
+ * Uebernimmt offene Issues des verknuepften Repositories als Aufgaben.
+ *
+ * Grundlage ist der zuletzt geholte Snapshot – hier wird nichts nachgeladen,
+ * damit ein Klick nicht ungefragt fremde APIs anspricht. Wer den neuesten
+ * Stand will, gleicht vorher ab.
+ *
+ * Bereits uebernommene Issues werden uebersprungen: die Nummer steht an der
+ * Aufgabe und ist je Projekt eindeutig. Ein zweiter Aufruf legt also keine
+ * Dubletten an, auch wenn die Aufgabe inzwischen verschoben oder umbenannt
+ * wurde.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  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: id, ...(parsed.data.repositoryId ? { id: parsed.data.repositoryId } : {}) },
+    orderBy: [{ position: "asc" }, { createdAt: "asc" }],
+    include: { snapshot: true },
+  });
+
+  if (!repository) {
+    // 404 nur, wenn nach einem bestimmten gefragt wurde. Wer nichts angibt,
+    // hat schlicht noch keines verknuepft – und das ist kein "nicht gefunden".
+    return parsed.data.repositoryId
+      ? jsonError("Repository nicht gefunden", 404)
+      : jsonError("Kein Repository verknuepft. Bitte zuerst eines hinterlegen.", 409);
+  }
+
+  const snapshot = repository.snapshot;
+  if (!snapshot) {
+    return jsonError(
+      "Noch kein Repo-Stand vorhanden. Bitte zuerst synchronisieren.",
+      409,
+    );
+  }
+
+  const alle = asArray<TicketInfo>(snapshot.issues);
+  const gewuenscht = parsed.data.numbers;
+  const auswahl = gewuenscht?.length
+    ? alle.filter((issue) => gewuenscht.includes(issue.number))
+    : alle;
+
+  if (auswahl.length === 0) {
+    return NextResponse.json({ created: 0, skipped: 0, tasks: [] });
+  }
+
+  const vorhanden = await prisma.task.findMany({
+    where: {
+      projectId: id,
+      sourceRepositoryId: repository.id,
+      sourceIssue: { in: auswahl.map((issue) => issue.number) },
+    },
+    select: { sourceIssue: true },
+  });
+  const bekannt = new Set(vorhanden.map((task) => task.sourceIssue));
+
+  const neu = auswahl.filter((issue) => !bekannt.has(issue.number));
+  let position = await nextPosition(id, "TODO");
+
+  const angelegt = [];
+  for (const issue of neu) {
+    angelegt.push(
+      await prisma.task.create({
+        data: {
+          projectId: id,
+          title: issue.title.slice(0, 200),
+          // Der Link ist das Wichtigste – der Text steht im Git-System.
+          description: issue.url ? `[Issue #${issue.number}](${issue.url})` : null,
+          status: "TODO",
+          position: position++,
+          labels: issue.labels.slice(0, 8),
+          sourceIssue: issue.number,
+          sourceUrl: issue.url,
+          sourceRepositoryId: repository.id,
+        },
+      }),
+    );
+  }
+
+  if (angelegt.length > 0) {
+    await refreshDerivedProgress(id);
+    await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
+    // Ein Eintrag fuer den Vorgang, nicht einer je Aufgabe: sonst besteht der
+    // Verlauf nach einer Uebernahme aus nichts anderem mehr.
+    await recordActivity({
+      projectId: id,
+      userId: auth.user.id,
+      kind: "TASKS_IMPORTED",
+      summary:
+        angelegt.length === 1
+          ? `1 Issue aus ${repoTitle(repository)} als Aufgabe übernommen`
+          : `${angelegt.length} Issues aus ${repoTitle(repository)} als Aufgaben übernommen`,
+      meta: {
+        repositoryId: repository.id,
+        numbers: angelegt.map((task) => task.sourceIssue),
+      },
+    });
+  }
+
+  return NextResponse.json({
+    created: angelegt.length,
+    skipped: auswahl.length - angelegt.length,
+    tasks: angelegt,
+  });
+}

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

@@ -1,4 +1,5 @@
 import { NextResponse } from "next/server";
+import { recordActivity, shorten } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { jsonError, readJsonBody } from "@/lib/security/request";
@@ -45,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: {
@@ -57,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,
     },
   });
@@ -65,5 +67,13 @@ export async function POST(request: Request, { params }: Params) {
   // Damit die Sortierung nach Aktivitaet stimmt.
   await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
 
+  await recordActivity({
+    projectId: id,
+    userId: auth.user.id,
+    kind: "TASK_ADDED",
+    summary: `Aufgabe angelegt: ${shorten(task.title, 50)}`,
+    meta: { taskId: task.id },
+  });
+
   return NextResponse.json({ task }, { status: 201 });
 }

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

@@ -1,9 +1,14 @@
 import { NextResponse } from "next/server";
 import { z } from "zod";
+import { recordActivity } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
-import { exportFileSchema, type ExportedProject } from "@/lib/export/format";
+import {
-import { uniqueSlug } from "@/lib/projects";
+  exportFileSchema,
+  repositoriesOf,
+  type ExportedRepository,
+} from "@/lib/export/format";
+import { nextProjectPosition, uniqueSlug } from "@/lib/projects";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import {
   IMPORT_MAX_BODY_BYTES,
@@ -84,7 +89,7 @@ export async function POST(request: Request) {
     select: { id: true, name: true, provider: true, baseUrl: true },
   });
 
-  function matchConnection(described: ExportedProject["connection"]) {
+  function matchConnection(described: ExportedRepository["connection"]) {
     if (!described) return null;
     const byName = connections.find(
       (candidate) => candidate.name.toLowerCase() === described.name.toLowerCase(),
@@ -104,12 +109,26 @@ export async function POST(request: Request) {
 
   for (const incoming of file.projects) {
     const slug = incoming.slug || slugify(incoming.name) || "projekt";
-    const connection = matchConnection(incoming.connection);
+
-    const connectionState: ItemResult["connection"] = incoming.connection
+    // Version 1 kannte ein Repository je Projekt und schrieb es flach; seit
-      ? connection
+    // Version 2 steht eine Liste da. repositoriesOf glaettet den Unterschied.
-        ? "matched"
+    const eingehendeRepos = repositoriesOf(incoming);
-        : "missing"
+    const repos = eingehendeRepos.map((repo, index) => ({
-      : "none";
+      label: repo.label ?? null,
+      repoUrl: repo.repoUrl ?? null,
+      repoOwner: repo.repoOwner ?? null,
+      repoName: repo.repoName ?? null,
+      autoSync: repo.autoSync ?? true,
+      connectionId: matchConnection(repo.connection ?? null)?.id ?? null,
+      position: index,
+    }));
+
+    // Fuer die Rueckmeldung genuegt, ob ueberhaupt eine beschriebene
+    // Verbindung fehlt – welche, steht in der Datei.
+    const beschrieben = eingehendeRepos.filter((repo) => repo.connection);
+    const fehlend = beschrieben.filter((repo) => !matchConnection(repo.connection ?? null));
+    const connectionState: ItemResult["connection"] =
+      beschrieben.length === 0 ? "none" : fehlend.length > 0 ? "missing" : "matched";
 
     const existing = await prisma.project.findFirst({
       where: { slug, ownerId: auth.user.id },
@@ -122,7 +141,7 @@ export async function POST(request: Request) {
       action: "create",
       notes: incoming.notes.length,
       connection: connectionState,
-      connectionName: incoming.connection?.name,
+      connectionName: (fehlend[0] ?? beschrieben[0])?.connection?.name,
     };
 
     if (existing && strategy === "skip") {
@@ -145,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,
@@ -154,11 +175,6 @@ export async function POST(request: Request) {
       accent: incoming.accent,
       tags: incoming.tags,
       favorite: incoming.favorite,
-      autoSync: incoming.autoSync,
-      repoUrl: incoming.repoUrl ?? null,
-      repoOwner: incoming.repoOwner ?? null,
-      repoName: incoming.repoName ?? null,
-      connectionId: connection?.id ?? null,
       progressFromTasks: incoming.progressFromTasks,
     };
 
@@ -194,23 +210,43 @@ export async function POST(request: Request) {
         await prisma.$transaction([
           prisma.note.deleteMany({ where: { projectId: existing.id } }),
           prisma.task.deleteMany({ where: { projectId: existing.id } }),
+          // Wie Notizen und Aufgaben: austauschen statt zusammenfuehren. Der
+          // gesammelte Repo-Stand geht dabei mit, ist aber beim naechsten
+          // Abgleich zurueck.
+          prisma.repository.deleteMany({ where: { projectId: existing.id } }),
           prisma.project.update({
             where: { id: existing.id },
-            data: { ...data, slug, notes: { create: notes }, tasks: { create: tasks } },
+            data: {
+              ...data,
+              slug,
+              notes: { create: notes },
+              tasks: { create: tasks },
+              repositories: { create: repos },
+            },
           }),
         ]);
         results.push({ ...base, action: "overwrite" });
       } else {
         const finalSlug = existing ? await uniqueSlug(incoming.name, auth.user.id) : slug;
-        await prisma.project.create({
+        const angelegt = await prisma.project.create({
           data: {
             ...data,
             ownerId: auth.user.id,
             slug: finalSlug,
             notes: { create: notes },
             tasks: { create: tasks },
+            repositories: { create: repos },
           },
         });
+        // Der Verlauf wird nicht mitexportiert – der erste Eintrag hier haelt
+        // wenigstens fest, woher das Projekt stammt.
+        await recordActivity({
+          projectId: angelegt.id,
+          userId: auth.user.id,
+          kind: "PROJECT_CREATED",
+          summary: "Aus einer Exportdatei importiert",
+          meta: { notes: notes.length, tasks: tasks.length },
+        });
         results.push({
           ...base,
           action: existing ? "rename" : "create",

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

@@ -1,10 +1,12 @@
 import { NextResponse } from "next/server";
+import { recordActivity } from "@/lib/activity";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
-import { parseRepoUrl } from "@/lib/git";
+import { nextProjectPosition, projectListInclude, uniqueSlug } from "@/lib/projects";
-import { 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";
+import { statusOf } from "@/lib/status";
 import { formatZodError, projectCreateSchema } from "@/lib/validation";
 
 export const dynamic = "force-dynamic";
@@ -72,18 +74,21 @@ export async function POST(request: Request) {
     if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
   }
 
-  // Owner/Name aus der URL ableiten, falls nicht explizit angegeben.
+  // Aus der Vorlage kommen nur Notizen und Aufgaben. Die Stammdaten hat die
-  let repoOwner = data.repoOwner ?? null;
+  // Oberflaeche schon in die Felder uebernommen, damit man sie vor dem
-  let repoName = data.repoName ?? null;
+  // Speichern noch sieht und aendern kann.
-  if (data.repoUrl && (!repoOwner || !repoName)) {
+  const vorlage = data.templateId
-    const parsedUrl = parseRepoUrl(data.repoUrl);
+    ? await prisma.projectTemplate.findFirst({
-    if (parsedUrl) {
+        where: { id: data.templateId, ownerId: auth.user.id },
-      repoOwner = repoOwner ?? parsedUrl.owner;
+        select: { name: true, notes: true, tasks: true },
-      repoName = repoName ?? parsedUrl.name;
+      })
-    }
+    : null;
-  }
+  if (data.templateId && !vorlage) return jsonError("Vorlage nicht gefunden.", 404);
 
-  const project = await prisma.project.create({
+  const notes = templateNotes(vorlage?.notes);
+  const tasks = templateTasks(vorlage?.tasks);
+
+  const angelegt = await prisma.project.create({
     data: {
       ownerId: auth.user.id,
       name: data.name,
@@ -96,14 +101,83 @@ export async function POST(request: Request) {
       accent: data.accent,
       tags: data.tags,
       favorite: data.favorite,
-      autoSync: data.autoSync,
+      progressFromTasks: data.progressFromTasks,
-      repoUrl: data.repoUrl ?? null,
+      // Hinten an die Statusspalte des Bretts.
-      repoOwner,
+      position: await nextProjectPosition(auth.user.id, data.status),
-      repoName,
+      notes: { create: notes },
-      connectionId: data.connectionId ?? null,
+      tasks: { create: tasks },
     },
+    select: { id: true },
+  });
+
+  // Die Git-Angaben werden zum fuehrenden Repository – falls welche kamen.
+  await applyLeadingRepo(angelegt.id, {
+    repoUrl: data.repoUrl,
+    repoOwner: data.repoOwner,
+    repoName: data.repoName,
+    connectionId: data.connectionId,
+    autoSync: data.autoSync,
+  });
+
+  const project = await prisma.project.findUniqueOrThrow({
+    where: { id: angelegt.id },
     include: projectListInclude,
   });
 
+  await recordActivity({
+    projectId: project.id,
+    userId: auth.user.id,
+    kind: "PROJECT_CREATED",
+    summary: vorlage
+      ? `Aus Vorlage „${vorlage.name}“ angelegt`
+      : data.status === "IDEA"
+        ? "Als Idee angelegt"
+        : `Angelegt mit Status „${statusOf(data.status).label}“`,
+    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]/route.ts

@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import { recordActivity, shorten } from "@/lib/activity";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { connectionSafeSelect } from "@/lib/projects";
+import { completeRepoInput, ownedRepository, repoTitle } from "@/lib/repositories";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { formatZodError, repositoryUpdateSchema } 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 ownedRepository(id, auth.user.id);
+  if (!existing) return jsonError("Repository nicht gefunden", 404);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = repositoryUpdateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const eingabe = completeRepoInput(parsed.data);
+
+  if (eingabe.connectionId) {
+    const connection = await prisma.gitConnection.findFirst({
+      where: { id: eingabe.connectionId, ownerId: auth.user.id },
+      select: { id: true },
+    });
+    if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
+  }
+
+  const data: Record<string, unknown> = {};
+  for (const key of ["label", "repoUrl", "repoOwner", "repoName", "connectionId", "autoSync"] as const) {
+    if (eingabe[key] !== undefined) data[key] = eingabe[key];
+  }
+  if (parsed.data.position !== undefined) data.position = parsed.data.position;
+
+  // Zeigt das Repo woandershin, taugt der gesammelte Stand nicht mehr. Ihn
+  // stehen zu lassen waere schlimmer als ihn zu verlieren: er saehe echt aus.
+  const zieltWoandershin =
+    (eingabe.repoOwner !== undefined && eingabe.repoOwner !== existing.repoOwner) ||
+    (eingabe.repoName !== undefined && eingabe.repoName !== existing.repoName);
+  if (zieltWoandershin) {
+    data.lastSyncedAt = null;
+    data.syncError = null;
+    data.syncFailureCount = 0;
+    data.notifiedSyncError = null;
+    data.notifiedCiState = null;
+    data.notifiedRelease = null;
+    await prisma.repoSnapshot.deleteMany({ where: { repositoryId: id } });
+  }
+
+  const repository = await prisma.repository.update({
+    where: { id },
+    data,
+    include: { connection: { select: connectionSafeSelect }, snapshot: true },
+  });
+
+  return NextResponse.json({ repository });
+}
+
+export async function DELETE(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+
+  // Vor dem Loeschen lesen: danach ist nicht mehr feststellbar, worum es ging.
+  const vorher = await ownedRepository(id, auth.user.id);
+  if (!vorher) return jsonError("Repository nicht gefunden", 404);
+
+  await prisma.repository.delete({ where: { id } });
+
+  await recordActivity({
+    projectId: vorher.projectId,
+    userId: auth.user.id,
+    kind: "REPO_LINKED",
+    summary: `Repository entfernt: ${shorten(repoTitle(vorher))}`,
+  });
+
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { connectionSafeSelect } from "@/lib/projects";
+import { ownedRepository } from "@/lib/repositories";
+import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
+import { clientIp, jsonError, tooManyRequests } from "@/lib/security/request";
+import { syncRepository } from "@/lib/sync";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/** Gleicht ein einzelnes Repository ab. */
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  // Dieser Endpunkt loest ausgehende Verbindungen aus – hier wird enger
+  // begrenzt als bei reinen Datenbankzugriffen.
+  const limited = rateLimit(
+    `outbound:${auth.user.id}:${clientIp(request)}`,
+    LIMITS.outbound.limit,
+    LIMITS.outbound.windowMs,
+  );
+  if (!limited.ok) return tooManyRequests(limited.retryAfter);
+
+  const { id } = await params;
+  if (!(await ownedRepository(id, auth.user.id))) {
+    return jsonError("Repository nicht gefunden", 404);
+  }
+
+  const result = await syncRepository(id);
+
+  const repository = await prisma.repository.findUnique({
+    where: { id },
+    include: { connection: { select: connectionSafeSelect }, snapshot: true },
+  });
+
+  return NextResponse.json({ ...result, repository }, { status: result.ok ? 200 : 502 });
+}

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

@@ -1,8 +1,16 @@
+import type { TaskStatus } from "@prisma/client";
 import { NextResponse } from "next/server";
+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 { 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";
@@ -13,7 +21,7 @@ type Params = { params: Promise<{ id: string }> };
 async function ownedTask(taskId: string, ownerId: string) {
   return prisma.task.findFirst({
     where: { id: taskId, project: { ownerId } },
-    select: { id: true, projectId: true, status: true },
+    select: { id: true, projectId: true, status: true, title: true },
   });
 }
 
@@ -42,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;
   }
@@ -55,9 +64,51 @@ 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);
 
-  return NextResponse.json({ task });
+  /**
+   * 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.
+  if (update.status !== undefined) {
+    const nach = update.status as TaskStatus;
+    await recordActivity({
+      projectId: existing.projectId,
+      userId: auth.user.id,
+      kind: "TASK_MOVED",
+      summary: folge
+        ? `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, next: folge });
 }
 
 export async function DELETE(_request: Request, { params }: Params) {
@@ -71,5 +122,12 @@ export async function DELETE(_request: Request, { params }: Params) {
   await prisma.task.delete({ where: { id } });
   await refreshDerivedProgress(existing.projectId);
 
+  await recordActivity({
+    projectId: existing.projectId,
+    userId: auth.user.id,
+    kind: "TASK_DELETED",
+    summary: `Aufgabe gelöscht: ${shorten(existing.title, 50)}`,
+  });
+
   return NextResponse.json({ ok: true });
 }

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

src/app/components.css

@@ -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/connections/page.tsx

@@ -17,7 +17,7 @@ export default async function ConnectionsPage() {
 
   const connections = await prisma.gitConnection.findMany({
     where: { ownerId: user.id },
-    select: { ...connectionSafeSelect, _count: { select: { projects: true } } },
+    select: { ...connectionSafeSelect, _count: { select: { repositories: true } } },
     orderBy: { name: "asc" },
   });
 

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,6 @@
 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";
 import { APP_NAME, APP_TAGLINE, APP_VERSION } from "@/lib/config";
@@ -19,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",
+    },
   };
 }
 
@@ -26,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({
@@ -45,6 +66,9 @@ export default async function RootLayout({
 
         <TopNav user={user} appName={APP_NAME} tagline={APP_TAGLINE} />
 
+        {/* Nur fuer Angemeldete – auf der Anmeldeseite gibt es nichts zu suchen. */}
+        {user ? <CommandPalette isAdmin={user.role === "ADMIN"} /> : null}
+
         <main className="mx-auto w-full max-w-[1400px] px-4 pb-24 pt-6 sm:px-6 lg:px-8">
           {children}
         </main>
@@ -52,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

@@ -29,7 +29,7 @@ export default async function DashboardPage() {
   const ideas = active.filter((project) => project.status === "IDEA").length;
   const inDev = active.filter((project) => project.status === "IN_DEVELOPMENT").length;
   const done = active.filter((project) => project.status === "DONE").length;
-  const linked = active.filter((project) => Boolean(project.repoOwner && project.repoName)).length;
+  const linked = active.filter((project) => project.repositories.length > 0).length;
 
   const averageProgress =
     active.length > 0
@@ -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

@@ -1,15 +1,17 @@
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import { FileText } from "lucide-react";
+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";
@@ -53,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
@@ -66,8 +85,16 @@ export default async function ProjectPage({ params }: PageProps) {
         progressFromTasks={detail.progressFromTasks}
       />
 
+      {/*
+        min-w-0 an beiden Spalten ist hier nicht Kosmetik, sondern der Kern:
+        ein Rasterkind hat "min-width: auto" und weigert sich damit, unter
+        die Inhaltsbreite seines breitesten Kindes zu schrumpfen. Die
+        Heatmap ist ueber 700px breit – auf dem Telefon zog sie damit die
+        ganze Spalte und mit ihr die Seite auseinander. Erst mit min-w-0
+        greift das overflow-x-auto darin ueberhaupt.
+      */}
       <div className="grid gap-6 lg:grid-cols-12">
-        <div className="space-y-6 lg:col-span-5">
+        <div className="min-w-0 space-y-6 lg:col-span-5">
           <section className="glass p-5">
             <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-300">
               <FileText className="h-4 w-4 text-cyan-300" />
@@ -82,11 +109,27 @@ 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>
 
-        <div className="lg:col-span-7">
+        <div className="min-w-0 space-y-6 lg:col-span-7">
-          <GitPanel project={detail} />
+          <GitPanel
+            project={detail}
+            connections={connections as unknown as ConnectionSafe[]}
+            webhookRepoIds={webhookIds}
+          />
+          <ActivityFeed projectId={detail.id} initial={detail.activities} />
         </div>
       </div>
     </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/ActivityFeed.tsx

@@ -0,0 +1,148 @@
+"use client";
+
+import { useState } from "react";
+import {
+  AlertTriangle,
+  ArrowRight,
+  Bot,
+  Download,
+  GitCommitHorizontal,
+  History,
+  Link2,
+  Loader2,
+  NotebookPen,
+  Pencil,
+  Plus,
+  Signpost,
+  Sparkles,
+  Trash2,
+} from "lucide-react";
+import type { ActivityEntry, ActivityKind } from "@/types";
+import { formatDateTime, formatRelative } from "@/lib/utils";
+
+/**
+ * Der Verlauf eines Projekts: was ist wann passiert.
+ *
+ * Die erste Seite kommt mit der Seite mit, weitere holt der Knopf nach. Die
+ * Alternative – alles gleich mitzuladen – wuerde jeden Seitenaufruf mit
+ * zweihundert Eintraegen belasten, von denen man selten mehr als die
+ * obersten fuenf liest.
+ */
+
+const KINDS: Record<ActivityKind, { icon: typeof Sparkles; color: string }> = {
+  PROJECT_CREATED: { icon: Sparkles, color: "text-violet-300" },
+  PROJECT_UPDATED: { icon: Pencil, color: "text-slate-400" },
+  STATUS_CHANGED: { icon: Signpost, color: "text-cyan-300" },
+  NOTE_ADDED: { icon: NotebookPen, color: "text-blue-300" },
+  NOTE_UPDATED: { icon: Pencil, color: "text-blue-300" },
+  NOTE_DELETED: { icon: Trash2, color: "text-rose-300" },
+  TASK_ADDED: { icon: Plus, color: "text-emerald-300" },
+  TASK_MOVED: { icon: ArrowRight, color: "text-violet-300" },
+  TASK_DELETED: { icon: Trash2, color: "text-rose-300" },
+  TASKS_IMPORTED: { icon: Download, color: "text-amber-300" },
+  REPO_LINKED: { icon: Link2, color: "text-cyan-300" },
+  REPO_COMMITS: { icon: GitCommitHorizontal, color: "text-emerald-300" },
+  SYNC_FAILED: { icon: AlertTriangle, color: "text-rose-300" },
+};
+
+export function ActivityFeed({
+  projectId,
+  initial,
+}: {
+  projectId: string;
+  initial: ActivityEntry[];
+}) {
+  const [entries, setEntries] = useState(initial);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  // Kam eine volle Seite, gibt es womoeglich noch mehr.
+  const [complete, setComplete] = useState(initial.length < 20);
+
+  async function loadAll() {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch(`/api/projects/${projectId}/activity?limit=200`);
+      if (!response.ok) throw new Error("Verlauf konnte nicht geladen werden.");
+      const payload = await response.json();
+      setEntries(payload.activities as ActivityEntry[]);
+      setComplete(true);
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <section className="glass p-5">
+      <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-300">
+        <History className="h-4 w-4 text-violet-300" />
+        Verlauf
+      </h2>
+
+      {entries.length === 0 ? (
+        <p className="mt-3 text-sm text-slate-500">
+          Noch nichts passiert. Sobald du etwas änderst, steht es hier.
+        </p>
+      ) : (
+        <ol className="mt-4 space-y-0">
+          {entries.map((entry, index) => {
+            const meta = KINDS[entry.kind] ?? KINDS.PROJECT_UPDATED;
+            const Icon = meta.icon;
+            const letzter = index === entries.length - 1;
+
+            return (
+              <li key={entry.id} className="relative flex gap-3 pb-4">
+                {/* Die Linie endet am letzten Eintrag, statt ins Leere zu laufen. */}
+                {!letzter ? (
+                  <span
+                    aria-hidden
+                    className="absolute left-3 top-7 h-[calc(100%-1.25rem)] w-px bg-white/15"
+                  />
+                ) : null}
+
+                <span className="relative z-10 mt-0.5 flex h-6 w-6 shrink-0 items-center justify-center rounded-full bg-[#0d1020] ring-1 ring-white/10">
+                  <Icon className={`h-3.5 w-3.5 ${meta.color}`} />
+                </span>
+
+                <div className="min-w-0 flex-1">
+                  <p className="text-sm leading-snug text-slate-200">{entry.summary}</p>
+                  <p className="mt-0.5 flex items-center gap-1.5 text-xs text-slate-500">
+                    <time dateTime={new Date(entry.createdAt).toISOString()}>
+                      {formatRelative(entry.createdAt)}
+                    </time>
+                    <span aria-hidden>·</span>
+                    <span>{formatDateTime(entry.createdAt)}</span>
+                    {/* Ohne Benutzer war es der automatische Abgleich. */}
+                    {entry.user ? null : (
+                      <>
+                        <span aria-hidden>·</span>
+                        <Bot className="h-3 w-3" aria-hidden />
+                        <span>automatisch</span>
+                      </>
+                    )}
+                  </p>
+                </div>
+              </li>
+            );
+          })}
+        </ol>
+      )}
+
+      {error ? <p className="mt-2 text-xs text-rose-300">{error}</p> : null}
+
+      {!complete ? (
+        <button
+          type="button"
+          onClick={loadAll}
+          disabled={loading}
+          className="btn btn-ghost mt-1 w-full text-xs"
+        >
+          {loading ? <Loader2 className="h-3.5 w-3.5 animate-spin" /> : null}
+          Älteres anzeigen
+        </button>
+      ) : null}
+    </section>
+  );
+}

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

@@ -0,0 +1,388 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useRouter } from "next/navigation";
+import {
+  Bell,
+  CheckSquare,
+  CornerDownLeft,
+  GitBranch,
+  LayoutDashboard,
+  Loader2,
+  NotebookPen,
+  Plus,
+  Search,
+  Settings,
+  UserRound,
+} from "lucide-react";
+import type { ProjectStatus } from "@prisma/client";
+import { statusOf } from "@/lib/status";
+import { cn } from "@/lib/utils";
+
+/**
+ * Schnellsuche, zu erreichen mit Strg+K beziehungsweise Cmd+K.
+ *
+ * Springt zu einem Projekt, zu einer Notiz oder direkt in einen Bereich.
+ * Die Projektliste wird beim ersten Oeffnen geholt und dann behalten – sie
+ * bei jedem Tastendruck neu zu laden waere Verschwendung, und veraltet ist
+ * sie hoechstens um die Dauer einer Sitzung.
+ */
+
+interface ProjectHit {
+  id: string;
+  name: string;
+  slug: string;
+  summary: string | null;
+  status: ProjectStatus;
+  tags: string[];
+}
+
+interface NoteHit {
+  projectId: string;
+  noteId: string;
+  title: string | null;
+  snippet: string;
+}
+
+interface Action {
+  id: string;
+  label: string;
+  hint: string;
+  icon: typeof LayoutDashboard;
+  href: string;
+  adminOnly?: boolean;
+}
+
+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",
+    hint: "GitHub, GitLab, Gitea",
+    icon: GitBranch,
+    href: "/connections",
+  },
+  { id: "account", label: "Mein Konto", hint: "Profil, Passkeys", icon: UserRound, href: "/account" },
+  {
+    id: "notify",
+    label: "Benachrichtigungen",
+    hint: "Ziele verwalten",
+    icon: Bell,
+    href: "/account",
+  },
+  {
+    id: "admin",
+    label: "Admin-Einstellungen",
+    hint: "Betriebsart, Abgleich, Konten",
+    icon: Settings,
+    href: "/admin",
+    adminOnly: true,
+  },
+];
+
+type Entry =
+  | { kind: "action"; key: string; action: Action }
+  | { kind: "project"; key: string; project: ProjectHit }
+  | { kind: "note"; key: string; note: NoteHit; projectName: string };
+
+export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
+  const router = useRouter();
+  const [mounted, setMounted] = useState(false);
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [projects, setProjects] = useState<ProjectHit[] | null>(null);
+  const [notes, setNotes] = useState<NoteHit[]>([]);
+  const [active, setActive] = useState(0);
+  const [loading, setLoading] = useState(false);
+  const listRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => setMounted(true), []);
+
+  // Strg+K oeffnet, Escape schliesst. In Eingabefeldern nicht stoeren –
+  // ausser beim Kuerzel selbst, das soll ueberall greifen.
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
+        event.preventDefault();
+        setOpen((value) => !value);
+      } else if (event.key === "Escape") {
+        setOpen(false);
+      }
+    }
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, []);
+
+  // Projektliste beim ersten Oeffnen holen.
+  useEffect(() => {
+    if (!open || projects !== null) return;
+    setLoading(true);
+    fetch("/api/projects")
+      .then((response) => (response.ok ? response.json() : { projects: [] }))
+      .then((body) => setProjects(body.projects ?? []))
+      .catch(() => setProjects([]))
+      .finally(() => setLoading(false));
+  }, [open, projects]);
+
+  // Notizen sucht der Server – entprellt, wie im Board.
+  useEffect(() => {
+    if (!open) return;
+    const needle = query.trim();
+    if (needle.length < 2) {
+      setNotes([]);
+      return;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(async () => {
+      try {
+        const response = await fetch(`/api/search?q=${encodeURIComponent(needle)}`, {
+          signal: controller.signal,
+        });
+        if (!response.ok) return;
+        const body = (await response.json()) as { hits: NoteHit[] };
+        setNotes(body.hits ?? []);
+      } catch {
+        // Abbruch beim Weitertippen ist der Normalfall.
+      }
+    }, 250);
+    return () => {
+      clearTimeout(timer);
+      controller.abort();
+    };
+  }, [open, query]);
+
+  useEffect(() => {
+    if (!open) {
+      setQuery("");
+      setNotes([]);
+      setActive(0);
+    }
+  }, [open]);
+
+  const entries = useMemo<Entry[]>(() => {
+    const needle = query.toLowerCase().trim();
+    const result: Entry[] = [];
+
+    const passendeAktionen = ACTIONS.filter(
+      (action) =>
+        (!action.adminOnly || isAdmin) &&
+        (!needle ||
+          action.label.toLowerCase().includes(needle) ||
+          action.hint.toLowerCase().includes(needle)),
+    );
+
+    const passendeProjekte = (projects ?? []).filter(
+      (project) =>
+        !needle ||
+        project.name.toLowerCase().includes(needle) ||
+        (project.summary ?? "").toLowerCase().includes(needle) ||
+        project.tags.some((tag) => tag.includes(needle)),
+    );
+
+    // Bei leerer Eingabe stehen die Projekte oben – danach sucht man
+    // normalerweise.
+    if (!needle) {
+      for (const project of passendeProjekte.slice(0, 6)) {
+        result.push({ kind: "project", key: `p-${project.id}`, project });
+      }
+      for (const action of passendeAktionen) {
+        result.push({ kind: "action", key: `a-${action.id}`, action });
+      }
+      return result;
+    }
+
+    for (const project of passendeProjekte.slice(0, 8)) {
+      result.push({ kind: "project", key: `p-${project.id}`, project });
+    }
+    for (const hit of notes.slice(0, 5)) {
+      result.push({
+        kind: "note",
+        key: `n-${hit.noteId}`,
+        note: hit,
+        projectName:
+          (projects ?? []).find((project) => project.id === hit.projectId)?.name ?? "Projekt",
+      });
+    }
+    for (const action of passendeAktionen) {
+      result.push({ kind: "action", key: `a-${action.id}`, action });
+    }
+    return result;
+  }, [query, projects, notes, isAdmin]);
+
+  useEffect(() => {
+    setActive((current) => Math.min(current, Math.max(0, entries.length - 1)));
+  }, [entries.length]);
+
+  const go = useCallback(
+    (entry: Entry) => {
+      setOpen(false);
+      if (entry.kind === "action") router.push(entry.action.href);
+      else if (entry.kind === "project") router.push(`/projects/${entry.project.id}`);
+      else router.push(`/projects/${entry.note.projectId}`);
+    },
+    [router],
+  );
+
+  function onInputKey(event: React.KeyboardEvent) {
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      setActive((current) => (current + 1) % Math.max(1, entries.length));
+    } else if (event.key === "ArrowUp") {
+      event.preventDefault();
+      setActive((current) => (current - 1 + entries.length) % Math.max(1, entries.length));
+    } else if (event.key === "Enter") {
+      event.preventDefault();
+      const entry = entries[active];
+      if (entry) go(entry);
+    }
+  }
+
+  // Ausgewaehlten Eintrag im Blick behalten.
+  useEffect(() => {
+    listRef.current
+      ?.querySelector<HTMLElement>(`[data-index="${active}"]`)
+      ?.scrollIntoView({ block: "nearest" });
+  }, [active]);
+
+  if (!mounted || !open) return null;
+
+  return createPortal(
+    <div className="fixed inset-0 z-[130] flex items-start justify-center p-4 pt-[12vh]">
+      <button
+        type="button"
+        aria-label="Schnellsuche schliessen"
+        onClick={() => setOpen(false)}
+        className="fixed inset-0 cursor-default bg-[#03040c]/80 backdrop-blur-sm"
+      />
+
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-label="Schnellsuche"
+        className="popover fade-up relative z-10 w-full max-w-xl overflow-hidden rounded-2xl"
+      >
+        <div className="flex items-center gap-3 border-b border-white/8 px-4 py-3">
+          <Search className="h-4 w-4 shrink-0 text-slate-500" />
+          <input
+            autoFocus
+            value={query}
+            onChange={(event) => setQuery(event.target.value)}
+            onKeyDown={onInputKey}
+            placeholder="Projekt, Notiz oder Bereich…"
+            className="w-full bg-transparent text-sm text-slate-100 outline-none placeholder:text-slate-600"
+          />
+          {loading ? <Loader2 className="h-3.5 w-3.5 animate-spin text-slate-600" /> : null}
+        </div>
+
+        <div ref={listRef} className="max-h-[22rem] overflow-y-auto p-1.5">
+          {entries.length === 0 ? (
+            <p className="px-3 py-8 text-center text-sm text-slate-500">
+              {loading ? "Lade…" : "Nichts gefunden."}
+            </p>
+          ) : (
+            entries.map((entry, index) => (
+              <button
+                key={entry.key}
+                type="button"
+                data-index={index}
+                onMouseMove={() => setActive(index)}
+                onClick={() => go(entry)}
+                className={cn(
+                  "flex w-full items-start gap-3 rounded-lg px-3 py-2 text-left transition-colors",
+                  index === active ? "bg-white/8" : "hover:bg-white/5",
+                )}
+              >
+                {entry.kind === "action" ? (
+                  <>
+                    <entry.action.icon className="mt-0.5 h-4 w-4 shrink-0 text-slate-500" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.action.label}
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.action.hint}
+                      </span>
+                    </span>
+                  </>
+                ) : entry.kind === "project" ? (
+                  <>
+                    <span
+                      className="mt-1.5 h-2 w-2 shrink-0 rounded-full"
+                      style={{ backgroundColor: statusOf(entry.project.status).color }}
+                    />
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.project.name}
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.project.summary ?? statusOf(entry.project.status).label}
+                      </span>
+                    </span>
+                    <span className="mt-0.5 shrink-0 text-[10px] uppercase tracking-wider text-slate-600">
+                      {statusOf(entry.project.status).short}
+                    </span>
+                  </>
+                ) : (
+                  <>
+                    <NotebookPen className="mt-0.5 h-4 w-4 shrink-0 text-violet-300/70" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.note.title ?? "Notiz"}
+                        <span className="ml-1.5 text-[11px] text-slate-500">
+                          in {entry.projectName}
+                        </span>
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.note.snippet.replace(/\[\[|\]\]/g, "")}
+                      </span>
+                    </span>
+                  </>
+                )}
+              </button>
+            ))
+          )}
+        </div>
+
+        <div className="flex items-center gap-4 border-t border-white/6 px-4 py-2 text-[10px] text-slate-600">
+          <span className="inline-flex items-center gap-1">
+            <Kbd>↑</Kbd>
+            <Kbd>↓</Kbd>
+            waehlen
+          </span>
+          <span className="inline-flex items-center gap-1">
+            <Kbd>
+              <CornerDownLeft className="h-2.5 w-2.5" />
+            </Kbd>
+            oeffnen
+          </span>
+          <span className="inline-flex items-center gap-1">
+            <Kbd>Esc</Kbd>
+            schliessen
+          </span>
+          <span className="ml-auto inline-flex items-center gap-1">
+            <Plus className="h-2.5 w-2.5" />
+            <Kbd>Strg</Kbd>
+            <Kbd>K</Kbd>
+          </span>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+function Kbd({ children }: { children: React.ReactNode }) {
+  return (
+    <kbd className="inline-flex min-w-[1.2rem] items-center justify-center rounded border border-white/12 bg-white/5 px-1 py-0.5 font-sans text-[10px] text-slate-400">
+      {children}
+    </kbd>
+  );
+}

src/components/ConnectionsManager.tsx

@@ -140,8 +140,8 @@ export function ConnectionsManager({ connections }: { connections: ConnectionWit
   }
 
   async function remove(connection: ConnectionWithCount) {
-    const linked = connection._count?.projects ?? 0;
+    const linked = connection._count?.repositories ?? 0;
-    const hint = linked > 0 ? `\n\n${linked} Projekt(e) verlieren die Verknuepfung.` : "";
+    const hint = linked > 0 ? `\n\n${linked} Repository(s) verlieren die Verknuepfung.` : "";
     if (!window.confirm(`Verbindung „${connection.name}“ loeschen?${hint}`)) return;
     setBusyId(connection.id);
     await fetch(`/api/connections/${connection.id}`, { method: "DELETE" }).catch(() => undefined);
@@ -257,9 +257,9 @@ export function ConnectionsManager({ connections }: { connections: ConnectionWit
                     </div>
                   ) : null}
                   <div className="flex items-start justify-between gap-3">
-                    <dt className="text-slate-500">Projekte</dt>
+                    <dt className="text-slate-500">Repositories</dt>
                     <dd className="tabular-nums text-slate-300">
-                      {connection._count?.projects ?? 0}
+                      {connection._count?.repositories ?? 0}
                     </dd>
                   </div>
                   {connection.lastCheckedAt ? (

src/components/GitPanel.tsx

@@ -12,22 +12,32 @@ import {
   GitMerge,
   GitPullRequest,
   HardDrive,
+  ListPlus,
   Loader2,
   Lock,
   Package,
+  Plus,
+  Radio,
   RefreshCw,
   ShieldCheck,
   Star,
   Tag,
+  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 { asArray, asRecord } from "@/types";
+import { repoTitle } from "@/lib/git/meta";
+import { asArray, asCalendar, asRecord } from "@/types";
 import type {
   BranchInfo,
   CommitInfo,
+  ConnectionSafe,
   ProjectDetail,
   ReleaseInfo,
+  RepositoryWithSnapshot,
   TagInfo,
   TicketInfo,
 } from "@/types";
@@ -44,13 +54,62 @@ const TABS = [
 
 type TabKey = (typeof TABS)[number]["key"];
 
-export function GitPanel({ project }: { project: ProjectDetail }) {
+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");
   const [syncing, setSyncing] = useState(false);
+  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 snapshot = project.snapshot;
+  const repositories = project.repositories;
+  const [selectedId, setSelectedId] = useState<string | null>(repositories[0]?.id ?? null);
+
+  // 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() {
+    if (!repository) return;
+    setImporting(true);
+    setMessage(null);
+    try {
+      const response = await fetch(`/api/projects/${project.id}/tasks/from-issues`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ repositoryId: repository.id }),
+      });
+      const body = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(body.error ?? "Uebernahme fehlgeschlagen.");
+      setMessage({
+        ok: true,
+        text:
+          body.created === 0
+            ? `Nichts Neues – alle ${body.skipped} Issues sind bereits als Aufgabe vorhanden.`
+            : `${body.created} Aufgabe(n) angelegt${body.skipped ? `, ${body.skipped} uebersprungen` : ""}.`,
+      });
+      router.refresh();
+    } catch (caught) {
+      setMessage({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
+    } finally {
+      setImporting(false);
+    }
+  }
+
+  const snapshot = repository?.snapshot ?? null;
   const branches = asArray<BranchInfo>(snapshot?.branches);
   const tags = asArray<TagInfo>(snapshot?.tags);
   const commits = asArray<CommitInfo>(snapshot?.commits);
@@ -59,14 +118,17 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
   const pulls = asArray<TicketInfo>(snapshot?.pullRequests);
   const issues = asArray<TicketInfo>(snapshot?.issues);
   const activity = asArray<number>(snapshot?.commitActivity);
+  const calendar = asCalendar(snapshot?.commitCalendar);
 
-  const hasRepo = Boolean(project.repoOwner && project.repoName) || Boolean(project.repoUrl);
+  /** Ein einzelnes Repository oder – ohne Argument – alle. */
-
+  async function sync(nurDieses?: string) {
-  async function sync() {
     setSyncing(true);
     setMessage(null);
     try {
-      const response = await fetch(`/api/projects/${project.id}/sync`, { method: "POST" });
+      const url = nurDieses
+        ? `/api/repositories/${nurDieses}/sync`
+        : `/api/projects/${project.id}/sync`;
+      const response = await fetch(url, { method: "POST" });
       const payload = await response.json().catch(() => ({}));
       setMessage({ ok: response.ok, text: payload.message ?? "Unbekannte Antwort." });
       router.refresh();
@@ -80,16 +142,41 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
     }
   }
 
-  if (!hasRepo) {
+  async function removeRepository(entry: RepositoryWithSnapshot) {
+    if (
+      !window.confirm(
+        `„${repoTitle(entry)}“ vom Projekt loesen? Der geholte Stand geht dabei verloren.`,
+      )
+    ) {
+      return;
+    }
+    await fetch(`/api/repositories/${entry.id}`, { method: "DELETE" }).catch(() => undefined);
+    setSelectedId(null);
+    router.refresh();
+  }
+
+  if (!repository) {
     return (
+      <>
         <div className="glass px-5 py-10 text-center">
           <GitBranch className="mx-auto h-8 w-8 text-slate-600" />
           <h3 className="mt-3 text-sm font-semibold text-slate-200">Kein Repository verknuepft</h3>
           <p className="mx-auto mt-1 max-w-sm text-sm text-slate-500">
-          Hinterlege im Projekt eine Repository-URL und waehle eine Git-Verbindung, um
+            Verknuepfe ein Repository, um Branches, Tags, Commits und Releases hier zu sehen.
-          Branches, Tags, Commits und Releases hier zu sehen.
+            Ein Projekt darf auch mehrere haben – etwa Frontend und Backend.
           </p>
+          <button type="button" className="btn btn-primary mt-4" onClick={() => setAddOpen(true)}>
+            <Plus className="h-4 w-4" />
+            Repository verknuepfen
+          </button>
         </div>
+        <RepositoryDialog
+          open={addOpen}
+          onClose={() => setAddOpen(false)}
+          projectId={project.id}
+          connections={connections}
+        />
+      </>
     );
   }
 
@@ -100,12 +187,53 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
 
   return (
     <div className="space-y-4">
+      {/* Auswahl, sobald es mehr als eines gibt. Bei einem einzigen waere eine
+          Leiste mit genau einem Knopf nur Ballast. */}
+      {repositories.length > 1 ? (
+        <div className="glass flex flex-wrap items-center gap-1.5 p-2" role="tablist">
+          {repositories.map((entry) => {
+            const aktiv = entry.id === repository.id;
+            return (
+              <button
+                key={entry.id}
+                type="button"
+                role="tab"
+                aria-selected={aktiv}
+                onClick={() => setSelectedId(entry.id)}
+                className={cn(
+                  "flex items-center gap-2 rounded-lg px-3 py-1.5 text-xs transition-colors",
+                  aktiv
+                    ? "bg-white/9 text-white"
+                    : "text-slate-400 hover:bg-white/5 hover:text-slate-200",
+                )}
+              >
+                {entry.syncError ? (
+                  <AlertTriangle className="h-3 w-3 text-rose-300" />
+                ) : (
+                  <GitBranch className="h-3 w-3 text-slate-500" />
+                )}
+                {repoTitle(entry)}
+              </button>
+            );
+          })}
+          <button
+            type="button"
+            onClick={() => setAddOpen(true)}
+            className="ml-auto rounded-lg p-1.5 text-slate-500 transition-colors hover:bg-white/5 hover:text-violet-300"
+            aria-label="Weiteres Repository verknuepfen"
+            title="Weiteres Repository verknuepfen"
+          >
+            <Plus className="h-3.5 w-3.5" />
+          </button>
+        </div>
+      ) : null}
+
       {/* Kopf mit Sync */}
       <div className="glass flex flex-wrap items-center justify-between gap-3 p-4">
         <div className="min-w-0">
           <div className="flex items-center gap-2">
             <h2 className="truncate font-mono text-sm text-slate-100">
-              {snapshot?.fullName ?? `${project.repoOwner}/${project.repoName}`}
+              {snapshot?.fullName ?? repoTitle(repository)}
             </h2>
             {snapshot?.visibility ? (
               <span className="inline-flex items-center gap-1 rounded-md bg-white/6 px-1.5 py-0.5 text-[10px] uppercase tracking-wider text-slate-400">
@@ -131,13 +259,68 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
             <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} url={snapshot?.ciUrl} />
           </div>
           <p className="mt-1 text-xs text-slate-500" suppressHydrationWarning>
-            {project.lastSyncedAt
+            {repository.lastSyncedAt
-              ? `Zuletzt synchronisiert ${formatRelative(project.lastSyncedAt)} · ${formatDateTime(project.lastSyncedAt)}`
+              ? `Zuletzt synchronisiert ${formatRelative(repository.lastSyncedAt)} · ${formatDateTime(repository.lastSyncedAt)}`
               : "Noch nie synchronisiert."}
           </p>
         </div>
 
-        <button type="button" className="btn btn-primary" onClick={sync} disabled={syncing}>
+        <div className="flex flex-wrap items-center gap-2">
+          {repositories.length > 1 ? (
+            <button
+              type="button"
+              className="btn btn-ghost"
+              onClick={() => sync()}
+              disabled={syncing}
+              title="Alle Repositories dieses Projekts abgleichen"
+            >
+              <RefreshCw className="h-4 w-4" />
+              Alle
+            </button>
+          ) : (
+            <button
+              type="button"
+              onClick={() => setAddOpen(true)}
+              className="btn btn-ghost"
+              title="Weiteres Repository verknuepfen"
+            >
+              <Plus className="h-4 w-4" />
+              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)}
+            className="rounded-lg p-2 text-slate-500 transition-colors hover:bg-rose-500/10 hover:text-rose-300"
+            aria-label={`${repoTitle(repository)} vom Projekt loesen`}
+            title="Vom Projekt loesen"
+          >
+            <Unlink className="h-4 w-4" />
+          </button>
+          <button
+            type="button"
+            className="btn btn-primary"
+            onClick={() => sync(repository.id)}
+            disabled={syncing}
+          >
             {syncing ? (
               <Loader2 className="h-4 w-4 animate-spin" />
             ) : (
@@ -146,6 +329,24 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
             Jetzt synchronisieren
           </button>
         </div>
+      </div>
+
+      <RepositoryDialog
+        open={addOpen}
+        onClose={() => setAddOpen(false)}
+        projectId={project.id}
+        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
@@ -160,10 +361,10 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
         </p>
       ) : null}
 
-      {project.syncError && !message ? (
+      {repository.syncError && !message ? (
         <p className="flex items-start gap-2 rounded-xl border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
           <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
-          <span>{project.syncError}</span>
+          <span>{repository.syncError}</span>
         </p>
       ) : null}
 
@@ -253,6 +454,9 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
             </div>
           ) : null}
 
+          {/* Der Jahresueberblick, sobald er einmal geholt wurde. */}
+          {calendar ? <Heatmap calendar={calendar} /> : null}
+
           {/* Sprachen */}
           {languageTotal > 0 ? (
             <div className="glass p-4">
@@ -329,7 +533,30 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
                 />
               ) : null}
               {tab === "issues" ? (
+                <>
+                  {issues.length > 0 ? (
+                    <div className="flex flex-wrap items-center justify-between gap-2 border-b border-white/6 bg-white/2 px-4 py-2">
+                      <p className="text-[11px] text-slate-500">
+                        Aus offenen Issues Aufgaben machen. Bereits uebernommene werden
+                        uebersprungen.
+                      </p>
+                      <button
+                        type="button"
+                        className="btn btn-ghost px-2.5 py-1 text-[11px]"
+                        onClick={importIssues}
+                        disabled={importing}
+                      >
+                        {importing ? (
+                          <Loader2 className="h-3 w-3 animate-spin" />
+                        ) : (
+                          <ListPlus className="h-3 w-3" />
+                        )}
+                        Als Aufgaben uebernehmen
+                      </button>
+                    </div>
+                  ) : null}
                   <TicketList tickets={issues} empty="Keine offenen Issues." icon={CircleDot} />
+                </>
               ) : null}
               {tab === "branches" ? <BranchList branches={branches} /> : null}
               {tab === "tags" ? <TagList tags={tags} /> : null}

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}`}
@@ -256,11 +372,12 @@ function KanbanCard({
       </div>
 
       <div className="mt-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 text-[10px] text-slate-500">
-        <CiBadge state={project.snapshot?.ciState} compact />
+        {/* Auf der schmalen Kanban-Karte nur das fuehrende Repository. */}
-        {project.snapshot?.defaultBranch ? (
+        <CiBadge state={project.repositories[0]?.snapshot?.ciState} compact />
+        {project.repositories[0]?.snapshot?.defaultBranch ? (
           <span className="inline-flex items-center gap-1 font-mono">
             <GitBranch className="h-3 w-3" />
-            {project.snapshot.defaultBranch}
+            {project.repositories[0].snapshot.defaultBranch}
           </span>
         ) : null}
         {project._count.notes > 0 ? (

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
@@ -140,7 +197,9 @@ export function ProjectBoard({
         (project.summary ?? "").toLowerCase().includes(needle) ||
         (project.description ?? "").toLowerCase().includes(needle) ||
         project.tags.some((tag) => tag.includes(needle)) ||
-        (project.snapshot?.fullName ?? "").toLowerCase().includes(needle) ||
+        project.repositories.some((repo) =>
+          (repo.snapshot?.fullName ?? "").toLowerCase().includes(needle),
+        ) ||
         // Treffer in Notizen kommen vom Server dazu.
         noteHitProjectIds.has(project.id)
       );
@@ -172,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)
@@ -184,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"
@@ -211,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}>
@@ -224,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"
@@ -276,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" />
@@ -386,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>
       ) : (
@@ -414,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>
@@ -423,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}