docs: Benutzerverwaltung, Passkeys und Sicherheitsmassnahmen dokumentieren

README: Abschnitt zur ersten Anmeldung mit den beiden Betriebsarten und der Einrichtung eines Passkeys, erweiterte Variablentabelle mit dem Hinweis, dass Name und URL zur Laufzeit gelesen werden, vollstaendige API-Uebersicht sowie ein Sicherheitsabschnitt, der auch die Grenzen benennt: kein HSTS, keine TLS-Terminierung, Ratenbegrenzung nur im Arbeitsspeicher, kein Passwort-Zuruecksetzen per E-Mail, und warum Anfragen ohne Origin- und Sec-Fetch-Site-Header durchgelassen werden. FEATURES: neues Kapitel zu Konten und Zugang, aktualisiertes Datenmodell und ausgebauter Sicherheitsabschnitt. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
chore: neue Umgebungsvariablen in .env.example und Compose
2026-07-25 21:30:59 +02:00 · 2026-07-25 21:30:59 +02:00 · 2026-07-25 21:30:59 +02:00 · 2026-07-25 21:30:33 +02:00 · 2026-07-25 21:30:33 +02:00 · 2026-07-25 21:30:12 +02:00
132 changed files with 521 additions and 15977 deletions
@@ -56,21 +56,6 @@ APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
 # Lebensdauer einer Anmeldung in Tagen.
 SESSION_TTL_DAYS="30"
 # ── 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"
@@ -1,78 +0,0 @@
 # 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
@@ -43,15 +43,6 @@ yarn-error.log*
 /data
 /postgres-data
 # Sicherungen aus scripts/backup.* – enthalten alle Daten der Instanz
 /backups
 # Playwright
 /test-results
 /playwright-report
 /blob-report
 /playwright/.cache
 # editors
 .idea/
 .vscode/*
@@ -1,133 +0,0 @@
 # 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)
 ## Womit man arbeitet
 ```bash
 docker compose up -d db        # Postgres, muss laufen
 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.
 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.
@@ -27,14 +27,6 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
 - **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.
@@ -43,9 +35,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 · Zwei-Faktor einrichten und
+Anzeigename und E-Mail ändern · Passwort setzen oder wechseln · Passkeys verwalten ·
-abschalten · Passkeys verwalten · aktive Sitzungen einsehen (Browser, Betriebssystem, IP,
+aktive Sitzungen einsehen (Browser, Betriebssystem, IP, letzte Aktivität) · überall
-letzte Aktivität) · überall abmelden, wobei das eigene Gerät angemeldet bleibt.
+abmelden, wobei das eigene Gerät angemeldet bleibt.
 ### 0.4 Benutzerverwaltung (Administratoren)
@@ -115,41 +107,10 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
 - **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**.
+- **Zwei Ansichten**: freies Raster oder nach Status gruppierte Abschnitte.
 - **Volltextsuche über Notizen.** Die Suche im Board arbeitet auf den geladenen Projekten
  (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen liegen dort nicht vor — sie
  mitzuladen würde die Seite aufblähen. Stattdessen sucht Postgres serverseitig mit
  seiner deutschen Textsuche, entprellt ab zwei Zeichen. Treffer erscheinen als eigene
  Liste mit hervorgehobener Fundstelle, die betroffenen Projekte werden zusätzlich
  eingeblendet. Deutsche Stammformen greifen: „Webhook" findet auch „Webhooks".
 - **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.
 ### Kanban
 Spalten je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und
 erst danach gespeichert; scheitert das Speichern, springt die Karte zurück.
 - Gezogen wird am Griff links, nicht an der ganzen Karte — so bleibt der Titel ein
  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
  ginge nur mit einer gespeicherten Position — bewusst nicht gebaut.
 ### Projektkarte auf einen Blick
 Name und Favoritenstern · Kurzbeschreibung · Fortschrittsbalken · Provider-Badge ·
@@ -158,59 +119,9 @@ 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.
 ### 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.
 ---
 ## 3. Notizen
 - **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
 - **Markdown wird dargestellt** — Überschriften, Listen, Tabellen, Codeblöcke, Zitate und
  Links. Aus `- [ ] Aufgabe` werden echte Checklisten. Gilt auch für die Projekt-
  beschreibung. Rohes HTML wird beim Rendern entfernt (`rehype-sanitize`) — der Inhalt
  stammt vom Benutzer und wäre sonst ein XSS-Loch.
 - **Anpinnen** — angepinnte Notizen stehen oben und sind farblich hervorgehoben.
 - **Bearbeiten und Löschen** direkt in der Liste; Löschen fragt nach.
 - **Zeitstempel**: Anlagedatum immer, „bearbeitet vor …" nur bei echter Änderung.
@@ -223,31 +134,6 @@ statt verschoben.
 ## 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.1 Unterstützte Systeme
 | System | API | Authentifizierung | Besonderheit |
@@ -278,62 +164,14 @@ Firmen-Gitea nebeneinander.
 | --- | --- |
 | Repository | Voller Pfad, Beschreibung, Default-Branch, Sichtbarkeit, Größe, letzte Aktivität |
 | Kennzahlen | Stars, Forks, offene Issues, offene Pull-/Merge-Requests |
 | **Pull-/Merge-Requests** | bis zu 50 offene, mit Nummer, Titel, Autor, Alter, Labels, Entwurfskennzeichnung und Link |
 | **Issues** | bis zu 50 offene, gleiche Angaben. Bei GitHub und Gitea werden PRs herausgefiltert, die dort in derselben Liste stecken |
 | **CI-Status** | Letzter Lauf auf dem Default-Branch: erfolgreich, fehlgeschlagen, läuft, wartet oder abgebrochen — mit Name und Link |
 | Branches | bis zu 50, mit SHA, Default-Markierung, Schutzstatus und (wo die API es liefert) letztem Commit |
 | Tags | bis zu 25, mit SHA, Nachricht und Datum |
-| Commits | die letzten 15 zur Anzeige; geholt werden 100 für die Aktivitätskurve |
+| Commits | die letzten 15, mit Kurz-SHA, Nachricht, Autor, Datum und Link |
 | **Commit-Aktivität** | Balkenreihe der letzten Tage, auf Karte und Projektseite |
 | Releases | bis zu 10, inklusive Pre-Release- und Draft-Kennzeichnung |
 | Sprachen | Verteilung als Balken mit Prozentwerten |
 Woher der CI-Status kommt:
 | System | Quelle |
 | --- | --- |
 | GitHub | `actions/runs` für den Default-Branch; Lauf-Status und Ergebnis werden zusammengeführt |
 | GitLab | `pipelines` für den Default-Branch |
 | Gitea | Kombinierter Commit-Status — deckt Gitea Actions **und** externe Systeme wie Woodpecker ab, anders als ein reiner Actions-Endpunkt, den ältere Instanzen nicht kennen |
 Zur Ehrlichkeit der Aktivitätskurve: geholt wird eine Seite mit 100 Commits. Reicht die
 nicht über den ganzen Zeitraum, wird die Kurve auf den tatsächlich belegten Ausschnitt
 gekürzt — eine Null zu zeichnen, wo wir schlicht nichts wissen, wäre falsch.
 - **Snapshot-Prinzip**: Alle Daten werden in der Datenbank abgelegt. Das Dashboard bleibt
  ohne Netzverbindung oder bei erreichtem Rate-Limit vollständig nutzbar.
 ### 4.4 Automatischer Abgleich
 Standardmäßig **aus** — jeder Durchlauf verbraucht fremde API-Kontingente, das soll eine
 bewusste Entscheidung sein. Einschalten in den Admin-Einstellungen.
 | Einstellung | Bedeutung |
 | --- | --- |
 | Abstand | 15 Minuten bis täglich |
 | Projekte je Durchlauf | 1–100, Voreinstellung 25 |
 | Fertige und archivierte auslassen | Dort ändert sich selten noch etwas |
 Wie der Durchlauf arbeitet:
 - Der Zeitgeber läuft im Serverprozess selbst (`instrumentation.ts`), prüft minütlich, ob
  ein Durchlauf fällig ist, und startet ihn. Kein zusätzlicher Container, kein externer
  Cron. Zwei Durchläufe überschneiden sich nie.
 - **Am längsten nicht abgeglichene zuerst.** Was nicht in den Durchlauf passt, kommt beim
  nächsten Mal.
 - **Zurückhalten nach Fehlschlägen:** Nach jedem Fehlversuch verdoppelt sich der Abstand
  bis zum nächsten Versuch (gedeckelt beim 16-fachen). Ein Repository mit abgelaufenem
  Token blockiert damit nicht dauerhaft das Kontingent.
 - Kurze Pause zwischen zwei Projekten, damit kein Schwall entsteht.
 - **Pro Projekt abschaltbar** über einen Schalter im Projektdialog. Manuell
  synchronisieren geht unabhängig davon immer.
 - Der Adminbereich zeigt letzten und nächsten Durchlauf sowie einen Kurzbericht
  (aktualisiert / fehlgeschlagen / zurückgestellt) und hat einen Knopf **Jetzt abgleichen**.
 - Wer lieber von außen taktet, lässt den Automatismus aus und ruft
  `POST /api/admin/sync/run` per eigenem Cron auf.
 Der Abgleich läuft über alle Konten hinweg — er ist ein Serverauftrag, keine
 Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 - **URL-Erkennung** für `https://…`, `git@host:owner/repo.git` und GitLab-Weboberflächen-URLs
  mit `/-/tree/…`; verschachtelte Gruppenpfade bleiben erhalten.
 - **Ohne Token** funktionieren öffentliche Repositories, mit deutlich strengerem Rate-Limit.
@@ -345,111 +183,6 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 ---
 ## 4a. Export, Import und Sicherung
 ### Projekte mitnehmen
 - **JSON-Export** einzeln oder für alle Projekte: Stammdaten, Notizen, Tags,
  Repo-Verknüpfung. **Ohne Access Tokens** — die Verbindung wird nur beschrieben, das
  Token muss beim Import neu hinterlegt werden. Auch ohne Snapshots (reproduzierbar) und
  ohne Datenbank-IDs (gelten nur in der Quellinstanz).
 - **Markdown-Export** eines Projekts: Beschreibung, Kennzahlen, Notizen und der letzte
  bekannte Git-Stand als lesbare Datei.
 - **Import mit Vorschau.** Die Datei wird streng geprüft, bevor irgendetwas passiert.
  Abgeglichen wird über den Slug; bei Treffern stehen drei Strategien bereit:
  | Strategie | Wirkung |
  | --- | --- |
  | Überspringen | Vorhandene bleiben unverändert |
  | Zusätzlich anlegen | Kopie mit freiem Slug (`nebula` → `nebula-2`) |
  | Ersetzen | Stammdaten überschreiben, Notizen austauschen |
  Die Vorschau zeigt je Projekt, was geschähe, und weist auf fehlende Git-Verbindungen
  hin. Erst ein zweiter Klick schreibt.
 ### Sicherung
 - **JSON-Sicherung** im Adminbereich: Einstellungen, Konten, Verbindungen, Projekte und
  Notizen in einer Datei. Passwörter als scrypt-Hash, Git-Tokens als Chiffrat — ohne
  dasselbe `APP_SECRET` wertlos. Sitzungen und Passkeys bleiben draußen: erstere sind
  kurzlebig, letztere hängen an Gerät und rpID.
 - **Datenbank-Sicherung** über `scripts/backup.*`: `pg_dump` im Container, mit
  `--clean --if-exists`, also für sich allein einspielbar. Gegenstück ist
  `scripts/restore.*`, das vor dem Überschreiben nachfragt und sich über einen Parameter
  auf eine Wegwerf-Datenbank umlenken lässt — damit sich eine Sicherung prüfen lässt,
  ohne die echte anzufassen.
 ---
 ## 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
@@ -474,17 +207,11 @@ letzten Zustellung stehen an der Karte.
 | `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, Besitzer |
+| `Project` | Projektstammdaten, Status, Fortschritt, Repo-Verknüpfung, Besitzer |
 | `Repository` | Repositories eines Projekts inkl. Abgleichstand (n:1 zu Projekt) |
 | `Task` | Aufgaben mit Spalte, Position, Fälligkeit, Labels und Issue-Herkunft |
 | `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 Repository) |
+| `RepoSnapshot` | Zwischengespeicherter Repo-Stand (1:1 zu Projekt) |
 `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
@@ -533,58 +260,7 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
 - **Setup-Skript** erzeugt die `.env` samt zufälligem `APP_SECRET`.
 - **Seed-Daten** auf Wunsch, idempotent — mehrfaches Ausführen legt nichts doppelt an.
-### 6.4 Tests
+### 6.4 API
 Zwei Ebenen. `npm run test:all` führt beide aus.
 **`npm test` — Unit-Tests** (Vitest, 56 Stück, unter einer Sekunde, ohne DOM und ohne
 Datenbank):
 | Bereich | Was geprüft wird |
 | --- | --- |
 | `utils` | Slug-Erzeugung inklusive Umlauten und Längenbegrenzung, Tag-Aufbereitung, Kürzen, Zahlenformat |
 | `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 |
 **`npm run test:e2e` — Ende-zu-Ende** (Playwright, 13 Stück, rund 20 Sekunden). Läuft
 gegen die gebaute Anwendung mit eigener Datenbank auf Port 3111 — also durch Middleware,
 Authentifizierung, Validierung und Datenbank hindurch:
 | 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
@@ -594,5 +270,14 @@ Alles, was die Oberfläche kann, ist damit auch scriptbar. Übersicht in der
 ## 7. Ideen für später
-Was als Nächstes kommen könnte, steht mit Aufwandsschätzung und offenen Fragen in
+Bewusst nicht umgesetzt, aber vorgemerkt:
-**[ROADMAP.md](ROADMAP.md)** — gedacht zum Durchsprechen und schrittweisen Abarbeiten.
+
 - Kanban-Board mit Drag & Drop zwischen den Statusspalten
 - Webhooks, damit Pushes den Snapshot ohne Knopfdruck aktualisieren
 - Markdown-Rendering in Beschreibung und Notizen
 - Volltextsuche über Notizen hinweg
 - Export eines Projekts als Markdown
 - Automatischer Sync im Hintergrund (Intervall pro Verbindung)
 - Passwort-Zurücksetzen per E-Mail (aktuell setzt ein Administrator das Passwort neu)
 - Zwei-Faktor per TOTP als Alternative zum Passkey
 - Geteilte Projekte zwischen Konten (heute ist die Trennung absichtlich hart)
@@ -30,8 +30,7 @@ den Admin-Einstellungen.
 Alle Daten liegen in **deiner lokalen PostgreSQL**. Es gibt keinen Cloud-Dienst dahinter,
 Access Tokens werden verschlüsselt abgelegt.
-Eine vollständige Auflistung aller Funktionen steht in **[FEATURES.md](FEATURES.md)**,
+Eine vollständige Auflistung aller Funktionen steht in **[FEATURES.md](FEATURES.md)**.
 geplante Erweiterungen in **[ROADMAP.md](ROADMAP.md)**.
 ---
@@ -127,8 +126,6 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `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
@@ -184,80 +181,8 @@ Nebula auffindbare Credentials nutzt.
 Der Snapshot bleibt in der Datenbank, das Dashboard funktioniert also auch offline.
 Ohne Token gehen nur öffentliche Repositories, mit strengem Rate-Limit.
 ### Automatisch statt auf Knopfdruck
 Unter **Admin-Einstellungen → Automatischer Abgleich** lässt sich der Sync in den
 Hintergrund verlegen: Abstand von 15 Minuten bis täglich, Anzahl Projekte je Durchlauf,
 und wahlweise ohne fertige und archivierte Projekte. Standardmäßig ist er **aus**, weil
 jeder Durchlauf API-Kontingent verbraucht.
 Der Zeitgeber läuft im Serverprozess — kein zusätzlicher Container, kein externer Cron.
 Nach Fehlschlägen wird ein Repository mit wachsendem Abstand zurückgehalten, damit ein
 abgelaufener Token nicht dauerhaft Kontingent verbrennt. Einzelne Projekte lassen sich im
 Projektdialog ausnehmen; manuell synchronisieren geht immer.
 Wer lieber von außen taktet, lässt den Automatismus aus und ruft
 `POST /api/admin/sync/run` per eigenem Cron auf.
 ---
 ## Export, Import und Sicherung
 ### Projekte mitnehmen
 | Weg | Wo | Inhalt |
 | --- | --- | --- |
 | **Alle Projekte als JSON** | Dashboard → Datenbank-Symbol | Stammdaten, Notizen, Repo-Verknüpfung |
 | **Ein Projekt als JSON** | Projektseite → Download-Symbol | dasselbe, für ein Projekt |
 | **Ein Projekt als Markdown** | Projektseite → Download-Symbol | lesbar, inklusive letztem Git-Stand |
 | **Import** | Dashboard → Datenbank-Symbol | JSON einlesen, mit Vorschau |
 **Access Tokens sind nie enthalten.** Die Git-Verbindung wird nur beschrieben (Name,
 System, Basis-URL); nach dem Import muss das Token neu hinterlegt werden. Verweist eine
 importierte Datei auf eine hier unbekannte Verbindung, wird das Projekt ohne Verknüpfung
 angelegt und in der Vorschau angezeigt.
 Beim Import wird über den Slug abgeglichen. Für Treffer gibt es drei Strategien:
 - **Überspringen** — Vorhandene bleiben unverändert
 - **Zusätzlich anlegen** — Kopie mit freiem Slug (`nebula` → `nebula-2`)
 - **Ersetzen** — Stammdaten überschreiben, Notizen austauschen
 Vor dem Schreiben zeigt eine Vorschau, was passieren würde. Erst dann wird geschrieben.
 ### Sicherung
 Zwei Wege, mit unterschiedlichem Zweck:
 **JSON-Sicherung** (Admin-Einstellungen → Sicherung) enthält Einstellungen, Konten,
 Verbindungen, Projekte und Notizen. Gut zum Umziehen. Passwörter liegen als scrypt-Hash
 vor, Git-Tokens als Chiffrat — ohne dasselbe `APP_SECRET` sind sie wertlos. Trotzdem
 vertraulich behandeln.
 **Datenbank-Sicherung** über `pg_dump` — das, was man zum Wiederherstellen einer kaputten
 Instanz braucht:
 ```powershell
 .\scripts\backup.ps1                    # → .\backups\nebula-<datum>.sql
 .\scripts\restore.ps1 -File .\backups\nebula-....sql
 ```
 ```bash
 ./scripts/backup.sh                     # → ./backups/nebula-<datum>.sql
 ./scripts/restore.sh backups/nebula-....sql
 ```
 Die Skripte lesen Benutzer und Datenbankname aus der `.env` und führen `pg_dump` im
 Container aus — auf dem Rechner selbst muss nichts installiert sein.
 > Eine Sicherung ist erst dann eine Sicherung, wenn du sie einmal zurückgespielt hast.
 > Das geht ohne Risiko in eine Wegwerf-Datenbank:
 >
 > ```powershell
 > docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
 > .\scripts\restore.ps1 -File .\backups\nebula-....sql -Database nebula_test -Force
 > ```
 ## Projektstruktur
 ```
@@ -300,12 +225,7 @@ nebula/
 | `npm run db:seed` | Beispielprojekte anlegen |
 | `npm run db:studio` | Prisma Studio öffnen |
 | `npm run db:reset` | Datenbank zurücksetzen (**löscht alles**) |
 | `npm test` | Unit-Tests (Vitest), unter einer Sekunde |
 | `npm run test:watch` | Tests im Beobachtungsmodus |
 | `npm run typecheck` | TypeScript prüfen |
 | `npm test` | Unit-Tests (Vitest, ohne Datenbank) |
 | `npm run test:e2e` | Ende-zu-Ende-Tests (Playwright, baut vorher) |
 | `npm run test:all` | Beides nacheinander |
 | `npm run docker:db` | Nur die Datenbank starten |
 | `npm run docker:up` / `docker:down` | Kompletten Stack starten / stoppen |
 | `npm run docker:tools` | Adminer auf `http://localhost:8080` |
@@ -324,38 +244,18 @@ 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 |
+| `GET` `PATCH` | `/api/admin/settings` | Betriebsart und Registrierung (Admin) |
 | `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) |
 | `PATCH` `DELETE` | `/api/admin/users/:id` | Konto ändern / löschen (Admin) |
 | `GET` `POST` | `/api/projects` | Projekte auflisten / anlegen |
 | `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` | `/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` | Alle Repositories des Projekts abgleichen |
+| `POST` | `/api/projects/:id/sync` | Repo-Daten vom Git-System holen |
 | `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 |
@@ -1,108 +0,0 @@
 # Roadmap
 Sammlung dessen, was als Nächstes kommen könnte — zum Durchsprechen und
 Stück für Stück abarbeiten. Reihenfolge ist ein Vorschlag, keine Festlegung.
 **Aufwand:** `S` = überschaubar · `M` = halber Tag · `L` = größerer Brocken
 Was bereits steht, listet [FEATURES.md](FEATURES.md).
 ---
 ## 1 · Als Nächstes empfohlen
 ### 1.1 Webhooks statt Polling `M`
 Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
 zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
 Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
 erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.
 ---
 ## 2 · Danach
 ### 2.1 Commit-Aktivität als Heatmap `S`
 Die Sparkline gibt es auf Karte und Projektseite. Eine Heatmap über ein Jahr
 wäre die nächste Ausbaustufe — dafür braucht es allerdings mehr als eine
 Seite Commits, also Paginierung oder die Statistik-Endpunkte.
 ### 2.2 Kanban mit freier Reihenfolge `M`
 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
 ### 3.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`
 Die Oberfläche ist durchgängig deutsch verdrahtet. Englisch dazu wäre eine
 Voraussetzung, falls du das Projekt veröffentlichen willst.
 ---
 ## 4 · Kleinigkeiten
 | Idee | Aufwand | Nutzen |
 | --- | --- | --- |
 | 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 |
 | Wiederkehrende Aufgaben | `M` | Etwa „jeden Montag Abhängigkeiten prüfen" |
 | 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
 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.
 - **Eigene Git-Operationen** (klonen, committen, pushen). Nebula ist eine
  Übersicht, keine Entwicklungsumgebung.
 - **Zeiterfassung, Rechnungen, Kundenverwaltung.** Andere Baustelle.
 - **Cloud-Synchronisation.** Die Daten bleiben in deiner Datenbank; das ist
  der Punkt.
 ---
 ## Erledigt
 | | |
 | --- | --- |
 | Dashboard mit Status, Notizen, Git-Anbindung | ✓ |
 | GitHub, GitLab und Gitea | ✓ |
 | Benutzerverwaltung, Passwort und Passkeys | ✓ |
 | Einzel- und Mehrbenutzerbetrieb | ✓ |
 | Härtung: CSRF, CSP, SSRF, Ratenbegrenzung, Datentrennung | ✓ |
 | Docker- und Standalone-Betrieb | ✓ |
 | Automatischer Abgleich mit Zeitplan | ✓ |
 | 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 | ✓ |
 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
 ebenfalls draußen — sie sind reproduzierbar. Der Projekt-Export steht jedem Konto für
 seine eigenen Daten offen, die Voll-Sicherung nur Administratoren.
@@ -59,13 +59,6 @@ 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:-}
@@ -1,361 +0,0 @@
 import { expect, test, type APIRequestContext } from "@playwright/test";
 /**
 * 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("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);
 });
@@ -1,62 +0,0 @@
 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();
  }
 }
@@ -1,130 +0,0 @@
 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);
  await page.mouse.up();
  await expect(inArbeit.getByText("Erste Aufgabe")).toBeVisible();
  // 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("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("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/);
 });
@@ -1,6 +1,6 @@
 {
  "name": "nebula",
-  "version": "1.0.0",
+  "version": "0.1.0",
  "private": true,
  "description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
  "scripts": {
@@ -23,47 +23,30 @@
    "docker:logs": "docker compose --profile full logs -f app",
    "docker:tools": "docker compose --profile tools up -d",
    "setup": "node scripts/setup.mjs",
-    "postinstall": "prisma generate",
+    "postinstall": "prisma generate"
    "test": "vitest run",
    "test:watch": "vitest",
    "test:e2e": "npm run build && playwright test",
    "test:e2e:ui": "playwright test --ui",
    "test:all": "npm test && npm run test:e2e"
  },
  "prisma": {
    "seed": "tsx prisma/seed.ts"
  },
  "dependencies": {
    "@dnd-kit/core": "^6.3.1",
    "@dnd-kit/modifiers": "^9.0.0",
    "@dnd-kit/sortable": "^10.0.0",
    "@prisma/client": "^6.8.2",
    "@simplewebauthn/browser": "^13.3.0",
    "@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",
    "rehype-sanitize": "^6.0.0",
    "remark-gfm": "^4.0.1",
    "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",
    "prisma": "^6.8.2",
    "tailwindcss": "^4.1.7",
    "tsx": "^4.19.4",
-    "typescript": "^5.8.3",
+    "typescript": "^5.8.3"
    "vitest": "^4.1.10"
  },
  "engines": {
    "node": ">=20.11"
@@ -1,63 +0,0 @@
 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",
    },
  },
 });
@@ -1,11 +0,0 @@
 -- AlterTable
 ALTER TABLE "AppSettings" ADD COLUMN     "autoSyncActiveOnly" BOOLEAN NOT NULL DEFAULT true,
 ADD COLUMN     "autoSyncBatchSize" INTEGER NOT NULL DEFAULT 25,
 ADD COLUMN     "autoSyncEnabled" BOOLEAN NOT NULL DEFAULT false,
 ADD COLUMN     "autoSyncIntervalMinutes" INTEGER NOT NULL DEFAULT 60,
 ADD COLUMN     "lastAutoSyncAt" TIMESTAMP(3),
 ADD COLUMN     "lastAutoSyncReport" JSONB;
 -- AlterTable
 ALTER TABLE "Project" ADD COLUMN     "autoSync" BOOLEAN NOT NULL DEFAULT true,
 ADD COLUMN     "syncFailureCount" INTEGER NOT NULL DEFAULT 0;
@@ -1,16 +0,0 @@
 -- Volltextsuche ueber Notizen.
 --
 -- Dies ist ein Ausdrucksindex. Prisma kann so etwas im Schema nicht abbilden
 -- und kennt ihn deshalb nicht. Nachgeprueft: "prisma migrate diff" laesst ihn
 -- in Ruhe und schlaegt kein DROP vor - Ausdrucksindizes werden schlicht
 -- ignoriert. Trotzdem beim Erzeugen kuenftiger Migrationen kurz hinsehen.
 --
 -- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
 -- Postgres berechnet to_tsvector dann je Zeile.
 --
 -- Der Ausdruck muss mit dem in src/app/api/search/route.ts uebereinstimmen,
 -- sonst greift der Index nicht. Die zweistellige Form von to_tsvector mit
 -- fester Konfiguration ist IMMUTABLE und damit indizierbar.
 CREATE INDEX "Note_fulltext_idx" ON "Note"
  USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || "content"));
@@ -1,9 +0,0 @@
 -- AlterTable
 ALTER TABLE "RepoSnapshot" ADD COLUMN     "ciBranch" TEXT,
 ADD COLUMN     "ciFinishedAt" TIMESTAMP(3),
 ADD COLUMN     "ciName" TEXT,
 ADD COLUMN     "ciState" TEXT,
 ADD COLUMN     "ciUrl" TEXT,
 ADD COLUMN     "commitActivity" JSONB NOT NULL DEFAULT '[]',
 ADD COLUMN     "issues" JSONB NOT NULL DEFAULT '[]',
 ADD COLUMN     "pullRequests" JSONB NOT NULL DEFAULT '[]';
@@ -1,28 +0,0 @@
 -- CreateEnum
 CREATE TYPE "TaskStatus" AS ENUM ('TODO', 'DOING', 'BLOCKED', 'DONE');
 -- AlterTable
 ALTER TABLE "Project" ADD COLUMN     "progressFromTasks" BOOLEAN NOT NULL DEFAULT false;
 -- CreateTable
 CREATE TABLE "Task" (
    "id" TEXT NOT NULL,
    "projectId" TEXT NOT NULL,
    "title" TEXT NOT NULL,
    "description" TEXT,
    "status" "TaskStatus" NOT NULL DEFAULT 'TODO',
    "position" INTEGER NOT NULL DEFAULT 0,
    "dueDate" TIMESTAMP(3),
    "labels" TEXT[] DEFAULT ARRAY[]::TEXT[],
    "doneAt" TIMESTAMP(3),
    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
    "updatedAt" TIMESTAMP(3) NOT NULL,
    CONSTRAINT "Task_pkey" PRIMARY KEY ("id")
 );
 -- CreateIndex
 CREATE INDEX "Task_projectId_status_position_idx" ON "Task"("projectId", "status", "position");
 -- AddForeignKey
 ALTER TABLE "Task" ADD CONSTRAINT "Task_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
@@ -1,39 +0,0 @@
 -- 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;
@@ -1,9 +0,0 @@
 -- 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);
@@ -1,6 +0,0 @@
 -- AlterTable
 ALTER TABLE "Task" ADD COLUMN     "sourceIssue" INTEGER,
 ADD COLUMN     "sourceUrl" TEXT;
 -- CreateIndex
 CREATE UNIQUE INDEX "Task_projectId_sourceIssue_key" ON "Task"("projectId", "sourceIssue");
@@ -1,24 +0,0 @@
 -- 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;
@@ -1,47 +0,0 @@
 -- 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;
@@ -1,113 +0,0 @@
 -- 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";
@@ -33,52 +33,6 @@ 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
 }
 /// Spalten des Aufgabenbretts innerhalb eines Projekts.
 enum TaskStatus {
  TODO
  DOING
  BLOCKED
  DONE
 }
 /// ADMIN darf Benutzer und Einstellungen verwalten. Auf fremde Projekte hat
 /// auch ein Admin keinen Zugriff – die Trennung ist bewusst hart.
 enum UserRole {
@@ -112,21 +66,10 @@ 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?
  sessions    Session[]
  credentials Credential[]
  projects    Project[]
  connections GitConnection[]
  notificationTargets NotificationTarget[]
  activities    Activity[]
  recoveryCodes RecoveryCode[]
  pendingLogins PendingLogin[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
@@ -171,45 +114,6 @@ 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 {
@@ -233,31 +137,7 @@ model AppSettings {
  allowRegistration Boolean  @default(false)
  /// Anzeigename gegenueber dem Authenticator beim Anlegen eines Passkeys.
  rpName            String   @default("Nebula")
-
+  updatedAt         DateTime @updatedAt
  // ── Automatischer Abgleich mit den Git-Systemen ────────────
  /// Standardmaessig aus: der Abgleich verbraucht fremde API-Kontingente,
  /// das soll eine bewusste Entscheidung sein.
  autoSyncEnabled         Boolean @default(false)
  /// Abstand zwischen zwei Durchlaeufen in Minuten.
  autoSyncIntervalMinutes Int     @default(60)
  /// Fertige und archivierte Projekte auslassen – dort aendert sich selten
  /// noch etwas.
  autoSyncActiveOnly      Boolean @default(true)
  /// Hoechstzahl Projekte je Durchlauf, damit ein grosses Board nicht auf
  /// einen Schlag in ein Rate-Limit laeuft.
  autoSyncBatchSize       Int     @default(25)
  lastAutoSyncAt     DateTime?
  /// 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
 }
 /// Eine Verbindung zu einem Git-System inkl. verschluesseltem Token.
@@ -286,7 +166,7 @@ model GitConnection {
  ownerId String?
  owner   User?   @relation(fields: [ownerId], references: [id], onDelete: Cascade)
-  repositories Repository[]
+  projects  Project[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
@@ -316,178 +196,36 @@ model Project {
  tags        String[]      @default([])
  favorite    Boolean       @default(false)
  // ── Git-Anbindung ──────────────────────────────────────────
  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)
  lastSyncedAt DateTime?
  syncError    String?
  /// Besitzer. Nullable wie bei GitConnection, damit Bestandsdaten beim
  /// Einrichten des ersten Kontos uebernommen werden koennen.
  ownerId String?
  owner   User?   @relation(fields: [ownerId], references: [id], onDelete: Cascade)
-  /// Fortschritt aus dem Verhaeltnis erledigter Aufgaben berechnen statt
+  notes    Note[]
-  /// von Hand zu schieben. Nur sinnvoll, wenn es ueberhaupt Aufgaben gibt.
+  snapshot RepoSnapshot?
  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[]
  activities   Activity[]
  repositories Repository[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
  @@unique([ownerId, slug])
  @@index([status])
  @@index([connectionId])
  @@index([updatedAt])
  @@index([ownerId])
 }
 /// 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?
  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.
 model Task {
  id          String     @id @default(cuid())
  projectId   String
  project     Project    @relation(fields: [projectId], references: [id], onDelete: Cascade)
  title       String
  /// Optionale Notiz zur Aufgabe, Markdown wird dargestellt.
  description String?
  status      TaskStatus @default(TODO)
  /// Rang innerhalb der Spalte. Anders als beim Projektbrett braucht es ihn
  /// hier wirklich: Aufgaben haben eine Reihenfolge, die der Benutzer setzt.
  /// Beim Umsortieren werden die Positionen einer Spalte neu durchnummeriert.
  position    Int        @default(0)
  dueDate     DateTime?
  labels      String[]   @default([])
  /// Zeitpunkt, zu dem die Aufgabe nach DONE gewandert ist.
  doneAt      DateTime?
  /// 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])
 }
 /// 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())
@@ -503,12 +241,12 @@ model Note {
  @@index([pinned])
 }
-/// Zwischengespeicherter Stand eines Repositories. Wird beim Sync
+/// Zwischengespeicherter Stand des verknuepften Repositories. Wird beim
-/// ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
+/// Sync ueberschrieben, damit das Dashboard auch ohne Netz Daten zeigt.
 model RepoSnapshot {
-  id           String     @id @default(cuid())
+  id        String  @id @default(cuid())
-  repositoryId String     @unique
+  projectId String  @unique
-  repository   Repository @relation(fields: [repositoryId], references: [id], onDelete: Cascade)
+  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)
  fullName      String?
  description   String?
@@ -536,23 +274,11 @@ model RepoSnapshot {
  /// Rohdaten der Listen – bewusst als JSON, damit providerspezifische
  /// Zusatzfelder nicht verloren gehen.
-  branches      Json @default("[]")
+  branches  Json @default("[]")
-  tags          Json @default("[]")
+  tags      Json @default("[]")
-  commits       Json @default("[]")
+  commits   Json @default("[]")
-  releases      Json @default("[]")
+  releases  Json @default("[]")
-  languages     Json @default("{}")
+  languages Json @default("{}")
  pullRequests  Json @default("[]")
  issues        Json @default("[]")
  /// Commits je Tag der letzten 30 Tage, aeltester zuerst.
  commitActivity Json @default("[]")
  // ── Letzter CI-Lauf auf dem Default-Branch ─────────────────
  /// success | failure | running | pending | cancelled
  ciState      String?
  ciName       String?
  ciBranch     String?
  ciUrl        String?
  ciFinishedAt DateTime?
  pushedAt  DateTime?
  fetchedAt DateTime @default(now())
@@ -1,64 +0,0 @@
 <#
 .SYNOPSIS
    Byteweise Sicherung der Nebula-Datenbank mit pg_dump.
 .DESCRIPTION
    Ergaenzt den JSON-Export im Adminbereich um eine vollstaendige
    Datenbanksicherung: Schema, Daten, Sequenzen, Indizes. Genau das, was
    man zum Wiederherstellen einer kaputten Instanz braucht.
    Laeuft die Datenbank im mitgelieferten Container, wird pg_dump dort
    ausgefuehrt - auf dem Rechner selbst muss dann nichts installiert sein.
 .PARAMETER OutDir
    Zielverzeichnis. Vorgabe: .\backups
 .PARAMETER Container
    Name des Postgres-Containers. Vorgabe: nebula-db
 .EXAMPLE
    .\scripts\backup.ps1
    .\scripts\backup.ps1 -OutDir D:\Sicherungen
 #>
 [CmdletBinding()]
 param(
    [string]$OutDir = (Join-Path $PSScriptRoot "..\backups"),
    [string]$Container = "nebula-db"
 )
 $ErrorActionPreference = "Stop"
 # .env einlesen, damit Benutzer und Datenbankname nicht doppelt gepflegt werden.
 $envFile = Join-Path $PSScriptRoot "..\.env"
 $settings = @{ POSTGRES_USER = "nebula"; POSTGRES_DB = "nebula" }
 if (Test-Path $envFile) {
    foreach ($line in Get-Content $envFile) {
        if ($line -match '^\s*([A-Z_]+)\s*=\s*"?([^"#]*)"?\s*$') {
            $settings[$Matches[1]] = $Matches[2].Trim()
        }
    }
 }
 $user = $settings["POSTGRES_USER"]
 $database = $settings["POSTGRES_DB"]
 if (-not (Test-Path $OutDir)) { New-Item -ItemType Directory -Path $OutDir | Out-Null }
 $stamp = Get-Date -Format "yyyy-MM-dd-HHmmss"
 $target = Join-Path $OutDir "nebula-$stamp.sql"
 $running = docker ps --filter "name=$Container" --format "{{.Names}}"
 if ($running -notcontains $Container) {
    Write-Error "Container '$Container' laeuft nicht. Zuerst 'docker compose up -d db' ausfuehren."
 }
 Write-Host "Sichere Datenbank '$database' aus Container '$Container'..."
 # --clean --if-exists macht die Datei fuer sich allein einspielbar.
 docker exec $Container pg_dump -U $user -d $database --clean --if-exists | Out-File -Encoding utf8 $target
 if ($LASTEXITCODE -ne 0) { Write-Error "pg_dump ist fehlgeschlagen." }
 $size = [math]::Round((Get-Item $target).Length / 1KB, 1)
 Write-Host "Fertig: $target ($size KB)" -ForegroundColor Green
 Write-Host "Wiederherstellen mit: .\scripts\restore.ps1 -File `"$target`""
@@ -1,43 +0,0 @@
 #!/bin/sh
 # ─────────────────────────────────────────────────────────────
 #  Byteweise Sicherung der Nebula-Datenbank mit pg_dump.
 #
 #  Ergaenzt den JSON-Export im Adminbereich um eine vollstaendige
 #  Datenbanksicherung: Schema, Daten, Sequenzen, Indizes.
 #
 #  Aufruf:  ./scripts/backup.sh [Zielverzeichnis]
 # ─────────────────────────────────────────────────────────────
 set -eu
 root="$(cd "$(dirname "$0")/.." && pwd)"
 out_dir="${1:-$root/backups}"
 container="${NEBULA_DB_CONTAINER:-nebula-db}"
 user="nebula"
 database="nebula"
 if [ -f "$root/.env" ]; then
  # Nur die beiden benoetigten Werte lesen, ohne die Datei auszufuehren.
  value_of() {
    sed -n "s/^[[:space:]]*$1[[:space:]]*=[[:space:]]*\"\{0,1\}\([^\"#]*\)\"\{0,1\}[[:space:]]*$/\1/p" \
      "$root/.env" | tail -n 1
  }
  [ -n "$(value_of POSTGRES_USER)" ] && user="$(value_of POSTGRES_USER)"
  [ -n "$(value_of POSTGRES_DB)" ] && database="$(value_of POSTGRES_DB)"
 fi
 if ! docker ps --filter "name=$container" --format '{{.Names}}' | grep -qx "$container"; then
  echo "Container '$container' laeuft nicht. Zuerst 'docker compose up -d db' ausfuehren." >&2
  exit 1
 fi
 mkdir -p "$out_dir"
 stamp="$(date +%Y-%m-%d-%H%M%S)"
 target="$out_dir/nebula-$stamp.sql"
 echo "Sichere Datenbank '$database' aus Container '$container'..."
 # --clean --if-exists macht die Datei fuer sich allein einspielbar.
 docker exec "$container" pg_dump -U "$user" -d "$database" --clean --if-exists > "$target"
 size="$(du -h "$target" | cut -f1)"
 echo "Fertig: $target ($size)"
 echo "Wiederherstellen mit: ./scripts/restore.sh \"$target\""
@@ -1,62 +0,0 @@
 <#
 .SYNOPSIS
    Spielt eine mit backup.ps1 erzeugte Sicherung zurueck.
 .DESCRIPTION
    ACHTUNG: Der aktuelle Inhalt der Datenbank wird dabei ersetzt. Das Skript
    fragt vorher nach, es sei denn, -Force ist gesetzt.
 .PARAMETER Database
    Zieldatenbank. Vorgabe: der Wert aus der .env.
    Tipp: Eine Sicherung laesst sich pruefen, ohne die echte Datenbank
    anzufassen - in eine leere Testdatenbank einspielen und nachsehen:
        docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
        .\scripts\restore.ps1 -File .\backups\... -Database nebula_test -Force
 .EXAMPLE
    .\scripts\restore.ps1 -File .\backups\nebula-2026-07-26-101500.sql
 #>
 [CmdletBinding()]
 param(
    [Parameter(Mandatory = $true)][string]$File,
    [string]$Database,
    [string]$Container = "nebula-db",
    [switch]$Force
 )
 $ErrorActionPreference = "Stop"
 if (-not (Test-Path $File)) { Write-Error "Datei nicht gefunden: $File" }
 $envFile = Join-Path $PSScriptRoot "..\.env"
 $settings = @{ POSTGRES_USER = "nebula"; POSTGRES_DB = "nebula" }
 if (Test-Path $envFile) {
    foreach ($line in Get-Content $envFile) {
        if ($line -match '^\s*([A-Z_]+)\s*=\s*"?([^"#]*)"?\s*$') {
            $settings[$Matches[1]] = $Matches[2].Trim()
        }
    }
 }
 $user = $settings["POSTGRES_USER"]
 $database = if ($Database) { $Database } else { $settings["POSTGRES_DB"] }
 if (-not $Force) {
    Write-Host "Der gesamte Inhalt der Datenbank '$database' wird ersetzt." -ForegroundColor Yellow
    $answer = Read-Host "Wirklich fortfahren? (ja/nein)"
    if ($answer -ne "ja") { Write-Host "Abgebrochen."; exit 0 }
 }
 $running = docker ps --filter "name=$Container" --format "{{.Names}}"
 if ($running -notcontains $Container) {
    Write-Error "Container '$Container' laeuft nicht."
 }
 Write-Host "Spiele '$File' ein..."
 Get-Content $File -Raw | docker exec -i $Container psql -U $user -d $database -v ON_ERROR_STOP=1
 if ($LASTEXITCODE -ne 0) { Write-Error "Das Einspielen ist fehlgeschlagen." }
 Write-Host "Fertig. Anwendung neu starten, damit sie eine frische Verbindung aufbaut." -ForegroundColor Green
@@ -1,57 +0,0 @@
 #!/bin/sh
 # ─────────────────────────────────────────────────────────────
 #  Spielt eine mit backup.sh erzeugte Sicherung zurueck.
 #
 #  ACHTUNG: Der aktuelle Inhalt der Datenbank wird ersetzt.
 #
 #  Aufruf:  ./scripts/restore.sh <datei.sql> [--force]
 #
 #  Zieldatenbank ueberschreiben mit NEBULA_DB_NAME. Damit laesst sich eine
 #  Sicherung pruefen, ohne die echte Datenbank anzufassen:
 #
 #    docker exec nebula-db psql -U nebula -d postgres -c "CREATE DATABASE nebula_test"
 #    NEBULA_DB_NAME=nebula_test ./scripts/restore.sh backups/... --force
 # ─────────────────────────────────────────────────────────────
 set -eu
 root="$(cd "$(dirname "$0")/.." && pwd)"
 file="${1:-}"
 force="${2:-}"
 container="${NEBULA_DB_CONTAINER:-nebula-db}"
 if [ -z "$file" ]; then
  echo "Aufruf: ./scripts/restore.sh <datei.sql> [--force]" >&2
  exit 1
 fi
 if [ ! -f "$file" ]; then
  echo "Datei nicht gefunden: $file" >&2
  exit 1
 fi
 user="nebula"
 database="nebula"
 if [ -f "$root/.env" ]; then
  value_of() {
    sed -n "s/^[[:space:]]*$1[[:space:]]*=[[:space:]]*\"\{0,1\}\([^\"#]*\)\"\{0,1\}[[:space:]]*$/\1/p" \
      "$root/.env" | tail -n 1
  }
  [ -n "$(value_of POSTGRES_USER)" ] && user="$(value_of POSTGRES_USER)"
  [ -n "$(value_of POSTGRES_DB)" ] && database="$(value_of POSTGRES_DB)"
 fi
 database="${NEBULA_DB_NAME:-$database}"
 if [ "$force" != "--force" ]; then
  printf "Der gesamte Inhalt der Datenbank '%s' wird ersetzt.\nWirklich fortfahren? (ja/nein) " "$database"
  read -r answer
  [ "$answer" = "ja" ] || { echo "Abgebrochen."; exit 0; }
 fi
 if ! docker ps --filter "name=$container" --format '{{.Names}}' | grep -qx "$container"; then
  echo "Container '$container' laeuft nicht." >&2
  exit 1
 fi
 echo "Spiele '$file' ein..."
 docker exec -i "$container" psql -U "$user" -d "$database" -v ON_ERROR_STOP=1 < "$file"
 echo "Fertig. Anwendung neu starten, damit sie eine frische Verbindung aufbaut."
@@ -1,10 +1,5 @@
 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";
@@ -18,7 +13,7 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AccountPage() {
  const user = await requireUserPage();
-  const [passkeys, sessions, targets, konto, offeneCodes] = await Promise.all([
+  const [passkeys, sessions] = await Promise.all([
    prisma.credential.findMany({
      where: { userId: user.id },
      select: {
@@ -42,27 +37,6 @@ 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 = {
@@ -74,11 +48,6 @@ export default async function AccountPage() {
    passkeys,
    sessions,
    passkeysAvailable: WEBAUTHN_AVAILABLE,
    totp: {
      enabled: Boolean(konto.totpEnabledAt),
      enabledAt: konto.totpEnabledAt,
      recoveryCodesLeft: offeneCodes,
    },
  };
  return (
@@ -91,11 +60,6 @@ export default async function AccountPage() {
      </header>
      <AccountManager data={data} />
      <NotificationSection
        targets={targets as unknown as NotificationTargetEntry[]}
        emailAvailable={emailAvailable()}
      />
    </div>
  );
 }
@@ -1,9 +1,5 @@
 import type { Metadata } from "next";
-import {
+import { AdminManager, type AdminData } from "@/components/admin/AdminManager";
  AdminManager,
  type AdminData,
  type AutoSyncReport,
 } from "@/components/admin/AdminManager";
 import { requireAdminPage } from "@/lib/auth/guard";
 import { getAppSettings } from "@/lib/auth/settings";
 import { userSafeSelect } from "@/lib/auth/users";
@@ -19,28 +15,12 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AdminPage() {
  const admin = await requireAdminPage();
-  const [settings, users, eligible, staleListeners] = await Promise.all([
+  const [settings, users] = await Promise.all([
    getAppSettings(),
    prisma.user.findMany({
      select: userSafeSelect,
      orderBy: [{ role: "asc" }, { username: "asc" }],
    }),
    // Bewusst ueber alle Konten: der Abgleich ist ein Serverauftrag, keine
    // Dateneinsicht. Gezaehlt wird nur, nicht gelesen.
    // Gezaehlt werden Repositories, nicht Projekte: sie sind die Einheit, in
    // der abgeglichen und begrenzt wird.
    prisma.repository.count({
      where: {
        autoSync: true,
        OR: [
          { AND: [{ repoOwner: { not: null } }, { repoName: { not: null } }] },
          { repoUrl: { not: null } },
        ],
      },
    }),
    prisma.notificationTarget.count({
      where: { isActive: true, events: { has: "PROJECT_STALE" } },
    }),
  ]);
  const data: AdminData = {
@@ -50,20 +30,6 @@ export default async function AdminPage() {
    currentUserId: admin.id,
    appUrl: APP_URL,
    passkeysAvailable: WEBAUTHN_AVAILABLE,
    autoSync: {
      enabled: settings.autoSyncEnabled,
      intervalMinutes: settings.autoSyncIntervalMinutes,
      activeOnly: settings.autoSyncActiveOnly,
      batchSize: settings.autoSyncBatchSize,
      lastRunAt: settings.lastAutoSyncAt,
      lastReport: (settings.lastAutoSyncReport as AutoSyncReport | null) ?? null,
      eligible,
    },
    stale: {
      afterDays: settings.staleAfterDays,
      lastCheckAt: settings.lastStaleCheckAt,
      listeners: staleListeners,
    },
  };
  return (
@@ -76,7 +42,7 @@ export default async function AdminPage() {
          Admin-Einstellungen
        </h1>
        <p className="mt-1 text-sm text-slate-400">
-          Betriebsart, automatischer Abgleich und Benutzerkonten.
+          Betriebsart, Registrierung und Benutzerkonten.
        </p>
      </header>
@@ -1,43 +0,0 @@
 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) });
 }
@@ -1,167 +0,0 @@
 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, otpauthUri, verifyTotp } 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);
  }
  if (!verifyTotp(secret, parsed.data.code)) {
    return jsonError(
      "Der Code stimmt nicht. Geht die Uhr des Geraets richtig?",
      401,
    );
  }
  await prisma.user.update({
    where: { id: auth.user.id },
    data: { totpEnabledAt: new Date() },
  });
  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 },
    }),
    prisma.recoveryCode.deleteMany({ where: { userId: auth.user.id } }),
    prisma.pendingLogin.deleteMany({ where: { userId: auth.user.id } }),
  ]);
  return NextResponse.json({ ok: true });
 }
@@ -1,89 +0,0 @@
 import { requireAdminApi } from "@/lib/auth/guard";
 import { APP_NAME } from "@/lib/config";
 import { prisma } from "@/lib/db";
 import { exportFileName } from "@/lib/export/format";
 export const dynamic = "force-dynamic";
 /**
 * Vollstaendige Sicherung der Instanz als JSON.
 *
 * Anders als der Projekt-Export ist das eine echte Sicherung und enthaelt
 * deshalb auch Konten und Verbindungen. Was drinsteht:
 *
 *  - Passwoerter nur als scrypt-Hash, nicht im Klartext
 *  - Git-Tokens nur als Chiffrat; ohne dasselbe APP_SECRET sind sie wertlos
 *  - Sitzungen und Passkeys bewusst nicht: Sitzungen sind kurzlebig, und
 *    Passkeys haengen ohnehin am Geraet und an der rpID
 *
 * Die Datei ist damit vertraulich zu behandeln. Fuer eine byteweise Sicherung
 * der Datenbank siehe scripts/backup.* mit pg_dump.
 */
 export async function GET() {
  const auth = await requireAdminApi();
  if (!auth.ok) return auth.response;
  const [settings, users, connections, projects] = await Promise.all([
    prisma.appSettings.findUnique({ where: { id: "singleton" } }),
    prisma.user.findMany({
      select: {
        id: true,
        username: true,
        displayName: true,
        email: true,
        passwordHash: true,
        role: true,
        isActive: true,
        createdAt: true,
        lastLoginAt: true,
      },
      orderBy: { username: "asc" },
    }),
    prisma.gitConnection.findMany({
      select: {
        id: true,
        ownerId: true,
        name: true,
        provider: true,
        baseUrl: true,
        username: true,
        tokenCipher: true,
        tokenHint: true,
        createdAt: true,
      },
      orderBy: { name: "asc" },
    }),
    prisma.project.findMany({
      include: {
        notes: { orderBy: { createdAt: "asc" } },
        tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
        // Snapshots bleiben draussen: reproduzierbar und gross.
      },
      orderBy: { name: "asc" },
    }),
  ]);
  const payload = {
    kind: "nebula.backup",
    version: 1,
    exportedAt: new Date().toISOString(),
    app: APP_NAME,
    note:
      "Enthaelt Passwort-Hashes und verschluesselte Git-Tokens. " +
      "Die Tokens sind nur mit demselben APP_SECRET wieder lesbar. Vertraulich behandeln.",
    settings,
    users,
    connections,
    projects,
  };
  const filename = exportFileName(`${APP_NAME}-sicherung`, new Date(), "json");
  return new Response(JSON.stringify(payload, null, 2), {
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Content-Disposition": `attachment; filename="${filename}"`,
      "Cache-Control": "no-store",
    },
  });
 }
@@ -30,15 +30,7 @@ export async function PATCH(request: Request) {
    );
  }
-  const {
+  const { mode, allowRegistration } = parsed.data;
    mode,
    allowRegistration,
    autoSyncEnabled,
    autoSyncIntervalMinutes,
    autoSyncActiveOnly,
    autoSyncBatchSize,
    staleAfterDays,
  } = parsed.data;
  // Der Wechsel in den Einzelbetrieb wuerde weitere Konten aussperren –
  // deshalb nur erlauben, wenn es wirklich nur ein Konto gibt.
@@ -53,32 +45,18 @@ export async function PATCH(request: Request) {
    }
  }
  const autoSyncFields = {
    ...(autoSyncEnabled !== undefined ? { autoSyncEnabled } : {}),
    ...(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({
    where: { id: "singleton" },
    create: {
      id: "singleton",
      ...(mode ? { mode } : {}),
      ...(allowRegistration !== undefined ? { allowRegistration } : {}),
      ...autoSyncFields,
    },
    update: {
      ...(mode ? { mode } : {}),
      ...(allowRegistration !== undefined ? { allowRegistration } : {}),
      // Im Einzelbetrieb ergibt eine offene Registrierung keinen Sinn.
      ...(mode === "SINGLE_USER" ? { allowRegistration: false } : {}),
      ...autoSyncFields,
    },
  });
@@ -1,37 +0,0 @@
 import { NextResponse } from "next/server";
 import { requireAdminApi } from "@/lib/auth/guard";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import { clientIp, jsonError, tooManyRequests } from "@/lib/security/request";
 import { isAutoSyncRunning, runAutoSyncPass } from "@/lib/sync/scheduler";
 export const dynamic = "force-dynamic";
 /**
 * Stoesst einen Abgleich sofort an – unabhaengig vom Zeitplan.
 *
 * Dient zwei Zwecken: dem Knopf "Jetzt abgleichen" im Adminbereich und
 * einem externen Zeitgeber, falls jemand lieber von aussen taktet als den
 * eingebauten Automatismus zu nutzen.
 */
 export async function POST(request: Request) {
  const auth = await requireAdminApi();
  if (!auth.ok) return auth.response;
  const limited = rateLimit(
    `sync-run:${clientIp(request)}`,
    LIMITS.outbound.limit,
    LIMITS.outbound.windowMs,
  );
  if (!limited.ok) return tooManyRequests(limited.retryAfter);
  if (isAutoSyncRunning()) {
    return jsonError("Es laeuft bereits ein Abgleich.", 409);
  }
  const report = await runAutoSyncPass("manuell");
  if (!report) {
    return jsonError("Es laeuft bereits ein Abgleich.", 409);
  }
  return NextResponse.json({ report });
 }
@@ -1,5 +1,4 @@
 import { NextResponse } from "next/server";
 import { createPendingLogin, setMfaCookie } from "@/lib/auth/mfa";
 import { fakeVerifyDelay, verifyPassword } from "@/lib/auth/password";
 import { createSession, setSessionCookie } from "@/lib/auth/session";
 import { lockRemainingSeconds, noteFailedLogin, noteSuccessfulLogin } from "@/lib/auth/users";
@@ -69,18 +68,6 @@ export async function POST(request: Request) {
    return jsonError(GENERIC, 401);
  }
  // Das Passwort stimmt. Ist ein zweiter Faktor eingerichtet, entsteht hier
  // noch keine Sitzung, sondern nur ein Vorgang mit kurzer Frist.
  if (user.totpEnabledAt) {
    // 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);
  resetRateLimit(`login:user:${username}`);
  resetRateLimit(`login:ip:${ip}`);
@@ -1,98 +0,0 @@
 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 { verifyTotp } from "@/lib/auth/totp";
 import { noteSuccessfulLogin } from "@/lib/auth/users";
 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);
  const erfolg = istZiffern
    ? Boolean(pending.user.totpSecret) && verifyTotp(pending.user.totpSecret!, eingabe)
    : 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);
  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;
 }
@@ -69,8 +69,6 @@ export async function POST(request: Request) {
      email: email ?? null,
      passwordHash: await hashPassword(password),
      role: "USER",
      // Die Registrierung meldet direkt an.
      lastLoginAt: new Date(),
    },
  });
@@ -49,9 +49,6 @@ export async function POST(request: Request) {
      email: email ?? null,
      passwordHash: await hashPassword(password),
      role: "ADMIN",
      // Die Einrichtung meldet direkt an – sonst stuende im Adminbereich
      // "noch nie angemeldet", obwohl gerade eine Sitzung laeuft.
      lastLoginAt: new Date(),
    },
  });
@@ -14,7 +14,7 @@ type Params = { params: Promise<{ id: string }> };
 const safeSelect = {
  ...connectionSafeSelect,
-  _count: { select: { repositories: true } },
+  _count: { select: { projects: true } },
 };
 export async function PATCH(request: Request, { params }: Params) {
@@ -14,7 +14,7 @@ export const dynamic = "force-dynamic";
 /** Verbindungen ohne Token-Chiffrat – das verlaesst den Server nie. */
 const safeSelect = {
  ...connectionSafeSelect,
-  _count: { select: { repositories: true } },
+  _count: { select: { projects: true } },
 };
 export async function GET() {
@@ -1,5 +1,4 @@
 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,18 +44,6 @@ 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 });
 }
@@ -66,25 +53,10 @@ 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 });
 }
@@ -1,93 +0,0 @@
 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 });
 }
@@ -1,40 +0,0 @@
 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 });
 }
@@ -1,83 +0,0 @@
 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 });
 }
@@ -1,44 +0,0 @@
 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 });
 }
@@ -1,63 +0,0 @@
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 import { exportFileName } from "@/lib/export/format";
 import { buildExportFile, exportInclude, toMarkdown } from "@/lib/export/project";
 import { jsonError } from "@/lib/security/request";
 export const dynamic = "force-dynamic";
 type Params = { params: Promise<{ id: string }> };
 /**
 * Ein einzelnes Projekt exportieren.
 *
 *   ?format=json  (Vorgabe)  – zum Wiedereinlesen
 *   ?format=md               – lesbar, zum Archivieren
 */
 export async function GET(request: Request, { params }: Params) {
  const auth = await requireUserApi();
  if (!auth.ok) return auth.response;
  const { id } = await params;
  const format = new URL(request.url).searchParams.get("format") ?? "json";
  const project = await prisma.project.findFirst({
    where: { id, ownerId: auth.user.id },
    include: {
      ...exportInclude,
      // 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);
  if (format === "md" || format === "markdown") {
    const filename = exportFileName(project.slug, new Date(), "md");
    return new Response(toMarkdown(project), {
      headers: {
        "Content-Type": "text/markdown; charset=utf-8",
        "Content-Disposition": `attachment; filename="${filename}"`,
        "Cache-Control": "no-store",
      },
    });
  }
  const payload = buildExportFile([project]);
  const filename = exportFileName(project.slug, new Date(), "json");
  return new Response(JSON.stringify(payload, null, 2), {
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Content-Disposition": `attachment; filename="${filename}"`,
      "Cache-Control": "no-store",
    },
  });
 }
@@ -1,5 +1,4 @@
 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";
@@ -65,13 +64,5 @@ 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 });
 }
@@ -1,122 +0,0 @@
 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 });
 }
@@ -1,12 +1,9 @@
 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 { 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";
@@ -77,97 +74,34 @@ export async function PATCH(request: Request, { params }: Params) {
    "accent",
    "tags",
    "favorite",
-    "progressFromTasks",
+    "connectionId",
  ] as const) {
    if (data[key] !== undefined) update[key] = data[key];
  }
-  await prisma.project.update({ where: { id }, data: update });
+  if (data.repoUrl !== undefined) {
-
+    update.repoUrl = data.repoUrl;
-  // Die Git-Felder gehen an das fuehrende Repository. Sie hier weiterhin
+    const parsedUrl = data.repoUrl ? parseRepoUrl(data.repoUrl) : null;
-  // anzunehmen erspart der Oberflaeche zwei Aufrufe fuer einen Speichervorgang.
+    if (parsedUrl) {
-  const repoFelder = {
+      update.repoOwner = data.repoOwner ?? parsedUrl.owner;
-    repoUrl: data.repoUrl,
+      update.repoName = data.repoName ?? parsedUrl.name;
-    repoOwner: data.repoOwner,
+    } else if (!data.repoUrl) {
-    repoName: data.repoName,
+      update.repoOwner = null;
-    connectionId: data.connectionId,
+      update.repoName = null;
-    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);
  }
  if (data.repoOwner !== undefined) update.repoOwner = data.repoOwner;
  if (data.repoName !== undefined) update.repoName = data.repoName;
-  const project = await prisma.project.findUniqueOrThrow({
+  const project = await prisma.project.update({
    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;
@@ -1,147 +0,0 @@
 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,
  });
 }
@@ -1,93 +0,0 @@
 import { NextResponse } from "next/server";
 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 { formatZodError, taskReorderSchema } from "@/lib/validation";
 export const dynamic = "force-dynamic";
 type Params = { params: Promise<{ id: string }> };
 /**
 * Neue Reihenfolge nach dem Ziehen.
 *
 * Uebergeben wird je betroffener Spalte die vollstaendige Liste der Aufgaben
 * in ihrer neuen Reihenfolge. Daraus ergeben sich Status und Position
 * eindeutig – der Aufruf ist damit wiederholbar, ohne Schaden anzurichten,
 * und ein verlorener Aufruf laesst sich einfach erneut senden.
 */
 export async function PATCH(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 = taskReorderSchema.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<TaskStatus, string[]>>;
  const requestedIds = Object.values(columns).flat();
  // Nur Aufgaben anfassen, die wirklich zu diesem Projekt gehoeren – sonst
  // liessen sich fremde Aufgaben ueber untergeschobene IDs verschieben.
  const owned = await prisma.task.findMany({
    where: { projectId: id, id: { in: requestedIds } },
    select: { id: true, status: true },
  });
  const ownedIds = new Set(owned.map((task) => task.id));
  const previousStatus = new Map(owned.map((task) => [task.id, task.status]));
  const now = new Date();
  const updates: Prisma.PrismaPromise<unknown>[] = [];
  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);
      updates.push(
        prisma.task.update({
          where: { id: taskId },
          data: {
            status,
            position: index,
            // doneAt nur beim tatsaechlichen Wechsel setzen oder loeschen,
            // damit ein Umsortieren innerhalb von "Erledigt" das Datum nicht
            // immer wieder erneuert.
            ...(before !== status
              ? { doneAt: status === "DONE" ? now : null }
              : {}),
          },
        }),
      );
    });
  }
  if (updates.length > 0) {
    await prisma.$transaction(updates);
    await refreshDerivedProgress(id);
  }
  const tasks = await prisma.task.findMany({
    where: { projectId: id },
    orderBy: [{ status: "asc" }, { position: "asc" }],
  });
  return NextResponse.json({
    tasks,
    updated: updates.length,
    ignored: requestedIds.length - updates.length,
  });
 }
@@ -1,78 +0,0 @@
 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, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
 import { formatZodError, taskCreateSchema } from "@/lib/validation";
 export const dynamic = "force-dynamic";
 type Params = { params: Promise<{ id: string }> };
 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 tasks = await prisma.task.findMany({
    where: { projectId: id },
    orderBy: [{ status: "asc" }, { position: "asc" }],
  });
  return NextResponse.json({ tasks });
 }
 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 = taskCreateSchema.safeParse(body.data);
  if (!parsed.success) {
    return NextResponse.json(
      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
      { status: 422 },
    );
  }
  const { title, description, status, dueDate, labels } = parsed.data;
  const task = await prisma.task.create({
    data: {
      projectId: id,
      title,
      description: description ?? null,
      status,
      // Neue Aufgaben landen unten in ihrer Spalte.
      position: await nextPosition(id, status),
      dueDate: dueDate ? new Date(dueDate) : null,
      labels,
      doneAt: status === "DONE" ? new Date() : null,
    },
  });
  await refreshDerivedProgress(id);
  // 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 });
 }
@@ -1,29 +0,0 @@
 import { requireUserApi } from "@/lib/auth/guard";
 import { APP_NAME } from "@/lib/config";
 import { exportFileName } from "@/lib/export/format";
 import { buildExportFile, loadProjectsForExport } from "@/lib/export/project";
 import { jsonError } from "@/lib/security/request";
 export const dynamic = "force-dynamic";
 /** Alle eigenen Projekte als JSON zum Herunterladen. */
 export async function GET() {
  const auth = await requireUserApi();
  if (!auth.ok) return auth.response;
  const projects = await loadProjectsForExport(auth.user.id);
  if (projects.length === 0) {
    return jsonError("Es gibt noch keine Projekte zum Exportieren.", 404);
  }
  const payload = buildExportFile(projects);
  const filename = exportFileName(`${APP_NAME}-projekte`, new Date(), "json");
  return new Response(JSON.stringify(payload, null, 2), {
    headers: {
      "Content-Type": "application/json; charset=utf-8",
      "Content-Disposition": `attachment; filename="${filename}"`,
      "Cache-Control": "no-store",
    },
  });
 }
@@ -1,274 +0,0 @@
 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,
  repositoriesOf,
  type ExportedRepository,
 } from "@/lib/export/format";
 import { uniqueSlug } from "@/lib/projects";
 import { LIMITS, rateLimit } from "@/lib/security/rateLimit";
 import {
  IMPORT_MAX_BODY_BYTES,
  clientIp,
  jsonError,
  readJsonBody,
  tooManyRequests,
 } from "@/lib/security/request";
 import { slugify } from "@/lib/utils";
 export const dynamic = "force-dynamic";
 const requestSchema = z.object({
  data: z.unknown(),
  /**
   * skip      – vorhandene Projekte unveraendert lassen
   * rename    – zusaetzlich anlegen, mit freiem Slug
   * overwrite – vorhandenes Projekt ersetzen (Notizen werden ausgetauscht)
   */
  strategy: z.enum(["skip", "rename", "overwrite"]).default("skip"),
  /** Nur pruefen und berichten, nichts schreiben. */
  dryRun: z.boolean().default(true),
 });
 type Action = "create" | "rename" | "overwrite" | "skip" | "error";
 interface ItemResult {
  name: string;
  slug: string;
  action: Action;
  /** Bei "rename" der tatsaechlich vergebene Slug. */
  newSlug?: string;
  notes: number;
  /** matched: Verbindung gefunden · missing: beschrieben, aber nicht vorhanden */
  connection: "matched" | "missing" | "none";
  connectionName?: string;
  message?: string;
 }
 export async function POST(request: Request) {
  const auth = await requireUserApi();
  if (!auth.ok) return auth.response;
  const limited = rateLimit(
    `import:${clientIp(request)}`,
    LIMITS.mutation.limit,
    LIMITS.mutation.windowMs,
  );
  if (!limited.ok) return tooManyRequests(limited.retryAfter);
  const body = await readJsonBody(request, IMPORT_MAX_BODY_BYTES);
  if (!body.ok) return body.response;
  const outer = requestSchema.safeParse(body.data);
  if (!outer.success) return jsonError("Ungueltige Anfrage.", 422);
  // Die hochgeladene Datei ist Fremdinhalt – strikt pruefen, bevor irgendetwas
  // damit passiert.
  const parsed = exportFileSchema.safeParse(outer.data.data);
  if (!parsed.success) {
    const first = parsed.error.issues[0];
    return NextResponse.json(
      {
        error:
          "Die Datei passt nicht zum erwarteten Format. " +
          (first ? `${first.path.join(".") || "Datei"}: ${first.message}` : ""),
      },
      { status: 422 },
    );
  }
  const { strategy, dryRun } = outer.data;
  const file = parsed.data;
  // Verbindungen des Kontos einmal laden, um sie den Projekten zuzuordnen.
  const connections = await prisma.gitConnection.findMany({
    where: { ownerId: auth.user.id },
    select: { id: true, name: true, provider: true, baseUrl: true },
  });
  function matchConnection(described: ExportedRepository["connection"]) {
    if (!described) return null;
    const byName = connections.find(
      (candidate) => candidate.name.toLowerCase() === described.name.toLowerCase(),
    );
    if (byName) return byName;
    return (
      connections.find(
        (candidate) =>
          candidate.provider === described.provider &&
          candidate.baseUrl.replace(/\/+$/, "").toLowerCase() ===
            described.baseUrl.replace(/\/+$/, "").toLowerCase(),
      ) ?? null
    );
  }
  const results: ItemResult[] = [];
  for (const incoming of file.projects) {
    const slug = incoming.slug || slugify(incoming.name) || "projekt";
    // Version 1 kannte ein Repository je Projekt und schrieb es flach; seit
    // Version 2 steht eine Liste da. repositoriesOf glaettet den Unterschied.
    const eingehendeRepos = repositoriesOf(incoming);
    const repos = eingehendeRepos.map((repo, index) => ({
      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 },
      select: { id: true },
    });
    const base: ItemResult = {
      name: incoming.name,
      slug,
      action: "create",
      notes: incoming.notes.length,
      connection: connectionState,
      connectionName: (fehlend[0] ?? beschrieben[0])?.connection?.name,
    };
    if (existing && strategy === "skip") {
      results.push({ ...base, action: "skip", message: "Slug bereits vergeben." });
      continue;
    }
    const action: Action = !existing ? "create" : strategy === "rename" ? "rename" : "overwrite";
    if (dryRun) {
      results.push({
        ...base,
        action,
        ...(action === "rename" ? { newSlug: `${slug}-…` } : {}),
        ...(action === "overwrite"
          ? { message: "Ersetzt Stammdaten und tauscht die Notizen aus." }
          : {}),
      });
      continue;
    }
    const data = {
      name: incoming.name,
      summary: incoming.summary ?? null,
      description: incoming.description ?? null,
      status: incoming.status,
      priority: incoming.priority,
      progress: incoming.progress,
      accent: incoming.accent,
      tags: incoming.tags,
      favorite: incoming.favorite,
      progressFromTasks: incoming.progressFromTasks,
    };
    const tasks = incoming.tasks.map((task, index) => ({
      title: task.title,
      description: task.description ?? null,
      status: task.status,
      // Position aus der Datei uebernehmen, notfalls die Reihenfolge in ihr.
      position: task.position ?? index,
      dueDate: task.dueDate && !Number.isNaN(Date.parse(task.dueDate))
        ? new Date(task.dueDate)
        : null,
      labels: task.labels,
      doneAt: task.status === "DONE" ? new Date() : null,
      ...(task.createdAt && !Number.isNaN(Date.parse(task.createdAt))
        ? { createdAt: new Date(task.createdAt) }
        : {}),
    }));
    const notes = incoming.notes.map((note) => ({
      title: note.title ?? null,
      content: note.content,
      pinned: note.pinned ?? false,
      ...(note.createdAt && !Number.isNaN(Date.parse(note.createdAt))
        ? { createdAt: new Date(note.createdAt) }
        : {}),
    }));
    try {
      if (existing && action === "overwrite") {
        // Notizen austauschen statt zusammenfuehren: vorhersagbar, und ein
        // erneuter Import erzeugt keine Dubletten.
        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 },
              repositories: { create: repos },
            },
          }),
        ]);
        results.push({ ...base, action: "overwrite" });
      } else {
        const finalSlug = existing ? await uniqueSlug(incoming.name, auth.user.id) : slug;
        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",
          ...(existing ? { newSlug: finalSlug } : {}),
        });
      }
    } catch (error) {
      results.push({
        ...base,
        action: "error",
        message: error instanceof Error ? error.message : String(error),
      });
    }
  }
  const summary = {
    total: results.length,
    created: results.filter((entry) => entry.action === "create").length,
    renamed: results.filter((entry) => entry.action === "rename").length,
    overwritten: results.filter((entry) => entry.action === "overwrite").length,
    skipped: results.filter((entry) => entry.action === "skip").length,
    errors: results.filter((entry) => entry.action === "error").length,
    missingConnections: results.filter((entry) => entry.connection === "missing").length,
  };
  return NextResponse.json({ dryRun, strategy, summary, results });
 }
@@ -1,12 +1,10 @@
 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 { 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";
@@ -74,7 +72,18 @@ export async function POST(request: Request) {
    if (!connection) return jsonError("Git-Verbindung nicht gefunden.", 404);
  }
-  const angelegt = await prisma.project.create({
+  // Owner/Name aus der URL ableiten, falls nicht explizit angegeben.
  let repoOwner = data.repoOwner ?? null;
  let repoName = data.repoName ?? null;
  if (data.repoUrl && (!repoOwner || !repoName)) {
    const parsedUrl = parseRepoUrl(data.repoUrl);
    if (parsedUrl) {
      repoOwner = repoOwner ?? parsedUrl.owner;
      repoName = repoName ?? parsedUrl.name;
    }
  }
  const project = await prisma.project.create({
    data: {
      ownerId: auth.user.id,
      name: data.name,
@@ -87,34 +96,13 @@ export async function POST(request: Request) {
      accent: data.accent,
      tags: data.tags,
      favorite: data.favorite,
      repoUrl: data.repoUrl ?? null,
      repoOwner,
      repoName,
      connectionId: data.connectionId ?? null,
    },
    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:
      data.status === "IDEA"
        ? "Als Idee angelegt"
        : `Angelegt mit Status „${statusOf(data.status).label}“`,
    meta: { status: data.status },
  });
  return NextResponse.json({ project }, { status: 201 });
 }
@@ -1,93 +0,0 @@
 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 });
 }
@@ -1,41 +0,0 @@
 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 });
 }
@@ -1,67 +0,0 @@
 import { NextResponse } from "next/server";
 import { requireUserApi } from "@/lib/auth/guard";
 import { prisma } from "@/lib/db";
 export const dynamic = "force-dynamic";
 interface Hit {
  projectId: string;
  noteId: string;
  title: string | null;
  /** Textausschnitt mit hervorgehobener Fundstelle. */
  snippet: string;
 }
 /**
 * Volltextsuche ueber Notizen.
 *
 * Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt
 * Name, Kurzbeschreibung und Tags ab. Notizen liegen dort nicht vor – die
 * mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser Endpunkt:
 * Postgres sucht mit seiner deutschen Textsuche direkt in der Datenbank.
 *
 * ts_headline liefert gleich den passenden Ausschnitt mit; die Hervorhebung
 * kommt als [[…]] zurueck, damit die Oberflaeche kein HTML einbetten muss.
 */
 export async function GET(request: Request) {
  const auth = await requireUserApi();
  if (!auth.ok) return auth.response;
  const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
  if (query.length < 2) {
    return NextResponse.json({ query, hits: [], projectIds: [] });
  }
  // websearch_to_tsquery versteht Eingaben wie "docker -compose" oder
  // Anfuehrungszeichen und wirft bei Unsinn keinen Fehler.
  const hits = await prisma.$queryRaw<Hit[]>`
    SELECT
      n."projectId" AS "projectId",
      n."id"        AS "noteId",
      n."title"     AS "title",
      ts_headline(
        'german',
        n."content",
        websearch_to_tsquery('german', ${query}),
        'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
      ) AS "snippet"
    FROM "Note" n
    JOIN "Project" p ON p."id" = n."projectId"
    WHERE p."ownerId" = ${auth.user.id}
      AND to_tsvector('german', coalesce(n."title", '') || ' ' || n."content")
          @@ websearch_to_tsquery('german', ${query})
    ORDER BY ts_rank(
      to_tsvector('german', coalesce(n."title", '') || ' ' || n."content"),
      websearch_to_tsquery('german', ${query})
    ) DESC
    LIMIT 50
  `;
  return NextResponse.json({
    query,
    hits,
    // Die Oberflaeche braucht vor allem die betroffenen Projekte, um sie im
    // Board einzublenden.
    projectIds: Array.from(new Set(hits.map((hit) => hit.projectId))),
  });
 }
@@ -1,98 +0,0 @@
 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 { TASK_STATUS_META, nextPosition, refreshDerivedProgress } from "@/lib/tasks";
 import { formatZodError, taskUpdateSchema } from "@/lib/validation";
 export const dynamic = "force-dynamic";
 type Params = { params: Promise<{ id: string }> };
 /** Eine Aufgabe gehoert dem, dem das zugehoerige Projekt gehoert. */
 async function ownedTask(taskId: string, ownerId: string) {
  return prisma.task.findFirst({
    where: { id: taskId, project: { ownerId } },
    select: { id: true, projectId: true, status: true, title: true },
  });
 }
 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 ownedTask(id, auth.user.id);
  if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
  const body = await readJsonBody(request);
  if (!body.ok) return body.response;
  const parsed = taskUpdateSchema.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.title !== undefined) update.title = data.title;
  if (data.description !== undefined) update.description = data.description;
  if (data.labels !== undefined) update.labels = data.labels;
  if (data.dueDate !== undefined) {
    update.dueDate = data.dueDate ? new Date(data.dueDate) : null;
  }
  if (data.status !== undefined && data.status !== existing.status) {
    update.status = data.status;
    // Beim Spaltenwechsel ans Ende der neuen Spalte.
    update.position = await nextPosition(existing.projectId, data.status);
    // doneAt nur setzen, wenn die Aufgabe wirklich nach DONE wandert.
    update.doneAt = data.status === "DONE" ? new Date() : null;
  }
  const task = await prisma.task.update({ where: { id }, data: update });
  await refreshDerivedProgress(existing.projectId);
  // 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: `Aufgabe „${shorten(task.title, 50)}“ → ${TASK_STATUS_META[nach].label}`,
      meta: { taskId: id, from: existing.status, to: nach },
    });
  }
  return NextResponse.json({ task });
 }
 export async function DELETE(_request: Request, { params }: Params) {
  const auth = await requireUserApi();
  if (!auth.ok) return auth.response;
  const { id } = await params;
  const existing = await ownedTask(id, auth.user.id);
  if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
  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 });
 }
@@ -69,151 +69,6 @@
    opacity: 0.85;
  }
  /**
   * Flaeche fuer alles, was ueber dem Inhalt schwebt: Menues, Dialoge.
   *
   * Bewusst nahezu deckend statt Glas. Ein Overlay muss lesbar sein, egal
   * was darunter liegt - bei 3,5 % Deckkraft schien der Inhalt dahinter
   * durch. backdrop-filter hilft hier nicht: liegt das Element in einem
   * Vorfahren, der selbst backdrop-filter setzt (unsere Karten), bleibt die
   * Weichzeichnung wirkungslos.
   */
  .popover {
    /* Vollstaendig deckend: bei 97 % schimmerte darunterliegender Text
       (die Schaltflaechen "Bearbeiten" und "Loeschen") noch durch. */
    background: #090b18;
    border: 1px solid rgba(255, 255, 255, 0.11);
    border-radius: 0.9rem;
    box-shadow:
      0 1px 0 0 rgba(255, 255, 255, 0.07) inset,
      0 28px 70px -24px rgba(0, 0, 0, 0.95);
  }
  /**
   * Markdown-Inhalte. Tailwind setzt in seinem Preflight alle Abstaende und
   * Schriftgroessen zurueck, also muessen Ueberschriften, Listen und
   * Codebloecke hier wieder Form bekommen.
   */
  .md {
    font-size: 0.875rem;
    line-height: 1.65;
    color: #cbd5e1;
    overflow-wrap: break-word;
  }
  .md > *:first-child { margin-top: 0; }
  .md > *:last-child { margin-bottom: 0; }
  .md h1, .md h2, .md h3, .md h4 {
    color: #f1f5f9;
    font-weight: 600;
    line-height: 1.3;
    margin: 1.4em 0 0.5em;
  }
  .md h1 { font-size: 1.3rem; }
  .md h2 { font-size: 1.15rem; }
  .md h3 { font-size: 1rem; }
  .md h4 { font-size: 0.9rem; }
  .md p { margin: 0.75em 0; }
  .md a {
    color: #c4b5fd;
    text-decoration: underline;
    text-underline-offset: 2px;
  }
  .md a:hover { color: #ddd6fe; }
  .md strong { color: #f1f5f9; font-weight: 600; }
  .md ul, .md ol { margin: 0.75em 0; padding-left: 1.35em; }
  .md ul { list-style: disc; }
  .md ol { list-style: decimal; }
  .md li { margin: 0.3em 0; }
  .md li::marker { color: #64748b; }
  /* Aufgabenlisten aus "- [ ] …" */
  .md li:has(> input[type="checkbox"]) {
    list-style: none;
    margin-left: -1.35em;
    display: flex;
    align-items: flex-start;
    gap: 0.5rem;
  }
  .md input[type="checkbox"] {
    margin-top: 0.35em;
    accent-color: #8b5cf6;
    width: 0.9rem;
    height: 0.9rem;
    flex-shrink: 0;
  }
  .md code {
    background: rgba(255, 255, 255, 0.07);
    border: 1px solid rgba(255, 255, 255, 0.07);
    border-radius: 0.35rem;
    padding: 0.1em 0.35em;
    font-family: var(--font-mono);
    font-size: 0.85em;
    color: #e9d5ff;
  }
  .md pre {
    background: rgba(4, 6, 16, 0.75);
    border: 1px solid rgba(255, 255, 255, 0.08);
    border-radius: 0.75rem;
    padding: 0.85rem 1rem;
    margin: 0.9em 0;
    overflow-x: auto;
  }
  .md pre code {
    background: none;
    border: none;
    padding: 0;
    color: #cbd5e1;
    font-size: 0.8rem;
    line-height: 1.6;
  }
  .md blockquote {
    border-left: 2px solid rgba(167, 139, 250, 0.5);
    padding-left: 0.9rem;
    margin: 0.9em 0;
    color: #94a3b8;
    font-style: italic;
  }
  .md hr {
    border: 0;
    border-top: 1px solid rgba(255, 255, 255, 0.09);
    margin: 1.4em 0;
  }
  .md table {
    width: 100%;
    margin: 0.9em 0;
    border-collapse: collapse;
    font-size: 0.8rem;
    display: block;
    overflow-x: auto;
  }
  .md th, .md td {
    border: 1px solid rgba(255, 255, 255, 0.09);
    padding: 0.4rem 0.6rem;
    text-align: left;
  }
  .md th {
    background: rgba(255, 255, 255, 0.04);
    color: #e2e8f0;
    font-weight: 600;
  }
  .md img {
    max-width: 100%;
    height: auto;
    border-radius: 0.5rem;
  }
  /* ── Text & Akzente ───────────────────────────────────────── */
  .text-gradient {
@@ -335,61 +190,4 @@
    background: #0a0c1a;
    color: #e6e8f5;
  }
  /**
   * Schieberegler. Der native Regler zeichnet die Spur rechts vom Griff in
   * einem hellen Standardton - im dunklen Layout ein grelles Band. Deshalb
   * vollstaendig selbst gezeichnet: der gefuellte Anteil kommt aus der
   * Variablen --fill, die die Komponente aus dem Wert setzt.
   */
  .range {
    -webkit-appearance: none;
    appearance: none;
    width: 100%;
    height: 6px;
    border-radius: 9999px;
    cursor: pointer;
    background: linear-gradient(
      90deg,
      #8b5cf6 0%,
      #d946ef var(--fill, 0%),
      rgba(255, 255, 255, 0.1) var(--fill, 0%),
      rgba(255, 255, 255, 0.1) 100%
    );
  }
  .range:focus-visible {
    outline: 2px solid rgba(167, 139, 250, 0.8);
    outline-offset: 4px;
  }
  .range::-webkit-slider-thumb {
    -webkit-appearance: none;
    appearance: none;
    height: 16px;
    width: 16px;
    border-radius: 9999px;
    background: #f5f3ff;
    border: 2px solid #7c3aed;
    box-shadow: 0 0 14px -2px rgba(168, 85, 247, 0.9);
    cursor: grab;
  }
  .range::-webkit-slider-thumb:active {
    cursor: grabbing;
  }
  .range::-moz-range-thumb {
    height: 14px;
    width: 14px;
    border-radius: 9999px;
    background: #f5f3ff;
    border: 2px solid #7c3aed;
    box-shadow: 0 0 14px -2px rgba(168, 85, 247, 0.9);
    cursor: grab;
  }
  .range::-moz-range-track {
    background: transparent;
  }
 }
@@ -17,7 +17,7 @@ export default async function ConnectionsPage() {
  const connections = await prisma.gitConnection.findMany({
    where: { ownerId: user.id },
-    select: { ...connectionSafeSelect, _count: { select: { repositories: true } } },
+    select: { ...connectionSafeSelect, _count: { select: { projects: true } } },
    orderBy: { name: "asc" },
  });
@@ -1,8 +1,7 @@
 import type { Metadata, Viewport } from "next";
 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";
+import { APP_NAME, APP_TAGLINE } from "@/lib/config";
 import "./globals.css";
 /**
@@ -46,9 +45,6 @@ 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>
@@ -56,7 +52,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>
+            <span className="font-mono text-slate-600">v0.2.0</span>
          </div>
        </footer>
      </body>
@@ -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) => project.repositories.length > 0).length;
+  const linked = active.filter((project) => Boolean(project.repoOwner && project.repoName)).length;
  const averageProgress =
    active.length > 0
@@ -63,9 +63,7 @@ export default async function DashboardPage() {
        <StatCard
          label="Ideen"
          value={ideas}
-          // Kurzer Hinweis statt der langen Statusbeschreibung – die wurde in
+          hint={STATUS_META.IDEA.description}
          // der schmalen Kachel mitten im Wort abgeschnitten.
          hint="Noch nichts gebaut"
          icon={Lightbulb}
          color={STATUS_META.IDEA.color}
        />
@@ -1,12 +1,9 @@
 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 { 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";
@@ -61,12 +58,6 @@ export default async function ProjectPage({ params }: PageProps) {
        connections={connections as unknown as ConnectionSafe[]}
      />
      <TaskBoard
        projectId={detail.id}
        tasks={detail.tasks}
        progressFromTasks={detail.progressFromTasks}
      />
      <div className="grid gap-6 lg:grid-cols-12">
        <div className="space-y-6 lg:col-span-5">
          <section className="glass p-5">
@@ -75,7 +66,9 @@ export default async function ProjectPage({ params }: PageProps) {
              Beschreibung
            </h2>
            {detail.description ? (
-              <Markdown className="mt-3">{detail.description}</Markdown>
+              <p className="mt-3 whitespace-pre-wrap break-words text-sm leading-relaxed text-slate-300">
                {detail.description}
              </p>
            ) : (
              <p className="mt-3 text-sm text-slate-500">
                Keine Beschreibung hinterlegt. Ueber „Bearbeiten“ kannst du die Idee ausformulieren.
@@ -86,12 +79,8 @@ export default async function ProjectPage({ params }: PageProps) {
          <NotesPanel projectId={detail.id} notes={detail.notes} />
        </div>
-        <div className="space-y-6 lg:col-span-7">
+        <div className="lg:col-span-7">
-          <GitPanel
+          <GitPanel project={detail} />
            project={detail}
            connections={connections as unknown as ConnectionSafe[]}
          />
          <ActivityFeed projectId={detail.id} initial={detail.activities} />
        </div>
      </div>
    </div>
@@ -1,148 +0,0 @@
 "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>
  );
 }
@@ -1,90 +0,0 @@
 import { CircleCheck, CircleDashed, CircleSlash, CircleX, LoaderCircle } from "lucide-react";
 import { cn } from "@/lib/utils";
 export type CiState = "success" | "failure" | "running" | "pending" | "cancelled";
 const META: Record<
  CiState,
  { label: string; short: string; className: string; icon: typeof CircleCheck; spin?: boolean }
 > = {
  success: {
    label: "CI erfolgreich",
    short: "CI ok",
    className: "bg-emerald-500/12 text-emerald-200 ring-emerald-400/30",
    icon: CircleCheck,
  },
  failure: {
    label: "CI fehlgeschlagen",
    short: "CI rot",
    className: "bg-rose-500/12 text-rose-200 ring-rose-400/30",
    icon: CircleX,
  },
  running: {
    label: "CI laeuft",
    short: "CI laeuft",
    className: "bg-amber-500/12 text-amber-200 ring-amber-400/30",
    icon: LoaderCircle,
    spin: true,
  },
  pending: {
    label: "CI wartet",
    short: "CI wartet",
    className: "bg-slate-500/12 text-slate-300 ring-slate-400/25",
    icon: CircleDashed,
  },
  cancelled: {
    label: "CI abgebrochen",
    short: "CI abgebrochen",
    className: "bg-slate-500/12 text-slate-400 ring-slate-400/20",
    icon: CircleSlash,
  },
 };
 export function CiBadge({
  state,
  name,
  url,
  compact = false,
 }: {
  state: string | null | undefined;
  name?: string | null;
  url?: string | null;
  compact?: boolean;
 }) {
  if (!state || !(state in META)) return null;
  const meta = META[state as CiState];
  const Icon = meta.icon;
  const content = (
    <>
      <Icon className={cn("h-3 w-3 shrink-0", meta.spin && "animate-spin")} />
      {compact ? meta.short : (name ?? meta.label)}
    </>
  );
  const className = cn(
    "inline-flex items-center gap-1.5 rounded-full ring-1 ring-inset",
    meta.className,
    compact ? "px-2 py-0.5 text-[10px]" : "px-2.5 py-1 text-[11px]",
  );
  if (url && !compact) {
    return (
      <a
        href={url}
        target="_blank"
        rel="noreferrer noopener"
        className={cn(className, "transition-all hover:brightness-125")}
        title={meta.label}
      >
        {content}
      </a>
    );
  }
  return (
    <span className={className} title={name ? `${meta.label} · ${name}` : meta.label}>
      {content}
    </span>
  );
 }
@@ -1,380 +0,0 @@
 "use client";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { useRouter } from "next/navigation";
 import {
  Bell,
  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: "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>
  );
 }
@@ -140,8 +140,8 @@ export function ConnectionsManager({ connections }: { connections: ConnectionWit
  }
  async function remove(connection: ConnectionWithCount) {
-    const linked = connection._count?.repositories ?? 0;
+    const linked = connection._count?.projects ?? 0;
-    const hint = linked > 0 ? `\n\n${linked} Repository(s) verlieren die Verknuepfung.` : "";
+    const hint = linked > 0 ? `\n\n${linked} Projekt(e) 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">Repositories</dt>
+                    <dt className="text-slate-500">Projekte</dt>
                    <dd className="tabular-nums text-slate-300">
-                      {connection._count?.repositories ?? 0}
+                      {connection._count?.projects ?? 0}
                    </dd>
                  </div>
                  {connection.lastCheckedAt ? (
@@ -3,46 +3,32 @@
 import { useState } from "react";
 import { useRouter } from "next/navigation";
 import {
  Activity,
  AlertTriangle,
  CircleDot,
  ExternalLink,
  GitBranch,
  GitCommitHorizontal,
  GitMerge,
  GitPullRequest,
  HardDrive,
  ListPlus,
  Loader2,
  Lock,
  Package,
  Plus,
  RefreshCw,
  ShieldCheck,
  Star,
  Tag,
  Unlink,
 } from "lucide-react";
 import { CiBadge } from "@/components/CiBadge";
 import { RepositoryDialog } from "@/components/RepositoryDialog";
 import { Sparkline } from "@/components/Sparkline";
 import { repoTitle } from "@/lib/git/meta";
 import { asArray, asRecord } from "@/types";
 import type {
  BranchInfo,
  CommitInfo,
  ConnectionSafe,
  ProjectDetail,
  ReleaseInfo,
  RepositoryWithSnapshot,
  TagInfo,
  TicketInfo,
 } from "@/types";
 import { cn, formatDateTime, formatNumber, formatRelative } from "@/lib/utils";
 const TABS = [
  { key: "pulls", label: "PRs", icon: GitPullRequest },
  { key: "issues", label: "Issues", icon: CircleDot },
  { key: "branches", label: "Branches", icon: GitBranch },
  { key: "tags", label: "Tags", icon: Tag },
  { key: "commits", label: "Commits", icon: GitCommitHorizontal },
@@ -51,74 +37,26 @@ const TABS = [
 type TabKey = (typeof TABS)[number]["key"];
-export function GitPanel({
+export function GitPanel({ project }: { project: ProjectDetail }) {
  project,
  connections,
 }: {
  project: ProjectDetail;
  connections: ConnectionSafe[];
 }) {
  const router = useRouter();
-  const [tab, setTab] = useState<TabKey>("pulls");
+  const [tab, setTab] = useState<TabKey>("branches");
  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 repositories = project.repositories;
+  const snapshot = project.snapshot;
  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;
  /** 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);
  const releases = asArray<ReleaseInfo>(snapshot?.releases);
  const languages = asRecord(snapshot?.languages);
  const pulls = asArray<TicketInfo>(snapshot?.pullRequests);
  const issues = asArray<TicketInfo>(snapshot?.issues);
  const activity = asArray<number>(snapshot?.commitActivity);
-  /** Ein einzelnes Repository oder – ohne Argument – alle. */
+  const hasRepo = Boolean(project.repoOwner && project.repoName) || Boolean(project.repoUrl);
-  async function sync(nurDieses?: string) {
+
  async function sync() {
    setSyncing(true);
    setMessage(null);
    try {
-      const url = nurDieses
+      const response = await fetch(`/api/projects/${project.id}/sync`, { method: "POST" });
        ? `/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();
@@ -132,41 +70,16 @@ export function GitPanel({
    }
  }
-  async function removeRepository(entry: RepositoryWithSnapshot) {
+  if (!hasRepo) {
    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">
-        <div className="glass px-5 py-10 text-center">
+        <GitBranch className="mx-auto h-8 w-8 text-slate-600" />
-          <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>
-          <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">
-          <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>
-          </p>
+      </div>
          <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}
        />
      </>
    );
  }
@@ -177,53 +90,12 @@ export function GitPanel({
  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 ?? repoTitle(repository)}
+              {snapshot?.fullName ?? `${project.repoOwner}/${project.repoName}`}
            </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">
@@ -246,70 +118,24 @@ export function GitPanel({
                <ExternalLink className="h-3.5 w-3.5" />
              </a>
            ) : null}
            <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} url={snapshot?.ciUrl} />
          </div>
          <p className="mt-1 text-xs text-slate-500" suppressHydrationWarning>
-            {repository.lastSyncedAt
+            {project.lastSyncedAt
-              ? `Zuletzt synchronisiert ${formatRelative(repository.lastSyncedAt)} · ${formatDateTime(repository.lastSyncedAt)}`
+              ? `Zuletzt synchronisiert ${formatRelative(project.lastSyncedAt)} · ${formatDateTime(project.lastSyncedAt)}`
              : "Noch nie synchronisiert."}
          </p>
        </div>
-        <div className="flex flex-wrap items-center gap-2">
+        <button type="button" className="btn btn-primary" onClick={sync} disabled={syncing}>
-          {repositories.length > 1 ? (
+          {syncing ? (
-            <button
+            <Loader2 className="h-4 w-4 animate-spin" />
              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
+            <RefreshCw className="h-4 w-4" />
              type="button"
              onClick={() => setAddOpen(true)}
              className="btn btn-ghost"
              title="Weiteres Repository verknuepfen"
            >
              <Plus className="h-4 w-4" />
              Repository
            </button>
          )}
-          <button
+          Jetzt synchronisieren
-            type="button"
+        </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" />
            ) : (
              <RefreshCw className="h-4 w-4" />
            )}
            Jetzt synchronisieren
          </button>
        </div>
      </div>
      <RepositoryDialog
        open={addOpen}
        onClose={() => setAddOpen(false)}
        projectId={project.id}
        connections={connections}
      />
      {message ? (
        <p
          className={cn(
@@ -323,10 +149,10 @@ export function GitPanel({
        </p>
      ) : null}
-      {repository.syncError && !message ? (
+      {project.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>{repository.syncError}</span>
+          <span>{project.syncError}</span>
        </p>
      ) : null}
@@ -398,24 +224,6 @@ export function GitPanel({
            </div>
          </div>
          {/* Commit-Aktivitaet */}
          {activity.some((value) => value > 0) ? (
            <div className="glass p-4">
              <div className="mb-2.5 flex items-center justify-between">
                <p className="flex items-center gap-1.5 text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">
                  <Activity className="h-3 w-3" />
                  {/* Der Zeitraum richtet sich danach, wie weit die geholten
                      Commits zurueckreichen – hoechstens 30 Tage. */}
                  Commits der letzten {activity.length} Tage
                </p>
                <span className="text-xs tabular-nums text-slate-400">
                  {activity.reduce((sum, value) => sum + value, 0)}
                </span>
              </div>
              <Sparkline values={activity} height={40} />
            </div>
          ) : null}
          {/* Sprachen */}
          {languageTotal > 0 ? (
            <div className="glass p-4">
@@ -455,14 +263,14 @@ export function GitPanel({
          <div className="glass overflow-hidden">
            <div className="flex flex-wrap gap-1 border-b border-white/6 p-2">
              {TABS.map(({ key, label, icon: Icon }) => {
-                const count = {
+                const count =
-                  pulls: pulls.length,
+                  key === "branches"
-                  issues: issues.length,
+                    ? branches.length
-                  branches: branches.length,
+                    : key === "tags"
-                  tags: tags.length,
+                      ? tags.length
-                  commits: commits.length,
+                      : key === "commits"
-                  releases: releases.length,
+                        ? commits.length
-                }[key];
+                        : releases.length;
                return (
                  <button
                    key={key}
@@ -484,39 +292,6 @@ export function GitPanel({
            </div>
            <div className="max-h-[26rem] overflow-y-auto">
              {tab === "pulls" ? (
                <TicketList
                  tickets={pulls}
                  empty="Keine offenen Pull oder Merge Requests."
                  icon={GitPullRequest}
                />
              ) : 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}
              {tab === "commits" ? <CommitList commits={commits} /> : null}
@@ -567,67 +342,6 @@ function Empty({ text }: { text: string }) {
  return <p className="px-4 py-8 text-center text-xs text-slate-500">{text}</p>;
 }
 function TicketList({
  tickets,
  empty,
  icon: Icon,
 }: {
  tickets: TicketInfo[];
  empty: string;
  icon: typeof GitPullRequest;
 }) {
  if (tickets.length === 0) return <Empty text={empty} />;
  return (
    <div>
      {tickets.map((ticket) => (
        <Row key={`${ticket.number}-${ticket.title}`}>
          <div className="flex min-w-0 items-start gap-2">
            <Icon
              className={cn(
                "mt-0.5 h-3.5 w-3.5 shrink-0",
                ticket.draft ? "text-slate-600" : "text-emerald-400/70",
              )}
            />
            <div className="min-w-0">
              <p className="truncate text-xs text-slate-200">
                {ticket.title}
                {ticket.draft ? (
                  <span className="ml-1.5 rounded bg-slate-500/15 px-1 py-0.5 text-[10px] text-slate-400">
                    Entwurf
                  </span>
                ) : null}
              </p>
              <p className="mt-0.5 flex flex-wrap items-center gap-x-2 text-[11px] text-slate-500">
                <span className="font-mono text-slate-600">#{ticket.number}</span>
                <span>{ticket.author ?? "unbekannt"}</span>
                {ticket.labels.slice(0, 3).map((label) => (
                  <span key={label} className="rounded bg-white/6 px-1 py-0.5 text-[10px]">
                    {label}
                  </span>
                ))}
              </p>
            </div>
          </div>
          <div className="flex shrink-0 items-center gap-2 text-[11px] text-slate-500">
            <span suppressHydrationWarning>{formatRelative(ticket.createdAt)}</span>
            {ticket.url ? (
              <a
                href={ticket.url}
                target="_blank"
                rel="noreferrer noopener"
                className="text-slate-600 transition-colors hover:text-violet-300"
                aria-label="Im Git-System oeffnen"
              >
                <ExternalLink className="h-3 w-3" />
              </a>
            ) : null}
          </div>
        </Row>
      ))}
    </div>
  );
 }
 function BranchList({ branches }: { branches: BranchInfo[] }) {
  if (branches.length === 0) return <Empty text="Keine Branches gefunden." />;
  return (
@@ -1,326 +0,0 @@
 "use client";
 import { useRef, useState } from "react";
 import { useRouter } from "next/navigation";
 import {
  AlertTriangle,
  ArrowRight,
  CheckCircle2,
  FileJson,
  Loader2,
  Upload,
 } from "lucide-react";
 import { Modal } from "@/components/ui/Modal";
 import { cn } from "@/lib/utils";
 type Strategy = "skip" | "rename" | "overwrite";
 interface ItemResult {
  name: string;
  slug: string;
  action: "create" | "rename" | "overwrite" | "skip" | "error";
  newSlug?: string;
  notes: number;
  connection: "matched" | "missing" | "none";
  connectionName?: string;
  message?: string;
 }
 interface ImportResponse {
  dryRun: boolean;
  strategy: Strategy;
  summary: {
    total: number;
    created: number;
    renamed: number;
    overwritten: number;
    skipped: number;
    errors: number;
    missingConnections: number;
  };
  results: ItemResult[];
 }
 const STRATEGIES: Array<{ value: Strategy; label: string; hint: string }> = [
  { value: "skip", label: "Ueberspringen", hint: "Vorhandene bleiben unveraendert." },
  { value: "rename", label: "Zusaetzlich anlegen", hint: "Doppelte bekommen einen freien Slug." },
  { value: "overwrite", label: "Ersetzen", hint: "Stammdaten und Notizen werden ueberschrieben." },
 ];
 const ACTION_LABEL: Record<ItemResult["action"], { text: string; className: string }> = {
  create: { text: "neu", className: "bg-emerald-500/12 text-emerald-200" },
  rename: { text: "zusaetzlich", className: "bg-cyan-500/12 text-cyan-200" },
  overwrite: { text: "ersetzt", className: "bg-amber-500/12 text-amber-200" },
  skip: { text: "uebersprungen", className: "bg-slate-500/12 text-slate-300" },
  error: { text: "Fehler", className: "bg-rose-500/12 text-rose-200" },
 };
 export function ImportDialog({ open, onClose }: { open: boolean; onClose: () => void }) {
  const router = useRouter();
  const fileRef = useRef<HTMLInputElement>(null);
  const [fileName, setFileName] = useState<string | null>(null);
  const [payload, setPayload] = useState<unknown>(null);
  const [strategy, setStrategy] = useState<Strategy>("skip");
  const [preview, setPreview] = useState<ImportResponse | null>(null);
  const [done, setDone] = useState<ImportResponse | null>(null);
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string | null>(null);
  function reset() {
    setFileName(null);
    setPayload(null);
    setPreview(null);
    setDone(null);
    setError(null);
    setStrategy("skip");
    if (fileRef.current) fileRef.current.value = "";
  }
  function close() {
    reset();
    onClose();
  }
  async function pickFile(event: React.ChangeEvent<HTMLInputElement>) {
    const file = event.target.files?.[0];
    if (!file) return;
    setError(null);
    setPreview(null);
    setDone(null);
    setFileName(file.name);
    try {
      const text = await file.text();
      const parsed = JSON.parse(text);
      setPayload(parsed);
      await run(parsed, strategy, true);
    } catch {
      setPayload(null);
      setError("Die Datei enthaelt kein gueltiges JSON.");
    }
  }
  async function run(data: unknown, chosen: Strategy, dryRun: boolean) {
    setBusy(true);
    setError(null);
    try {
      const response = await fetch("/api/projects/import", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ data, strategy: chosen, dryRun }),
      });
      const body = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(body.error ?? "Import fehlgeschlagen.");
      if (dryRun) setPreview(body as ImportResponse);
      else {
        setDone(body as ImportResponse);
        router.refresh();
      }
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setBusy(false);
    }
  }
  async function changeStrategy(next: Strategy) {
    setStrategy(next);
    if (payload) await run(payload, next, true);
  }
  const summary = done?.summary ?? preview?.summary;
  const results = done?.results ?? preview?.results ?? [];
  // Wuerde der Import ueberhaupt etwas veraendern? Sonst waere der Knopf ein
  // Angebot, das ins Leere laeuft.
  const wouldChange = preview
    ? preview.summary.created + preview.summary.renamed + preview.summary.overwritten > 0
    : false;
  return (
    <Modal
      open={open}
      onClose={close}
      width="xl"
      title="Projekte importieren"
      description="Eine zuvor exportierte JSON-Datei einlesen. Vor dem Schreiben gibt es eine Vorschau."
    >
      <div className="space-y-5">
        {/* Datei */}
        <div>
          <input
            ref={fileRef}
            type="file"
            accept="application/json,.json"
            onChange={pickFile}
            className="hidden"
            id="import-file"
          />
          <button
            type="button"
            className="btn btn-ghost w-full justify-start py-3"
            onClick={() => fileRef.current?.click()}
            disabled={busy}
          >
            <FileJson className="h-4 w-4 text-violet-300" />
            {fileName ?? "JSON-Datei auswaehlen…"}
          </button>
        </div>
        {/* Strategie */}
        {payload ? (
          <div>
            <span className="field-label">Bei gleichem Slug</span>
            <div className="grid gap-2 sm:grid-cols-3">
              {STRATEGIES.map((option) => (
                <button
                  key={option.value}
                  type="button"
                  disabled={busy || Boolean(done)}
                  onClick={() => changeStrategy(option.value)}
                  className={cn(
                    "rounded-xl border px-3 py-2.5 text-left transition-all disabled:opacity-60",
                    strategy === option.value
                      ? "border-violet-400/60 bg-violet-500/12"
                      : "border-white/9 hover:border-white/20",
                  )}
                >
                  <span className="block text-sm text-slate-100">{option.label}</span>
                  <span className="mt-0.5 block text-[11px] leading-snug text-slate-500">
                    {option.hint}
                  </span>
                </button>
              ))}
            </div>
          </div>
        ) : null}
        {error ? (
          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
            {error}
          </p>
        ) : null}
        {/* Vorschau oder Ergebnis */}
        {summary ? (
          <div className="space-y-3">
            <div className="flex flex-wrap items-center gap-2 text-xs">
              <span className="text-slate-400">
                {done ? "Ergebnis:" : "Vorschau:"} {summary.total} Projekt(e)
              </span>
              {summary.created > 0 ? <Chip tone="emerald">{summary.created} neu</Chip> : null}
              {summary.renamed > 0 ? <Chip tone="cyan">{summary.renamed} zusaetzlich</Chip> : null}
              {summary.overwritten > 0 ? (
                <Chip tone="amber">{summary.overwritten} ersetzt</Chip>
              ) : null}
              {summary.skipped > 0 ? <Chip tone="slate">{summary.skipped} uebersprungen</Chip> : null}
              {summary.errors > 0 ? <Chip tone="rose">{summary.errors} Fehler</Chip> : null}
            </div>
            {summary.missingConnections > 0 ? (
              <p className="flex items-start gap-2 rounded-lg border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-xs text-amber-200">
                <AlertTriangle className="mt-0.5 h-3.5 w-3.5 shrink-0" />
                <span>
                  {summary.missingConnections} Projekt(e) verweisen auf eine Git-Verbindung,
                  die hier nicht existiert. Sie werden ohne Verknuepfung angelegt – lege die
                  Verbindung an und waehle sie im Projekt aus. Access Tokens sind in
                  Exportdateien grundsaetzlich nicht enthalten.
                </span>
              </p>
            ) : null}
            <div className="max-h-64 overflow-y-auto rounded-xl border border-white/8">
              {results.map((item) => {
                const label = ACTION_LABEL[item.action];
                return (
                  <div
                    key={`${item.slug}-${item.name}`}
                    className="flex items-center justify-between gap-3 border-b border-white/5 px-3 py-2 last:border-b-0"
                  >
                    <div className="min-w-0">
                      <p className="truncate text-sm text-slate-200">{item.name}</p>
                      <p className="mt-0.5 flex flex-wrap items-center gap-x-2 font-mono text-[11px] text-slate-500">
                        <span>{item.slug}</span>
                        {item.newSlug ? (
                          <>
                            <ArrowRight className="h-3 w-3" />
                            <span className="text-cyan-300">{item.newSlug}</span>
                          </>
                        ) : null}
                        <span className="text-slate-600">· {item.notes} Notizen</span>
                        {item.connection === "missing" ? (
                          <span className="text-amber-300/80">
                            · Verbindung „{item.connectionName}“ fehlt
                          </span>
                        ) : null}
                      </p>
                      {item.message ? (
                        <p className="mt-0.5 text-[11px] text-slate-600">{item.message}</p>
                      ) : null}
                    </div>
                    <span
                      className={cn(
                        "shrink-0 rounded px-1.5 py-0.5 text-[10px] uppercase tracking-wider",
                        label.className,
                      )}
                    >
                      {label.text}
                    </span>
                  </div>
                );
              })}
            </div>
          </div>
        ) : null}
        {done ? (
          <p className="flex items-center gap-2 rounded-lg border border-emerald-500/30 bg-emerald-500/10 px-3 py-2 text-sm text-emerald-200">
            <CheckCircle2 className="h-4 w-4" />
            Import abgeschlossen.
          </p>
        ) : null}
        <div className="flex justify-end gap-2">
          <button type="button" className="btn btn-ghost" onClick={close} disabled={busy}>
            {done ? "Schliessen" : "Abbrechen"}
          </button>
          {!done ? (
            <button
              type="button"
              className="btn btn-primary"
              disabled={busy || !wouldChange}
              title={
                preview && !wouldChange
                  ? "Mit dieser Strategie wuerde sich nichts aendern."
                  : undefined
              }
              onClick={() => payload && run(payload, strategy, false)}
            >
              {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Upload className="h-4 w-4" />}
              Import ausfuehren
            </button>
          ) : null}
        </div>
      </div>
    </Modal>
  );
 }
 function Chip({
  tone,
  children,
 }: {
  tone: "emerald" | "cyan" | "amber" | "slate" | "rose";
  children: React.ReactNode;
 }) {
  const tones = {
    emerald: "bg-emerald-500/12 text-emerald-200",
    cyan: "bg-cyan-500/12 text-cyan-200",
    amber: "bg-amber-500/12 text-amber-200",
    slate: "bg-slate-500/12 text-slate-300",
    rose: "bg-rose-500/12 text-rose-200",
  };
  return <span className={cn("rounded px-1.5 py-0.5", tones[tone])}>{children}</span>;
 }
@@ -1,277 +0,0 @@
 "use client";
 import { useEffect, useMemo, useState } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import {
  DndContext,
  DragOverlay,
  PointerSensor,
  TouchSensor,
  closestCorners,
  useDraggable,
  useDroppable,
  useSensor,
  useSensors,
  type DragEndEvent,
  type DragStartEvent,
 } from "@dnd-kit/core";
 import { restrictToWindowEdges } from "@dnd-kit/modifiers";
 import { GitBranch, GripVertical, 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";
 /**
 * Statusspalten mit Ziehen und Ablegen.
 *
 * Der Statuswechsel wird sofort angezeigt und erst danach gespeichert;
 * scheitert das Speichern, springt die Karte zurueck. Die Reihenfolge
 * innerhalb einer Spalte ist nicht frei sortierbar – sie folgt der im Board
 * gewaehlten Sortierung, sonst muesste eine Position mitgespeichert werden.
 */
 export function KanbanBoard({
  projects,
  showArchived,
 }: {
  projects: ProjectListItem[];
  showArchived: boolean;
 }) {
  const router = useRouter();
  const [overrides, setOverrides] = useState<Record<string, ProjectStatus>>({});
  const [activeId, setActiveId] = useState<string | null>(null);
  // Eine Verschiebung, die der Server bestaetigt hat, braucht keine
  // oertliche Ausnahme mehr.
  useEffect(() => {
    setOverrides((current) => {
      const next: Record<string, ProjectStatus> = {};
      for (const [id, status] of Object.entries(current)) {
        const project = projects.find((entry) => entry.id === id);
        if (project && project.status !== status) next[id] = status;
      }
      return Object.keys(next).length === Object.keys(current).length ? current : next;
    });
  }, [projects]);
  const sensors = useSensors(
    // Erst ab ein paar Pixeln Bewegung ziehen – sonst liesse sich die Karte
    // nicht mehr anklicken.
    useSensor(PointerSensor, { activationConstraint: { distance: 6 } }),
    useSensor(TouchSensor, { activationConstraint: { delay: 180, tolerance: 8 } }),
  );
  const statusOf = (project: ProjectListItem) => overrides[project.id] ?? project.status;
  const columns = useMemo(() => {
    const visible = STATUS_ORDER.filter(
      (status) => showArchived || status !== "ARCHIVED",
    );
    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) {
    setActiveId(String(event.active.id));
  }
  async function onDragEnd(event: DragEndEvent) {
    setActiveId(null);
    const id = String(event.active.id);
    const target = event.over?.id ? (String(event.over.id) as ProjectStatus) : null;
    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}`, {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ status: target }),
      });
      if (!response.ok) throw new Error("failed");
      router.refresh();
    } catch {
      setOverrides((current) => {
        const next = { ...current };
        delete next[id];
        return next;
      });
    }
  }
  return (
    <DndContext
      sensors={sensors}
      collisionDetection={closestCorners}
      modifiers={[restrictToWindowEdges]}
      onDragStart={onDragStart}
      onDragEnd={onDragEnd}
      onDragCancel={() => setActiveId(null)}
    >
      <div className="flex gap-3 overflow-x-auto pb-3">
        {columns.map((column) => (
          <Column key={column.status} status={column.status} count={column.items.length}>
            {column.items.map((project) => (
              <KanbanCard key={project.id} project={project} />
            ))}
          </Column>
        ))}
      </div>
      {/* Die mitgezogene Karte haengt am Cursor, nicht in der Spalte. */}
      <DragOverlay dropAnimation={{ duration: 180, easing: "cubic-bezier(0.22, 1, 0.36, 1)" }}>
        {active ? <KanbanCard project={active} overlay /> : null}
      </DragOverlay>
    </DndContext>
  );
 }
 function Column({
  status,
  count,
  children,
 }: {
  status: ProjectStatus;
  count: number;
  children: React.ReactNode;
 }) {
  const meta = STATUS_META[status];
  const { setNodeRef, isOver } = useDroppable({ id: status });
  return (
    <section
      ref={setNodeRef}
      // 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",
        isOver && "border-violet-400/40 bg-violet-500/6",
      )}
    >
      <header className="flex items-center gap-2 px-3 py-2.5">
        <span
          className="accent-dot h-2 w-2 rounded-full"
          style={{ backgroundColor: meta.color, color: meta.color }}
        />
        <h3 className="text-xs font-semibold uppercase tracking-wider text-slate-300">
          {meta.label}
        </h3>
        <span className="ml-auto rounded-full bg-white/6 px-1.5 py-0.5 text-[10px] tabular-nums text-slate-400">
          {count}
        </span>
      </header>
      <div className="flex min-h-[7rem] flex-1 flex-col gap-2 px-2 pb-2">
        {children}
        {count === 0 ? (
          <p
            className={cn(
              "rounded-xl border border-dashed border-white/8 px-3 py-6 text-center text-[11px] text-slate-600 transition-colors",
              isOver && "border-violet-400/40 text-violet-200",
            )}
          >
            {isOver ? "Hier ablegen" : "leer"}
          </p>
        ) : null}
      </div>
    </section>
  );
 }
 function KanbanCard({
  project,
  overlay = false,
 }: {
  project: ProjectListItem;
  overlay?: boolean;
 }) {
  const accent = accentOf(project.accent);
  const { attributes, listeners, setNodeRef, isDragging } = useDraggable({ id: project.id });
  return (
    <article
      ref={overlay ? undefined : setNodeRef}
      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",
      )}
      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" />
      <div className="flex items-start gap-2">
        {/* Nur der Griff zieht – so bleibt der Titel ein normaler Link. */}
        <button
          type="button"
          className="mt-0.5 shrink-0 cursor-grab touch-none rounded p-0.5 text-slate-600 transition-colors hover:text-slate-300 active:cursor-grabbing"
          aria-label={`${project.name} verschieben`}
          {...attributes}
          {...listeners}
        >
          <GripVertical className="h-3.5 w-3.5" />
        </button>
        <div className="min-w-0 flex-1">
          <Link
            href={`/projects/${project.id}`}
            className="block truncate text-sm font-medium text-slate-100 hover:text-violet-200"
          >
            {project.name}
          </Link>
          {project.summary ? (
            <p className="mt-0.5 line-clamp-2 text-[11px] leading-snug text-slate-500">
              {truncate(project.summary, 90)}
            </p>
          ) : null}
        </div>
      </div>
      <div className="mt-2.5 h-1 w-full overflow-hidden rounded-full bg-white/6">
        <div
          className="accent-bar h-full rounded-full"
          style={{ width: `${Math.max(2, project.progress)}%` }}
        />
      </div>
      <div className="mt-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 text-[10px] text-slate-500">
        {/* Auf der schmalen Kanban-Karte nur das fuehrende Repository. */}
        <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.repositories[0].snapshot.defaultBranch}
          </span>
        ) : null}
        {project._count.notes > 0 ? (
          <span className="inline-flex items-center gap-1">
            <NotebookPen className="h-3 w-3" />
            {project._count.notes}
          </span>
        ) : null}
        <span className="ml-auto tabular-nums">{project.progress}%</span>
      </div>
    </article>
  );
 }
@@ -1,55 +0,0 @@
 "use client";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
 import { cn } from "@/lib/utils";
 /**
 * Markdown-Darstellung fuer Beschreibungen und Notizen.
 *
 * Der Inhalt stammt vom Benutzer, wird aber unveraendert gerendert – ohne
 * rehype-sanitize waere das ein XSS-Loch, sobald jemand rohes HTML in eine
 * Notiz schreibt. Das Standardschema erlaubt nur harmlose Elemente; ergaenzt
 * wird lediglich, was fuer Aufgabenlisten und Codebloecke noetig ist.
 */
 const schema = {
  ...defaultSchema,
  attributes: {
    ...defaultSchema.attributes,
    // Checkboxen aus "- [ ] Aufgabe"
    input: [...(defaultSchema.attributes?.input ?? []), "checked", "disabled", "type"],
    // Sprachklassen wie "language-ts" fuer Codebloecke
    code: [...(defaultSchema.attributes?.code ?? []), ["className", /^language-./]],
  },
 };
 export function Markdown({
  children,
  className,
 }: {
  children: string | null | undefined;
  className?: string;
 }) {
  if (!children?.trim()) return null;
  return (
    <div className={cn("md", className)}>
      <ReactMarkdown
        remarkPlugins={[remarkGfm]}
        rehypePlugins={[[rehypeSanitize, schema]]}
        components={{
          // Links aus fremdem Inhalt immer in neuem Tab und ohne
          // Zugriff auf das oeffnende Fenster.
          a: ({ href, children: content }) => (
            <a href={href} target="_blank" rel="noreferrer noopener nofollow">
              {content}
            </a>
          ),
        }}
      >
        {children}
      </ReactMarkdown>
    </div>
  );
 }
@@ -4,7 +4,6 @@ import { useState } from "react";
 import { useRouter } from "next/navigation";
 import { Loader2, NotebookPen, Pencil, Pin, PinOff, Plus, Trash2, X } from "lucide-react";
 import type { Note } from "@prisma/client";
 import { Markdown } from "@/components/Markdown";
 import { cn, formatDateTime, formatRelative } from "@/lib/utils";
 /** Nur als "bearbeitet" zaehlen, wenn wirklich spaeter geaendert wurde. */
@@ -119,7 +118,7 @@ export function NotesPanel({ projectId, notes }: { projectId: string; notes: Not
          />
          <textarea
            className="field min-h-32 resize-y font-mono text-[13px] leading-relaxed"
-            placeholder={"Gedanken, Todos, Snippets…\n\nMarkdown wird dargestellt:\n- [ ] offene Aufgabe\n**fett**, `code`, [Link](https://…)"}
+            placeholder="Gedanken, Todos, Snippets… Zeilenumbrueche bleiben erhalten."
            value={content}
            onChange={(event) => setContent(event.target.value)}
            autoFocus
@@ -162,7 +161,9 @@ export function NotesPanel({ projectId, notes }: { projectId: string; notes: Not
                    {note.title}
                  </h3>
                ) : null}
-                <Markdown className="mt-1">{note.content}</Markdown>
+                <p className="mt-1 whitespace-pre-wrap break-words text-sm leading-relaxed text-slate-300">
                  {note.content}
                </p>
                <p className="mt-2.5 text-[11px] text-slate-600" suppressHydrationWarning>
                  {formatDateTime(note.createdAt)}
                  {wasEdited(note) ? ` · bearbeitet ${formatRelative(note.updatedAt)}` : null}
@@ -1,58 +1,16 @@
 "use client";
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useMemo, useState } from "react";
-import Link from "next/link";
+import { LayoutGrid, ListFilter, Plus, Rows3, Search, X } from "lucide-react";
 import {
  Columns3,
  Database,
  Download,
  LayoutGrid,
  ListFilter,
  NotebookPen,
  Plus,
  Rows3,
  Search,
  Upload,
  X,
 } from "lucide-react";
 import type { ProjectStatus } from "@prisma/client";
 import { ImportDialog } from "@/components/ImportDialog";
 import { KanbanBoard } from "@/components/KanbanBoard";
 import { ProjectCard } from "@/components/ProjectCard";
 import { ProjectDialog } from "@/components/ProjectDialog";
 import { Popover } from "@/components/ui/Popover";
 import { STATUS_META, STATUS_ORDER } from "@/lib/status";
 import { cn } from "@/lib/utils";
 import type { ConnectionSafe, ProjectListItem } from "@/types";
 interface NoteHit {
  projectId: string;
  noteId: string;
  title: string | null;
  /** Ausschnitt mit [[…]] um die Fundstelle – siehe /api/search. */
  snippet: string;
 }
 /**
 * Wandelt die [[…]]-Markierungen von ts_headline in hervorgehobene Stellen.
 * Bewusst kein HTML aus der Datenbank einbetten – der Text stammt aus einer
 * Notiz und damit vom Benutzer.
 */
 function highlight(snippet: string): React.ReactNode[] {
  return snippet.split(/(\[\[.*?\]\])/g).map((part, index) => {
    if (part.startsWith("[[") && part.endsWith("]]")) {
      return (
        <mark key={index} className="rounded bg-violet-500/25 px-0.5 text-violet-100">
          {part.slice(2, -2)}
        </mark>
      );
    }
    return <span key={index}>{part}</span>;
  });
 }
 type SortKey = "updated" | "created" | "name" | "progress" | "priority";
-type ViewMode = "grid" | "grouped" | "kanban";
+type ViewMode = "grid" | "grouped";
 const SORT_LABEL: Record<SortKey, string> = {
  updated: "Zuletzt geaendert",
@@ -75,48 +33,6 @@ export function ProjectBoard({
  const [view, setView] = useState<ViewMode>("grid");
  const [showArchived, setShowArchived] = useState(false);
  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[]>([]);
  /**
   * Notizen liegen im Board nicht vor – sie mitzuladen wuerde die Seite
   * unnoetig aufblaehen. Stattdessen sucht Postgres serverseitig, sobald der
   * Begriff lang genug ist. Entprellt, damit nicht jeder Tastendruck eine
   * Abfrage ausloest.
   */
  useEffect(() => {
    const needle = query.trim();
    if (needle.length < 2) {
      setNoteHits([]);
      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[] };
        setNoteHits(body.hits ?? []);
      } catch {
        // Abgebrochene Anfragen sind der Normalfall beim Tippen.
      }
    }, 300);
    return () => {
      clearTimeout(timer);
      controller.abort();
    };
  }, [query]);
  const noteHitProjectIds = useMemo(
    () => new Set(noteHits.map((hit) => hit.projectId)),
    [noteHits],
  );
  const counts = useMemo(() => {
    const map = new Map<ProjectStatus, number>();
@@ -140,11 +56,7 @@ export function ProjectBoard({
        (project.summary ?? "").toLowerCase().includes(needle) ||
        (project.description ?? "").toLowerCase().includes(needle) ||
        project.tags.some((tag) => tag.includes(needle)) ||
-        project.repositories.some((repo) =>
+        (project.snapshot?.fullName ?? "").toLowerCase().includes(needle)
          (repo.snapshot?.fullName ?? "").toLowerCase().includes(needle),
        ) ||
        // Treffer in Notizen kommen vom Server dazu.
        noteHitProjectIds.has(project.id)
      );
    });
@@ -165,7 +77,7 @@ export function ProjectBoard({
    });
    return sorted;
-  }, [projects, query, statusFilter, sort, showArchived, noteHitProjectIds]);
+  }, [projects, query, statusFilter, sort, showArchived]);
  const grouped = useMemo(() => {
    return STATUS_ORDER.map((status) => ({
@@ -251,33 +163,8 @@ export function ProjectBoard({
              >
                <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"
              aria-label="Daten exportieren oder importieren"
              title="Export und Import"
              aria-haspopup="menu"
              aria-expanded={dataMenuOpen}
            >
              <Database className="h-4 w-4" />
            </button>
            <button type="button" className="btn btn-primary" onClick={() => setDialogOpen(true)}>
              <Plus className="h-4 w-4" />
              <span className="hidden sm:inline">Neues Projekt</span>
@@ -341,54 +228,9 @@ export function ProjectBoard({
        </div>
      </div>
      {/* Treffer in Notizen */}
      {noteHits.length > 0 ? (
        <div className="glass fade-up p-4">
          <h2 className="mb-2.5 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-wider text-slate-400">
            <NotebookPen className="h-3.5 w-3.5 text-violet-300" />
            Treffer in Notizen
            <span className="rounded-full bg-white/6 px-2 py-0.5 tabular-nums text-slate-400">
              {noteHits.length}
            </span>
          </h2>
          <ul className="space-y-1">
            {noteHits.slice(0, 8).map((hit) => {
              const project = projects.find((entry) => entry.id === hit.projectId);
              return (
                <li key={hit.noteId}>
                  <Link
                    href={`/projects/${hit.projectId}`}
                    className="block rounded-lg px-2.5 py-2 transition-colors hover:bg-white/5"
                  >
                    <span className="flex flex-wrap items-baseline gap-x-2">
                      <span className="text-sm text-slate-200">
                        {project?.name ?? "Projekt"}
                      </span>
                      {hit.title ? (
                        <span className="text-[11px] text-slate-500">· {hit.title}</span>
                      ) : null}
                    </span>
                    <span className="mt-0.5 block text-xs leading-snug text-slate-400">
                      {highlight(hit.snippet)}
                    </span>
                  </Link>
                </li>
              );
            })}
          </ul>
          {noteHits.length > 8 ? (
            <p className="mt-2 px-2.5 text-[11px] text-slate-600">
              … und {noteHits.length - 8} weitere
            </p>
          ) : null}
        </div>
      ) : null}
      {/* Inhalt */}
      {visible.length === 0 ? (
        <EmptyState hasFilters={hasFilters} onCreate={() => setDialogOpen(true)} />
      ) : view === "kanban" ? (
        <KanbanBoard projects={visible} showArchived={showArchived} />
      ) : view === "grid" ? (
        <div className="grid gap-4 sm:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4">
          {visible.map((project, index) => (
@@ -425,54 +267,11 @@ export function ProjectBoard({
        </div>
      )}
      <Popover
        anchorRef={dataButtonRef}
        open={dataMenuOpen}
        onClose={() => setDataMenuOpen(false)}
        width={260}
      >
        <a
          href="/api/projects/export"
          download
          role="menuitem"
          onClick={() => setDataMenuOpen(false)}
          className="flex items-start gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
        >
          <Download className="mt-0.5 h-4 w-4 shrink-0 text-violet-300" />
          <span>
            Alle Projekte exportieren
            <span className="mt-0.5 block text-[11px] text-slate-500">
              JSON mit Notizen, ohne Access Tokens
            </span>
          </span>
        </a>
        <button
          type="button"
          role="menuitem"
          onClick={() => {
            setDataMenuOpen(false);
            setImportOpen(true);
          }}
          className="flex w-full items-start gap-2.5 rounded-lg px-3 py-2 text-left text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
        >
          <Upload className="mt-0.5 h-4 w-4 shrink-0 text-cyan-300" />
          <span>
            Projekte importieren
            <span className="mt-0.5 block text-[11px] text-slate-500">
              Mit Vorschau vor dem Schreiben
            </span>
          </span>
        </button>
      </Popover>
      <ProjectDialog
        open={dialogOpen}
        onClose={() => setDialogOpen(false)}
        connections={connections}
      />
      <ImportDialog open={importOpen} onClose={() => setImportOpen(false)} />
    </section>
  );
 }
@@ -4,20 +4,16 @@ import Link from "next/link";
 import { useState } from "react";
 import {
  AlertTriangle,
  CheckSquare,
  GitBranch,
  GitCommitHorizontal,
  NotebookPen,
  Star,
  Tag,
 } from "lucide-react";
 import { CiBadge } from "@/components/CiBadge";
 import { Sparkline } from "@/components/Sparkline";
 import { StatusSelect } from "@/components/StatusSelect";
 import { repoTitle } from "@/lib/git/meta";
 import { PRIORITY_META, accentOf } from "@/lib/status";
 import { cn, formatRelative, truncate } from "@/lib/utils";
-import { asArray, type ProjectListItem } from "@/types";
+import type { ProjectListItem } from "@/types";
 const PROVIDER_LABEL: Record<string, string> = {
  GITHUB: "GitHub",
@@ -32,15 +28,7 @@ const PROVIDER_LABEL: Record<string, string> = {
 export function ProjectCard({ project, index = 0 }: { project: ProjectListItem; index?: number }) {
  const accent = accentOf(project.accent);
  const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
-  // Auf der Karte ist nur fuer eines Platz: das fuehrende. Wie viele es
+  const snapshot = project.snapshot;
  // insgesamt sind, sagt die Zahl daneben.
  const leading = project.repositories[0] ?? null;
  const snapshot = leading?.snapshot ?? null;
  const weitere = project.repositories.length - 1;
  // Ein Fehler an irgendeinem Repo gehoert auf die Karte, nicht nur einer am
  // fuehrenden – sonst bliebe er unbemerkt.
  const syncError = project.repositories.find((repo) => repo.syncError)?.syncError ?? null;
  const activity = asArray<number>(snapshot?.commitActivity);
  const [favorite, setFavorite] = useState(project.favorite);
  async function toggleFavorite() {
@@ -122,31 +110,12 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
          </div>
        </div>
        {/* Commit-Aktivitaet */}
        {activity.some((value) => value > 0) ? (
          <div className="mt-3">
            <Sparkline values={activity} height={20} />
          </div>
        ) : null}
        {/* Git-Kurzinfo */}
        <div className="mt-4 flex flex-wrap items-center gap-x-3 gap-y-2 text-[11px] text-slate-400">
-          <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} compact />
+          {project.connection ? (
          {leading?.connection ? (
            <span className="glass-soft inline-flex items-center gap-1.5 px-2 py-1">
              <span className="h-1.5 w-1.5 rounded-full bg-violet-400" aria-hidden="true" />
-              {PROVIDER_LABEL[leading.connection.provider] ?? leading.connection.provider}
+              {PROVIDER_LABEL[project.connection.provider] ?? project.connection.provider}
            </span>
          ) : null}
          {weitere > 0 ? (
            <span
              className="inline-flex items-center gap-1.5"
              title={project.repositories.map((repo) => repoTitle(repo)).join(", ")}
            >
              <GitBranch className="h-3.5 w-3.5 text-slate-500" />+{weitere} Repo
              {weitere === 1 ? "" : "s"}
            </span>
          ) : null}
@@ -174,16 +143,6 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
            </span>
          ) : null}
          {project._count.tasks > 0 ? (
            <span
              className="inline-flex items-center gap-1.5"
              title={`${project.tasks.length} von ${project._count.tasks} Aufgaben erledigt`}
            >
              <CheckSquare className="h-3.5 w-3.5 text-slate-500" />
              {project.tasks.length}/{project._count.tasks}
            </span>
          ) : null}
          {project._count.notes > 0 ? (
            <span className="inline-flex items-center gap-1.5">
              <NotebookPen className="h-3.5 w-3.5 text-slate-500" />
@@ -191,8 +150,11 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
            </span>
          ) : null}
-          {syncError ? (
+          {project.syncError ? (
-            <span className="inline-flex items-center gap-1.5 text-rose-300/80" title={syncError}>
+            <span
              className="inline-flex items-center gap-1.5 text-rose-300/80"
              title={project.syncError}
            >
              <AlertTriangle className="h-3.5 w-3.5" />
              Sync-Fehler
            </span>
@@ -31,8 +31,6 @@ interface FormState {
  repoUrl: string;
  repoOwner: string;
  repoName: string;
  autoSync: boolean;
  progressFromTasks: boolean;
 }
 const EMPTY: FormState = {
@@ -49,8 +47,6 @@ const EMPTY: FormState = {
  repoUrl: "",
  repoOwner: "",
  repoName: "",
  autoSync: true,
  progressFromTasks: false,
 };
 export function ProjectDialog({ open, onClose, connections, project }: ProjectDialogProps) {
@@ -87,15 +83,10 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
            accent: project.accent,
            tags: project.tags.join(", "),
            favorite: project.favorite,
-            // Der Dialog bearbeitet das fuehrende Repository. Weitere
+            connectionId: project.connectionId ?? "",
-            // verwaltet das Git-Panel – hier wuerde eine Liste den Dialog
+            repoUrl: project.repoUrl ?? "",
-            // sprengen, in dem es eigentlich um das Projekt geht.
+            repoOwner: project.repoOwner ?? "",
-            connectionId: project.repositories[0]?.connectionId ?? "",
+            repoName: project.repoName ?? "",
            repoUrl: project.repositories[0]?.repoUrl ?? "",
            repoOwner: project.repositories[0]?.repoOwner ?? "",
            repoName: project.repositories[0]?.repoName ?? "",
            autoSync: project.repositories[0]?.autoSync ?? true,
            progressFromTasks: project.progressFromTasks,
          }
        : EMPTY,
    );
@@ -163,8 +154,6 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
      repoUrl: form.repoUrl,
      repoOwner: form.repoOwner,
      repoName: form.repoName,
      autoSync: form.autoSync,
      progressFromTasks: form.progressFromTasks,
    };
    try {
@@ -298,25 +287,8 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
              step={5}
              value={form.progress}
              onChange={(event) => update("progress", Number(event.target.value))}
-              disabled={form.progressFromTasks}
+              className="w-full accent-violet-500"
              className={cn("range", form.progressFromTasks && "cursor-not-allowed opacity-40")}
              style={{ "--fill": `${form.progress}%` } as React.CSSProperties}
            />
            <label className="mt-2 flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
              <input
                type="checkbox"
                checked={form.progressFromTasks}
                onChange={(event) => update("progressFromTasks", event.target.checked)}
                className="mt-0.5 h-4 w-4 accent-violet-500"
              />
              <span>
                Aus Aufgaben berechnen
                <span className="mt-0.5 block text-[11px] text-slate-600">
                  Der Fortschritt ergibt sich dann aus dem Anteil erledigter Aufgaben und
                  laesst sich nicht mehr von Hand schieben.
                </span>
              </span>
            </label>
          </div>
          <div className="sm:col-span-2">
@@ -441,22 +413,6 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
            </div>
          </div>
          <label className="flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
            <input
              type="checkbox"
              checked={form.autoSync}
              onChange={(event) => update("autoSync", event.target.checked)}
              className="mt-0.5 h-4 w-4 accent-violet-500"
            />
            <span>
              Am automatischen Abgleich teilnehmen
              <span className="mt-0.5 block text-[11px] text-slate-600">
                Wirkt nur, wenn der Abgleich im Adminbereich eingeschaltet ist. Manuell
                synchronisieren geht unabhaengig davon immer.
              </span>
            </span>
          </label>
          {repoError ? <p className="text-xs text-rose-300">{repoError}</p> : null}
          {repoPickerOpen ? (
@@ -1,16 +1,12 @@
 "use client";
-import { useRef, useState } from "react";
+import { useState } from "react";
 import { useRouter } from "next/navigation";
 import Link from "next/link";
 import {
  ArrowLeft,
  CalendarDays,
  CheckSquare,
  Download,
  ExternalLink,
  FileJson,
  FileText,
  Loader2,
  Pencil,
  Star,
@@ -18,8 +14,6 @@ import {
 } from "lucide-react";
 import { ProjectDialog } from "@/components/ProjectDialog";
 import { StatusSelect } from "@/components/StatusSelect";
 import { Popover } from "@/components/ui/Popover";
 import { repoTitle } from "@/lib/git/meta";
 import { PRIORITY_META, accentOf } from "@/lib/status";
 import { cn, formatDate } from "@/lib/utils";
 import type { ConnectionSafe, ProjectDetail } from "@/types";
@@ -36,8 +30,6 @@ export function ProjectHeader({
  const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
  const [editOpen, setEditOpen] = useState(false);
  const [exportOpen, setExportOpen] = useState(false);
  const exportButtonRef = useRef<HTMLButtonElement>(null);
  const [favorite, setFavorite] = useState(project.favorite);
  const [progress, setProgress] = useState(project.progress);
  const [deleting, setDeleting] = useState(false);
@@ -133,22 +125,24 @@ export function ProjectHeader({
              angelegt {formatDate(project.createdAt)}
            </span>
            <span style={{ color: priority.color }}>Prioritaet: {priority.label}</span>
-            {/* Alle Repositories verlinken – bei einem einzigen sieht das aus
+            {project.connection ? (
-                wie vorher, bei mehreren steht jedes fuer sich. */}
+              <span className="inline-flex items-center gap-1.5">
-            {project.repositories
+                {project.connection.name}
-              .filter((repository) => repository.repoUrl)
+                <span className="text-slate-700">·</span>
-              .map((repository) => (
+                {project.connection.provider}
-                <a
+              </span>
-                  key={repository.id}
+            ) : null}
-                  href={repository.repoUrl!}
+            {project.repoUrl ? (
-                  target="_blank"
+              <a
-                  rel="noreferrer noopener"
+                href={project.repoUrl}
-                  className="inline-flex items-center gap-1.5 text-violet-300 transition-colors hover:text-violet-200"
+                target="_blank"
-                >
+                rel="noreferrer noopener"
-                  {project.repositories.length === 1 ? "Repository" : repoTitle(repository)}
+                className="inline-flex items-center gap-1.5 text-violet-300 transition-colors hover:text-violet-200"
-                  <ExternalLink className="h-3 w-3" />
+              >
-                </a>
+                Repository
-              ))}
+                <ExternalLink className="h-3 w-3" />
              </a>
            ) : null}
          </div>
          {project.tags.length > 0 ? (
@@ -168,17 +162,6 @@ export function ProjectHeader({
        <div className="flex flex-col items-end gap-3">
          <StatusSelect projectId={project.id} status={project.status} />
          <div className="flex gap-2">
            <button
              ref={exportButtonRef}
              type="button"
              className="btn btn-ghost px-2.5 py-1.5 text-xs"
              onClick={() => setExportOpen((value) => !value)}
              aria-haspopup="menu"
              aria-expanded={exportOpen}
              title="Exportieren"
            >
              <Download className="h-3.5 w-3.5" />
            </button>
            <button
              type="button"
              className="btn btn-ghost px-3 py-1.5 text-xs"
@@ -207,77 +190,32 @@ export function ProjectHeader({
      {/* Fortschritt direkt regelbar */}
      <div className="mt-6">
        <div className="mb-2 flex items-center justify-between text-xs text-slate-500">
-          <span className="flex items-center gap-1.5">
+          <span>Fortschritt</span>
            Fortschritt
            {project.progressFromTasks ? (
              <span className="inline-flex items-center gap-1 rounded bg-white/6 px-1.5 py-0.5 text-[10px] text-slate-400">
                <CheckSquare className="h-2.5 w-2.5" />
                aus Aufgaben
              </span>
            ) : null}
          </span>
          <span className="tabular-nums text-slate-300">{progress}%</span>
        </div>
-        {/* Eigener Regler statt eines unsichtbaren Eingabefelds ueber einem
+        <div className="relative">
-            gezeichneten Balken: so gibt es einen sichtbaren Griff. */}
+          <div className="h-2 w-full overflow-hidden rounded-full bg-white/6">
-        <input
+            <div
-          type="range"
+              className="accent-bar h-full rounded-full transition-[width] duration-300"
-          min={0}
+              style={{ width: `${Math.max(1, progress)}%` }}
-          max={100}
+            />
-          step={5}
+          </div>
-          value={progress}
+          <input
-          onChange={(event) => setProgress(Number(event.target.value))}
+            type="range"
-          onMouseUp={() => patch({ progress })}
+            min={0}
-          onTouchEnd={() => patch({ progress })}
+            max={100}
-          onKeyUp={() => patch({ progress })}
+            step={5}
-          aria-label="Fortschritt anpassen"
+            value={progress}
-          // Wird der Wert aus Aufgaben abgeleitet, waere ein Zug hier
+            onChange={(event) => setProgress(Number(event.target.value))}
-          // wirkungslos – er wuerde beim naechsten Aufgabenwechsel wieder
+            onMouseUp={() => patch({ progress })}
-          // ueberschrieben.
+            onTouchEnd={() => patch({ progress })}
-          disabled={project.progressFromTasks}
+            onKeyUp={() => patch({ progress })}
-          className={cn("range", project.progressFromTasks && "cursor-not-allowed opacity-50")}
+            aria-label="Fortschritt anpassen"
-          style={{ "--fill": `${progress}%` } as React.CSSProperties}
+            className="absolute inset-0 h-2 w-full cursor-pointer opacity-0"
-        />
+          />
        </div>
      </div>
      <Popover
        anchorRef={exportButtonRef}
        open={exportOpen}
        onClose={() => setExportOpen(false)}
        width={250}
      >
        <a
          href={`/api/projects/${project.id}/export`}
          download
          role="menuitem"
          onClick={() => setExportOpen(false)}
          className="flex items-start gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
        >
          <FileJson className="mt-0.5 h-4 w-4 shrink-0 text-violet-300" />
          <span>
            Als JSON
            <span className="mt-0.5 block text-[11px] text-slate-500">
              Zum Wiedereinlesen, mit Notizen
            </span>
          </span>
        </a>
        <a
          href={`/api/projects/${project.id}/export?format=md`}
          download
          role="menuitem"
          onClick={() => setExportOpen(false)}
          className="flex items-start gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
        >
          <FileText className="mt-0.5 h-4 w-4 shrink-0 text-cyan-300" />
          <span>
            Als Markdown
            <span className="mt-0.5 block text-[11px] text-slate-500">
              Lesbar, inklusive Git-Stand
            </span>
          </span>
        </a>
      </Popover>
      <ProjectDialog
        open={editOpen}
        onClose={() => setEditOpen(false)}
@@ -1,334 +0,0 @@
 "use client";
 import { useEffect, useMemo, useState } from "react";
 import { useRouter } from "next/navigation";
 import { Loader2, RefreshCw, Search } from "lucide-react";
 import { Modal } from "@/components/ui/Modal";
 import type { ConnectionSafe, RepoListEntry, RepositoryWithSnapshot } from "@/types";
 /**
 * Ein weiteres Repository mit einem Projekt verknuepfen – oder ein
 * vorhandenes umbenennen und umhaengen.
 *
 * Beim Anlegen des Projekts genuegt der Projektdialog: dort setzen die
 * Git-Felder das erste Repository. Alles darueber hinaus laeuft hier.
 */
 interface FormState {
  label: string;
  connectionId: string;
  repoUrl: string;
  repoOwner: string;
  repoName: string;
  autoSync: boolean;
 }
 const EMPTY: FormState = {
  label: "",
  connectionId: "",
  repoUrl: "",
  repoOwner: "",
  repoName: "",
  autoSync: true,
 };
 export function RepositoryDialog({
  open,
  onClose,
  projectId,
  connections,
  repository,
 }: {
  open: boolean;
  onClose: () => void;
  projectId: string;
  connections: ConnectionSafe[];
  /** Vorhandenes = Bearbeiten, sonst Verknuepfen. */
  repository?: RepositoryWithSnapshot | null;
 }) {
  const router = useRouter();
  const [form, setForm] = useState<FormState>(EMPTY);
  const [saving, setSaving] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [repos, setRepos] = useState<RepoListEntry[]>([]);
  const [pickerOpen, setPickerOpen] = useState(false);
  const [loading, setLoading] = useState(false);
  const [filter, setFilter] = useState("");
  const isEdit = Boolean(repository);
  useEffect(() => {
    if (!open) return;
    setError(null);
    setPickerOpen(false);
    setRepos([]);
    setFilter("");
    setForm(
      repository
        ? {
            label: repository.label ?? "",
            connectionId: repository.connectionId ?? "",
            repoUrl: repository.repoUrl ?? "",
            repoOwner: repository.repoOwner ?? "",
            repoName: repository.repoName ?? "",
            autoSync: repository.autoSync,
          }
        : EMPTY,
    );
  }, [open, repository]);
  const gefiltert = useMemo(() => {
    const needle = filter.toLowerCase().trim();
    if (!needle) return repos.slice(0, 60);
    return repos.filter((repo) => repo.fullPath.toLowerCase().includes(needle)).slice(0, 60);
  }, [repos, filter]);
  function update<K extends keyof FormState>(key: K, value: FormState[K]) {
    setForm((previous) => ({ ...previous, [key]: value }));
  }
  async function loadRepos() {
    if (!form.connectionId) {
      setError("Bitte zuerst eine Git-Verbindung auswaehlen.");
      return;
    }
    setLoading(true);
    setError(null);
    try {
      const response = await fetch(`/api/connections/${form.connectionId}/repos`);
      const payload = await response.json();
      if (!response.ok) throw new Error(payload.error ?? "Repos konnten nicht geladen werden.");
      setRepos(payload.repos ?? []);
      setPickerOpen(true);
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setLoading(false);
    }
  }
  function pick(repo: RepoListEntry) {
    setForm((previous) => ({
      ...previous,
      repoUrl: repo.htmlUrl,
      repoOwner: repo.owner,
      repoName: repo.name,
    }));
    setPickerOpen(false);
  }
  async function submit(event: React.FormEvent) {
    event.preventDefault();
    setSaving(true);
    setError(null);
    try {
      const response = await fetch(
        isEdit ? `/api/repositories/${repository?.id}` : `/api/projects/${projectId}/repositories`,
        {
          method: isEdit ? "PATCH" : "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify({
            label: form.label,
            connectionId: form.connectionId || null,
            repoUrl: form.repoUrl,
            repoOwner: form.repoOwner,
            repoName: form.repoName,
            autoSync: form.autoSync,
          }),
        },
      );
      const payload = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(payload.error ?? "Speichern fehlgeschlagen.");
      onClose();
      router.refresh();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setSaving(false);
    }
  }
  return (
    <Modal
      open={open}
      onClose={onClose}
      width="lg"
      title={isEdit ? "Repository bearbeiten" : "Repository verknuepfen"}
      description={
        isEdit
          ? "Zeigt das Repository woandershin, wird der geholte Stand verworfen."
          : "Ein Projekt darf mehrere Repositories haben – etwa Frontend und Backend."
      }
    >
      <form onSubmit={submit} className="space-y-5">
        <div className="grid gap-4 sm:grid-cols-2">
          <div className="sm:col-span-2">
            <label className="field-label" htmlFor="repo-label">
              Bezeichnung (optional)
            </label>
            <input
              id="repo-label"
              className="field"
              value={form.label}
              onChange={(event) => update("label", event.target.value)}
              placeholder="Frontend"
              maxLength={80}
            />
            <p className="mt-1 text-xs text-slate-500">
              Ohne Angabe steht schlicht owner/name da.
            </p>
          </div>
          <div>
            <label className="field-label" htmlFor="repo-connection">
              Verbindung
            </label>
            <select
              id="repo-connection"
              className="field"
              value={form.connectionId}
              onChange={(event) => update("connectionId", event.target.value)}
            >
              <option value="">– keine –</option>
              {connections.map((connection) => (
                <option key={connection.id} value={connection.id}>
                  {connection.name} ({connection.provider})
                </option>
              ))}
            </select>
          </div>
          <div className="flex items-end">
            <button
              type="button"
              className="btn btn-ghost w-full"
              onClick={loadRepos}
              disabled={loading || !form.connectionId}
            >
              {loading ? (
                <Loader2 className="h-3.5 w-3.5 animate-spin" />
              ) : (
                <RefreshCw className="h-3.5 w-3.5" />
              )}
              Repos laden
            </button>
          </div>
          <div className="sm:col-span-2">
            <label className="field-label" htmlFor="repo-url">
              Repository-URL
            </label>
            <input
              id="repo-url"
              className="field"
              value={form.repoUrl}
              onChange={(event) => update("repoUrl", event.target.value)}
              placeholder="https://github.com/user/repo"
            />
          </div>
          <div>
            <label className="field-label" htmlFor="repo-owner">
              Owner / Gruppe
            </label>
            <input
              id="repo-owner"
              className="field font-mono text-xs"
              value={form.repoOwner}
              onChange={(event) => update("repoOwner", event.target.value)}
              placeholder="wird aus der URL abgeleitet"
            />
          </div>
          <div>
            <label className="field-label" htmlFor="repo-name">
              Repository
            </label>
            <input
              id="repo-name"
              className="field font-mono text-xs"
              value={form.repoName}
              onChange={(event) => update("repoName", event.target.value)}
              placeholder="wird aus der URL abgeleitet"
            />
          </div>
        </div>
        <label className="flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
          <input
            type="checkbox"
            checked={form.autoSync}
            onChange={(event) => update("autoSync", event.target.checked)}
            className="mt-0.5 h-4 w-4 accent-violet-500"
          />
          <span>
            Am automatischen Abgleich teilnehmen
            <span className="mt-0.5 block text-[11px] text-slate-600">
              Wirkt nur, wenn der Abgleich im Adminbereich eingeschaltet ist. Manuell
              synchronisieren geht unabhaengig davon immer.
            </span>
          </span>
        </label>
        {pickerOpen ? (
          <div className="rounded-xl border border-white/8 bg-[#080a18]/70">
            <div className="flex items-center gap-2 border-b border-white/6 px-3 py-2">
              <Search className="h-3.5 w-3.5 text-slate-500" />
              <input
                className="w-full bg-transparent text-sm text-slate-200 outline-none placeholder:text-slate-600"
                placeholder={`${repos.length} Repositories durchsuchen…`}
                value={filter}
                onChange={(event) => setFilter(event.target.value)}
              />
            </div>
            <ul className="max-h-56 overflow-y-auto p-1">
              {gefiltert.map((repo) => (
                <li key={repo.fullPath}>
                  <button
                    type="button"
                    onClick={() => pick(repo)}
                    className="flex w-full items-center justify-between gap-3 rounded-lg px-2.5 py-2 text-left hover:bg-white/6"
                  >
                    <span className="min-w-0">
                      <span className="block truncate font-mono text-xs text-slate-200">
                        {repo.fullPath}
                      </span>
                      {repo.description ? (
                        <span className="block truncate text-[11px] text-slate-500">
                          {repo.description}
                        </span>
                      ) : null}
                    </span>
                    <span className="shrink-0 text-[10px] uppercase text-slate-600">
                      {repo.visibility}
                    </span>
                  </button>
                </li>
              ))}
              {gefiltert.length === 0 ? (
                <li className="px-3 py-4 text-center text-xs text-slate-500">Keine Treffer.</li>
              ) : null}
            </ul>
          </div>
        ) : null}
        {error ? (
          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
            {error}
          </p>
        ) : null}
        <div className="flex justify-end gap-3 pt-1">
          <button type="button" className="btn btn-ghost" onClick={onClose}>
            Abbrechen
          </button>
          <button type="submit" className="btn btn-primary" disabled={saving}>
            {saving ? <Loader2 className="h-4 w-4 animate-spin" /> : null}
            {isEdit ? "Speichern" : "Verknuepfen"}
          </button>
        </div>
      </form>
    </Modal>
  );
 }
@@ -1,57 +0,0 @@
 import { cn } from "@/lib/utils";
 /**
 * Commit-Aktivitaet als kleine Balkenreihe.
 *
 * Bewusst als reines SVG ohne Diagrammbibliothek: es sind dreissig Werte,
 * die Achsen, Legende und Tooltips einer Bibliothek waeren hier nur Ballast.
 */
 export function Sparkline({
  values,
  className,
  height = 28,
  label = "Commits",
 }: {
  values: number[];
  className?: string;
  height?: number;
  label?: string;
 }) {
  if (!values.length) return null;
  const total = values.reduce((sum, value) => sum + value, 0);
  if (total === 0) return null;
  const max = Math.max(...values);
  const gap = 1;
  const barWidth = 3;
  const width = values.length * (barWidth + gap) - gap;
  return (
    <svg
      viewBox={`0 0 ${width} ${height}`}
      preserveAspectRatio="none"
      className={cn("w-full", className)}
      style={{ height }}
      role="img"
      aria-label={`${label} der letzten ${values.length} Tage: insgesamt ${total}`}
    >
      <title>{`${label} der letzten ${values.length} Tage: insgesamt ${total}`}</title>
      {values.map((value, index) => {
        // Auch ein einzelner Commit soll sichtbar sein, daher die Untergrenze.
        const barHeight = value === 0 ? 1.5 : Math.max(3, (value / max) * height);
        return (
          <rect
            key={index}
            x={index * (barWidth + gap)}
            y={height - barHeight}
            width={barWidth}
            height={barHeight}
            rx={1}
            className={value === 0 ? "fill-white/10" : "fill-violet-400/80"}
          />
        );
      })}
    </svg>
  );
 }
@@ -1,10 +1,9 @@
 "use client";
-import { useRef, useState, useTransition } from "react";
+import { useState, useTransition } from "react";
 import { useRouter } from "next/navigation";
 import { Check, ChevronDown, Loader2 } from "lucide-react";
 import type { ProjectStatus } from "@prisma/client";
 import { Popover } from "@/components/ui/Popover";
 import { STATUS_META, STATUS_ORDER, statusOf } from "@/lib/status";
 import { cn } from "@/lib/utils";
@@ -23,7 +22,6 @@ export function StatusSelect({
  onChanged,
 }: StatusSelectProps) {
  const router = useRouter();
  const triggerRef = useRef<HTMLButtonElement>(null);
  const [open, setOpen] = useState(false);
  const [current, setCurrent] = useState<ProjectStatus>(status);
  const [pending, startTransition] = useTransition();
@@ -56,12 +54,10 @@ export function StatusSelect({
  }
  return (
-    <>
+    <div className="relative">
      <button
        ref={triggerRef}
        type="button"
        onClick={(event) => {
          // Die Karte im Board ist ein Link – der darf hier nicht ausloesen.
          event.preventDefault();
          event.stopPropagation();
          setOpen((value) => !value);
@@ -86,49 +82,60 @@ export function StatusSelect({
        <ChevronDown className="h-3 w-3 opacity-60" />
      </button>
-      <Popover
+      {open ? (
-        anchorRef={triggerRef}
+        <>
-        open={open}
+          <button
-        onClose={() => setOpen(false)}
+            type="button"
-        role="listbox"
+            aria-label="Auswahl schliessen"
-        width={264}
+            className="fixed inset-0 z-30 cursor-default"
-      >
+            onClick={(event) => {
-        {STATUS_ORDER.map((value) => {
+              event.preventDefault();
-          const option = STATUS_META[value];
+              event.stopPropagation();
-          const active = value === current;
+              setOpen(false);
-          return (
+            }}
-            <button
+          />
-              key={value}
+          <div
-              type="button"
+            role="listbox"
-              role="option"
+            className="glass fade-up absolute right-0 z-40 mt-2 w-60 overflow-hidden p-1.5"
-              aria-selected={active}
+          >
-              onClick={(event) => {
+            {STATUS_ORDER.map((value) => {
-                event.preventDefault();
+              const option = STATUS_META[value];
-                event.stopPropagation();
+              const active = value === current;
-                void select(value);
+              return (
-              }}
+                <button
-              className={cn(
+                  key={value}
-                "flex w-full items-start gap-2.5 rounded-lg px-2.5 py-2 text-left transition-colors",
+                  type="button"
-                active ? "bg-white/8" : "hover:bg-white/6",
+                  role="option"
-              )}
+                  aria-selected={active}
-            >
+                  onClick={(event) => {
-              <span
+                    event.preventDefault();
-                className="mt-1.5 h-2 w-2 shrink-0 rounded-full"
+                    event.stopPropagation();
-                style={{ backgroundColor: option.color }}
+                    void select(value);
-              />
+                  }}
-              <span className="min-w-0 flex-1">
+                  className={cn(
-                <span className="flex items-center gap-2 text-sm text-slate-100">
+                    "flex w-full items-start gap-2.5 rounded-lg px-2.5 py-2 text-left transition-colors",
-                  {option.label}
+                    active ? "bg-white/8" : "hover:bg-white/5",
-                  {active ? <Check className="h-3 w-3 text-violet-300" /> : null}
+                  )}
-                </span>
+                >
-                <span className="mt-0.5 block text-[11px] leading-snug text-slate-500">
+                  <span
-                  {option.description}
+                    className="mt-1.5 h-2 w-2 shrink-0 rounded-full"
-                </span>
+                    style={{ backgroundColor: option.color }}
-              </span>
+                  />
-            </button>
+                  <span className="min-w-0 flex-1">
-          );
+                    <span className="flex items-center gap-2 text-sm text-slate-100">
-        })}
+                      {option.label}
-      </Popover>
+                      {active ? <Check className="h-3 w-3 text-violet-300" /> : null}
-    </>
+                    </span>
                    <span className="mt-0.5 block text-[11px] leading-snug text-slate-500">
                      {option.description}
                    </span>
                  </span>
                </button>
              );
            })}
          </div>
        </>
      ) : null}
    </div>
  );
 }
@@ -1,6 +1,6 @@
 "use client";
-import { useRef, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import Link from "next/link";
 import { usePathname, useRouter } from "next/navigation";
 import {
@@ -12,7 +12,6 @@ import {
  Sparkles,
  UserRound,
 } from "lucide-react";
 import { Popover } from "@/components/ui/Popover";
 import type { SessionUser } from "@/lib/auth/session";
 import { cn } from "@/lib/utils";
@@ -86,7 +85,23 @@ function UserMenu({ user }: { user: SessionUser }) {
  const router = useRouter();
  const [open, setOpen] = useState(false);
  const [busy, setBusy] = useState(false);
-  const triggerRef = useRef<HTMLButtonElement>(null);
+  const containerRef = useRef<HTMLDivElement>(null);
  useEffect(() => {
    if (!open) return;
    function onPointerDown(event: MouseEvent) {
      if (!containerRef.current?.contains(event.target as Node)) setOpen(false);
    }
    function onKey(event: KeyboardEvent) {
      if (event.key === "Escape") setOpen(false);
    }
    document.addEventListener("mousedown", onPointerDown);
    document.addEventListener("keydown", onKey);
    return () => {
      document.removeEventListener("mousedown", onPointerDown);
      document.removeEventListener("keydown", onKey);
    };
  }, [open]);
  async function logout() {
    setBusy(true);
@@ -100,17 +115,13 @@ function UserMenu({ user }: { user: SessionUser }) {
  const initials = label.slice(0, 2).toUpperCase();
  return (
-    <>
+    <div className="relative" ref={containerRef}>
      <button
        ref={triggerRef}
        type="button"
        onClick={() => setOpen((value) => !value)}
        className="flex items-center gap-2 rounded-xl border border-white/10 bg-white/4 py-1.5 pl-1.5 pr-3 text-sm text-slate-200 transition-colors hover:bg-white/8"
        aria-haspopup="menu"
        aria-expanded={open}
        // Auf schmalen Anzeigen bleibt nur das Kuerzel sichtbar – ohne
        // Beschriftung liest ein Screenreader dann nur zwei Buchstaben vor.
        aria-label={`Benutzermenue fuer ${label}`}
      >
        <span className="grid h-7 w-7 place-items-center rounded-lg bg-gradient-to-br from-violet-500/80 to-cyan-400/70 text-[11px] font-semibold text-white">
          {initials}
@@ -121,48 +132,53 @@ function UserMenu({ user }: { user: SessionUser }) {
        ) : null}
      </button>
-      <Popover anchorRef={triggerRef} open={open} onClose={() => setOpen(false)} width={240}>
+      {open ? (
-        <div className="border-b border-white/6 px-3 py-2">
+        <div
-          <p className="truncate text-sm text-slate-100">{label}</p>
+          role="menu"
-          <p className="truncate text-[11px] text-slate-500">
+          className="glass fade-up absolute right-0 z-50 mt-2 w-60 overflow-hidden p-1.5"
            @{user.username}
            {user.role === "ADMIN" ? " · Administrator" : ""}
          </p>
        </div>
        <Link
          href="/account"
          role="menuitem"
          onClick={() => setOpen(false)}
          className="mt-1 flex items-center gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
        >
-          <UserRound className="h-4 w-4" />
+          <div className="border-b border-white/6 px-3 py-2">
-          Mein Konto
+            <p className="truncate text-sm text-slate-100">{label}</p>
-        </Link>
+            <p className="truncate text-[11px] text-slate-500">
              @{user.username}
              {user.role === "ADMIN" ? " · Administrator" : ""}
            </p>
          </div>
        {user.role === "ADMIN" ? (
          <Link
-            href="/admin"
+            href="/account"
            role="menuitem"
            onClick={() => setOpen(false)}
-            className="flex items-center gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
+            className="mt-1 flex items-center gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
          >
-            <Settings className="h-4 w-4" />
+            <UserRound className="h-4 w-4" />
-            Admin-Einstellungen
+            Mein Konto
          </Link>
        ) : null}
-        <button
+          {user.role === "ADMIN" ? (
-          type="button"
+            <Link
-          role="menuitem"
+              href="/admin"
-          onClick={logout}
+              role="menuitem"
-          disabled={busy}
+              onClick={() => setOpen(false)}
-          className="flex w-full items-center gap-2.5 rounded-lg px-3 py-2 text-left text-sm text-rose-200 transition-colors hover:bg-rose-500/10 disabled:opacity-50"
+              className="flex items-center gap-2.5 rounded-lg px-3 py-2 text-sm text-slate-300 transition-colors hover:bg-white/6 hover:text-white"
-        >
+            >
-          <LogOut className="h-4 w-4" />
+              <Settings className="h-4 w-4" />
-          Abmelden
+              Admin-Einstellungen
-        </button>
+            </Link>
-      </Popover>
+          ) : null}
-    </>
+
          <button
            type="button"
            role="menuitem"
            onClick={logout}
            disabled={busy}
            className="flex w-full items-center gap-2.5 rounded-lg px-3 py-2 text-left text-sm text-rose-200 transition-colors hover:bg-rose-500/10 disabled:opacity-50"
          >
            <LogOut className="h-4 w-4" />
            Abmelden
          </button>
        </div>
      ) : null}
    </div>
  );
 }
@@ -14,7 +14,6 @@ import {
  ShieldCheck,
  Trash2,
 } from "lucide-react";
 import { TotpSection, type TotpState } from "@/components/account/TotpSection";
 import { PASSWORD_MIN_LENGTH } from "@/lib/auth/constants";
 import { cn, formatDateTime, formatRelative } from "@/lib/utils";
@@ -44,7 +43,6 @@ export interface AccountData {
  passkeys: PasskeyEntry[];
  sessions: SessionEntry[];
  passkeysAvailable: boolean;
  totp: TotpState;
 }
 type Notice = { ok: boolean; text: string } | null;
@@ -54,7 +52,6 @@ export function AccountManager({ data }: { data: AccountData }) {
    <div className="space-y-6">
      <ProfileSection data={data} />
      <PasswordSection hasPassword={data.hasPassword} />
      <TotpSection state={data.totp} hasPassword={data.hasPassword} />
      <PasskeySection passkeys={data.passkeys} available={data.passkeysAvailable} />
      <SessionSection sessions={data.sessions} />
    </div>
@@ -1,515 +0,0 @@
 "use client";
 import { useEffect, useState } from "react";
 import { useRouter } from "next/navigation";
 import {
  Bell,
  BellRing,
  CheckCircle2,
  KeyRound,
  Loader2,
  Mail,
  Pencil,
  Plus,
  Trash2,
  Webhook,
  XCircle,
 } from "lucide-react";
 import type { NotificationChannel, NotificationEvent } from "@prisma/client";
 import { Modal } from "@/components/ui/Modal";
 import { EVENT_META, NOTIFICATION_EVENTS } from "@/lib/notify/types";
 import { cn, formatRelative } from "@/lib/utils";
 export interface NotificationTargetEntry {
  id: string;
  name: string;
  channel: NotificationChannel;
  target: string;
  secretHint: string | null;
  events: NotificationEvent[];
  isActive: boolean;
  lastSentAt: string | Date | null;
  lastOk: boolean | null;
  lastMessage: string | null;
 }
 const CHANNEL_META: Record<
  NotificationChannel,
  { label: string; icon: typeof Webhook; hint: string; placeholder: string }
 > = {
  NTFY: {
    label: "ntfy",
    icon: BellRing,
    hint: "Vollstaendige Themen-URL, z. B. https://ntfy.sh/mein-geheimes-thema",
    placeholder: "https://ntfy.sh/mein-thema",
  },
  WEBHOOK: {
    label: "Webhook",
    icon: Webhook,
    hint: "Bekommt JSON per POST. Mit Geheimnis wird der Rumpf signiert (X-Nebula-Signature).",
    placeholder: "https://mein-dienst.de/haken",
  },
  EMAIL: {
    label: "E-Mail",
    icon: Mail,
    hint: "Braucht SMTP-Zugangsdaten in der .env der Instanz.",
    placeholder: "ich@example.com",
  },
 };
 export function NotificationSection({
  targets,
  emailAvailable,
 }: {
  targets: NotificationTargetEntry[];
  emailAvailable: boolean;
 }) {
  const router = useRouter();
  const [dialogOpen, setDialogOpen] = useState(false);
  const [editing, setEditing] = useState<NotificationTargetEntry | null>(null);
  const [busyId, setBusyId] = useState<string | null>(null);
  const [notice, setNotice] = useState<{ ok: boolean; text: string } | null>(null);
  async function test(entry: NotificationTargetEntry) {
    setBusyId(entry.id);
    setNotice(null);
    try {
      const response = await fetch(`/api/notifications/${entry.id}/test`, { method: "POST" });
      const body = await response.json().catch(() => ({}));
      setNotice({ ok: response.ok, text: body.message ?? body.error ?? "Unbekannte Antwort." });
      router.refresh();
    } finally {
      setBusyId(null);
    }
  }
  async function remove(entry: NotificationTargetEntry) {
    if (!window.confirm(`Ziel „${entry.name}“ entfernen?`)) return;
    setBusyId(entry.id);
    await fetch(`/api/notifications/${entry.id}`, { method: "DELETE" }).catch(() => undefined);
    setBusyId(null);
    router.refresh();
  }
  async function toggle(entry: NotificationTargetEntry) {
    setBusyId(entry.id);
    await fetch(`/api/notifications/${entry.id}`, {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ isActive: !entry.isActive }),
    }).catch(() => undefined);
    setBusyId(null);
    router.refresh();
  }
  return (
    <section className="glass p-5">
      <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
        <div className="flex items-start gap-3">
          <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-violet-500/12 text-violet-300">
            <Bell className="h-4 w-4" />
          </span>
          <div>
            <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
              Benachrichtigungen
            </h2>
            <p className="mt-1 max-w-xl text-sm text-slate-400">
              Meldung bei fehlgeschlagenem Abgleich, roter CI oder neuem Release. Gemeldet
              wird nur bei einer <strong className="text-slate-300">Aenderung</strong> –
              nicht bei jedem Durchlauf.
            </p>
          </div>
        </div>
        <button
          type="button"
          className="btn btn-ghost px-3 py-1.5 text-xs"
          onClick={() => {
            setEditing(null);
            setDialogOpen(true);
          }}
        >
          <Plus className="h-3.5 w-3.5" />
          Ziel hinzufuegen
        </button>
      </div>
      {targets.length === 0 ? (
        <p className="rounded-xl border border-dashed border-white/8 px-4 py-6 text-center text-sm text-slate-500">
          Noch kein Ziel eingerichtet.
        </p>
      ) : (
        <div className="space-y-2">
          {targets.map((entry) => {
            const meta = CHANNEL_META[entry.channel];
            const Icon = meta.icon;
            return (
              <div key={entry.id} className="glass-soft px-3 py-3">
                <div className="flex flex-wrap items-start justify-between gap-3">
                  <div className="min-w-0 flex-1">
                    <p className="flex flex-wrap items-center gap-2 text-sm text-slate-100">
                      <Icon className="h-3.5 w-3.5 shrink-0 text-violet-300" />
                      {entry.name}
                      <span className="rounded bg-white/6 px-1.5 py-0.5 text-[10px] uppercase tracking-wider text-slate-400">
                        {meta.label}
                      </span>
                      {!entry.isActive ? (
                        <span className="rounded bg-slate-500/15 px-1.5 py-0.5 text-[10px] text-slate-400">
                          pausiert
                        </span>
                      ) : null}
                      {entry.secretHint ? (
                        <span className="inline-flex items-center gap-1 font-mono text-[10px] text-amber-300/70">
                          <KeyRound className="h-2.5 w-2.5" />
                          {entry.secretHint}
                        </span>
                      ) : null}
                    </p>
                    <p className="mt-0.5 truncate font-mono text-[11px] text-slate-500">
                      {entry.target}
                    </p>
                    <p className="mt-1.5 flex flex-wrap gap-1">
                      {entry.events.map((event) => (
                        <span
                          key={event}
                          className="rounded bg-white/6 px-1.5 py-0.5 text-[10px] text-slate-400"
                        >
                          {EVENT_META[event].emoji} {EVENT_META[event].label}
                        </span>
                      ))}
                    </p>
                    {entry.lastSentAt ? (
                      <p
                        className={cn(
                          "mt-1.5 flex items-center gap-1.5 text-[11px]",
                          entry.lastOk ? "text-emerald-200/80" : "text-rose-200/80",
                        )}
                        suppressHydrationWarning
                      >
                        {entry.lastOk ? (
                          <CheckCircle2 className="h-3 w-3" />
                        ) : (
                          <XCircle className="h-3 w-3" />
                        )}
                        {formatRelative(entry.lastSentAt)} · {entry.lastMessage}
                      </p>
                    ) : null}
                  </div>
                  <div className="flex shrink-0 items-center gap-1">
                    {busyId === entry.id ? (
                      <Loader2 className="h-4 w-4 animate-spin text-slate-500" />
                    ) : (
                      <>
                        <button
                          type="button"
                          className="btn btn-ghost px-2.5 py-1.5 text-xs"
                          onClick={() => test(entry)}
                        >
                          Testen
                        </button>
                        <button
                          type="button"
                          className="btn btn-ghost px-2.5 py-1.5 text-xs"
                          onClick={() => toggle(entry)}
                          title={entry.isActive ? "Pausieren" : "Fortsetzen"}
                        >
                          {entry.isActive ? "Pause" : "An"}
                        </button>
                        <button
                          type="button"
                          className="rounded-lg p-1.5 text-slate-500 transition-colors hover:bg-white/8 hover:text-violet-300"
                          onClick={() => {
                            setEditing(entry);
                            setDialogOpen(true);
                          }}
                          aria-label="Bearbeiten"
                        >
                          <Pencil className="h-3.5 w-3.5" />
                        </button>
                        <button
                          type="button"
                          className="rounded-lg p-1.5 text-slate-500 transition-colors hover:bg-rose-500/12 hover:text-rose-300"
                          onClick={() => remove(entry)}
                          aria-label="Entfernen"
                        >
                          <Trash2 className="h-3.5 w-3.5" />
                        </button>
                      </>
                    )}
                  </div>
                </div>
              </div>
            );
          })}
        </div>
      )}
      {notice ? (
        <p
          className={cn(
            "mt-3 rounded-lg border px-3 py-2 text-sm",
            notice.ok
              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
          )}
        >
          {notice.text}
        </p>
      ) : null}
      {!emailAvailable ? (
        <p className="mt-3 text-[11px] text-slate-600">
          E-Mail steht nicht bereit: In der <code className="text-violet-300">.env</code> der
          Instanz fehlt <code className="text-violet-300">SMTP_HOST</code>. ntfy und Webhook
          funktionieren ohne weitere Einrichtung.
        </p>
      ) : null}
      <TargetDialog
        open={dialogOpen}
        entry={editing}
        emailAvailable={emailAvailable}
        onClose={() => {
          setDialogOpen(false);
          setEditing(null);
        }}
      />
    </section>
  );
 }
 function TargetDialog({
  open,
  entry,
  emailAvailable,
  onClose,
 }: {
  open: boolean;
  entry: NotificationTargetEntry | null;
  emailAvailable: boolean;
  onClose: () => void;
 }) {
  const router = useRouter();
  const [name, setName] = useState("");
  const [channel, setChannel] = useState<NotificationChannel>("NTFY");
  const [target, setTarget] = useState("");
  const [secret, setSecret] = useState("");
  const [events, setEvents] = useState<NotificationEvent[]>(["SYNC_FAILED", "CI_FAILED"]);
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [fieldErrors, setFieldErrors] = useState<Record<string, string>>({});
  const isEdit = Boolean(entry);
  useEffect(() => {
    if (!open) return;
    setName(entry?.name ?? "");
    setChannel(entry?.channel ?? "NTFY");
    setTarget(entry?.target ?? "");
    setSecret("");
    setEvents(entry?.events ?? ["SYNC_FAILED", "CI_FAILED"]);
    setError(null);
    setFieldErrors({});
  }, [open, entry]);
  async function submit(event: React.FormEvent) {
    event.preventDefault();
    setBusy(true);
    setError(null);
    setFieldErrors({});
    const body: Record<string, unknown> = { name, target, events };
    if (!isEdit) body.channel = channel;
    if (!isEdit || secret.trim()) body.secret = secret;
    try {
      const response = await fetch(
        isEdit ? `/api/notifications/${entry?.id}` : "/api/notifications",
        {
          method: isEdit ? "PATCH" : "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify(body),
        },
      );
      const payload = await response.json().catch(() => ({}));
      if (!response.ok) {
        setFieldErrors(payload.fields ?? {});
        throw new Error(payload.error ?? "Speichern fehlgeschlagen.");
      }
      onClose();
      router.refresh();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setBusy(false);
    }
  }
  const meta = CHANNEL_META[channel];
  return (
    <Modal
      open={open}
      onClose={onClose}
      width="md"
      title={isEdit ? "Ziel bearbeiten" : "Neues Benachrichtigungsziel"}
      description={
        isEdit ? "Der Zustellweg selbst laesst sich nicht mehr aendern." : undefined
      }
    >
      <form onSubmit={submit} className="space-y-4">
        {!isEdit ? (
          <div>
            <span className="field-label">Weg</span>
            <div className="grid grid-cols-3 gap-2">
              {(Object.keys(CHANNEL_META) as NotificationChannel[]).map((value) => {
                const option = CHANNEL_META[value];
                const Icon = option.icon;
                const disabled = value === "EMAIL" && !emailAvailable;
                return (
                  <button
                    key={value}
                    type="button"
                    disabled={disabled}
                    onClick={() => setChannel(value)}
                    title={disabled ? "Kein SMTP in der .env hinterlegt" : undefined}
                    className={cn(
                      "rounded-xl border px-3 py-2.5 text-sm transition-all disabled:opacity-40",
                      channel === value
                        ? "border-violet-400/60 bg-violet-500/12 text-white"
                        : "border-white/9 text-slate-400 hover:border-white/20",
                    )}
                  >
                    <span className="flex items-center justify-center gap-1.5">
                      <Icon className="h-3.5 w-3.5" />
                      {option.label}
                    </span>
                  </button>
                );
              })}
            </div>
          </div>
        ) : null}
        <div>
          <label className="field-label" htmlFor="notify-name">
            Name *
          </label>
          <input
            id="notify-name"
            className="field"
            value={name}
            onChange={(e) => setName(e.target.value)}
            placeholder="Handy"
            required
            maxLength={60}
          />
          {fieldErrors.name ? (
            <p className="mt-1 text-xs text-rose-300">{fieldErrors.name}</p>
          ) : null}
        </div>
        <div>
          <label className="field-label" htmlFor="notify-target">
            {channel === "EMAIL" ? "E-Mail-Adresse *" : "URL *"}
          </label>
          <input
            id="notify-target"
            className="field font-mono text-xs"
            value={target}
            onChange={(e) => setTarget(e.target.value)}
            placeholder={meta.placeholder}
            required
          />
          <p className="mt-1 text-[11px] text-slate-500">{meta.hint}</p>
          {fieldErrors.target ? (
            <p className="mt-1 text-xs text-rose-300">{fieldErrors.target}</p>
          ) : null}
        </div>
        {channel !== "EMAIL" ? (
          <div>
            <label className="field-label" htmlFor="notify-secret">
              Geheimnis {isEdit ? "(leer = unveraendert)" : "(optional)"}
            </label>
            <input
              id="notify-secret"
              className="field font-mono text-xs"
              type="password"
              value={secret}
              onChange={(e) => setSecret(e.target.value)}
              autoComplete="off"
              placeholder={isEdit ? "••••••••" : ""}
            />
            <p className="mt-1 text-[11px] text-slate-500">
              {channel === "NTFY"
                ? "Wird als Bearer-Token gesendet – fuer geschuetzte Themen."
                : "Signiert den Rumpf per HMAC-SHA256 im Kopf X-Nebula-Signature."}
            </p>
          </div>
        ) : null}
        <div>
          <span className="field-label">Anlaesse *</span>
          <div className="space-y-1.5">
            {NOTIFICATION_EVENTS.map((event) => {
              const option = EVENT_META[event];
              const checked = events.includes(event);
              return (
                <label
                  key={event}
                  className="flex cursor-pointer items-start gap-2.5 rounded-lg border border-white/8 bg-black/20 px-3 py-2"
                >
                  <input
                    type="checkbox"
                    checked={checked}
                    onChange={(e) =>
                      setEvents((current) =>
                        e.target.checked
                          ? [...current, event]
                          : current.filter((value) => value !== event),
                      )
                    }
                    className="mt-0.5 h-4 w-4 accent-violet-500"
                  />
                  <span>
                    <span className="block text-sm text-slate-200">
                      {option.emoji} {option.label}
                    </span>
                    <span className="mt-0.5 block text-[11px] text-slate-500">
                      {option.description}
                    </span>
                  </span>
                </label>
              );
            })}
          </div>
          {fieldErrors.events ? (
            <p className="mt-1 text-xs text-rose-300">{fieldErrors.events}</p>
          ) : null}
        </div>
        {error ? (
          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
            {error}
          </p>
        ) : null}
        <div className="flex justify-end gap-2 pt-1">
          <button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
            Abbrechen
          </button>
          <button
            type="submit"
            className="btn btn-primary"
            disabled={busy || events.length === 0}
          >
            {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : null}
            Speichern
          </button>
        </div>
      </form>
    </Modal>
  );
 }
@@ -1,375 +0,0 @@
 "use client";
 import { useState } from "react";
 import { useRouter } from "next/navigation";
 import {
  Check,
  Copy,
  Download,
  Loader2,
  RefreshCw,
  ShieldCheck,
  ShieldOff,
  Smartphone,
 } from "lucide-react";
 import { cn, formatDateTime } from "@/lib/utils";
 /**
 * Zwei-Faktor-Anmeldung per Einmalkennwort.
 *
 * Die Einrichtung ist bewusst zweistufig: erst der QR-Code, dann ein Code zur
 * Bestaetigung. Scharf wird der Schluessel erst danach – sonst waere jemand,
 * der den QR-Code nicht scannen konnte, beim naechsten Anmelden ausgesperrt.
 */
 export interface TotpState {
  enabled: boolean;
  enabledAt: string | Date | null;
  recoveryCodesLeft: number;
 }
 type Notice = { ok: boolean; text: string } | null;
 export function TotpSection({
  state,
  hasPassword,
 }: {
  state: TotpState;
  hasPassword: boolean;
 }) {
  const router = useRouter();
  const [busy, setBusy] = useState(false);
  const [notice, setNotice] = useState<Notice>(null);
  // Einrichtung
  const [setup, setSetup] = useState<{ qr: string; secret: string } | null>(null);
  const [code, setCode] = useState("");
  // Wird genau einmal angezeigt, direkt nach dem Erzeugen.
  const [codes, setCodes] = useState<string[] | null>(null);
  // Abschalten und Neuerzeugen verlangen beides das Passwort.
  const [password, setPassword] = useState("");
  const [confirming, setConfirming] = useState<"disable" | "recovery" | null>(null);
  async function call(url: string, method: string, body?: unknown) {
    const response = await fetch(url, {
      method,
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(body ?? {}),
    });
    const payload = await response.json().catch(() => ({}));
    if (!response.ok) throw new Error(payload.error ?? "Das hat nicht geklappt.");
    return payload;
  }
  async function start() {
    setBusy(true);
    setNotice(null);
    try {
      const payload = await call("/api/account/totp", "POST");
      setSetup({ qr: payload.qr, secret: payload.secret });
    } catch (caught) {
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setBusy(false);
    }
  }
  async function confirm(event: React.FormEvent) {
    event.preventDefault();
    setBusy(true);
    setNotice(null);
    try {
      const payload = await call("/api/account/totp", "PUT", { code });
      setSetup(null);
      setCode("");
      setCodes(payload.recoveryCodes);
      router.refresh();
    } catch (caught) {
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setBusy(false);
    }
  }
  async function submitPassword(event: React.FormEvent) {
    event.preventDefault();
    setBusy(true);
    setNotice(null);
    try {
      if (confirming === "disable") {
        await call("/api/account/totp", "DELETE", { password });
        setNotice({ ok: true, text: "Die Zwei-Faktor-Anmeldung ist abgeschaltet." });
        setCodes(null);
      } else {
        const payload = await call("/api/account/totp/recovery", "POST", { password });
        setCodes(payload.recoveryCodes);
        setNotice({ ok: true, text: "Neue Codes erzeugt. Die alten gelten nicht mehr." });
      }
      setConfirming(null);
      setPassword("");
      router.refresh();
    } catch (caught) {
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setBusy(false);
    }
  }
  return (
    <section className="glass p-5">
      <div className="mb-4 flex items-start gap-3">
        <span
          className={cn(
            "grid h-9 w-9 shrink-0 place-items-center rounded-xl",
            state.enabled
              ? "bg-emerald-500/12 text-emerald-300"
              : "bg-violet-500/12 text-violet-300",
          )}
        >
          <ShieldCheck className="h-4 w-4" />
        </span>
        <div>
          <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
            Zwei-Faktor-Anmeldung
          </h2>
          <p className="mt-1 text-sm text-slate-400">
            {state.enabled
              ? `Aktiv seit ${formatDateTime(state.enabledAt)}. Nach dem Passwort fragt die Anmeldung nach einem Code.`
              : "Ein zeitbasiertes Einmalkennwort zusätzlich zum Passwort — aus einer Authenticator-App."}
          </p>
        </div>
      </div>
      {!hasPassword ? (
        <p className="rounded-lg border border-white/8 bg-black/25 px-3 py-2 text-sm text-slate-400">
          Dieses Konto hat kein Passwort und meldet sich per Passkey an. Ein zweiter Faktor
          käme dabei nie zum Einsatz — der Passkey ist bereits an dein Gerät gebunden.
        </p>
      ) : null}
      {/* Frisch erzeugte Wiederherstellungscodes, einmalige Anzeige. */}
      {codes ? <RecoveryCodes codes={codes} onDone={() => setCodes(null)} /> : null}
      {hasPassword && !state.enabled && !setup && !codes ? (
        <button type="button" onClick={start} disabled={busy} className="btn btn-primary">
          {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Smartphone className="h-4 w-4" />}
          Einrichten
        </button>
      ) : null}
      {/* Schritt 1: QR-Code scannen, Schritt 2: Code bestaetigen. */}
      {setup ? (
        <form onSubmit={confirm} className="space-y-4">
          <div className="flex flex-col gap-4 sm:flex-row sm:items-start">
            {/* eslint-disable-next-line @next/next/no-img-element -- data-URI, kein Netzabruf */}
            <img
              src={setup.qr}
              alt="QR-Code für die Authenticator-App"
              width={160}
              height={160}
              className="shrink-0 rounded-xl bg-white p-2"
            />
            <div className="min-w-0 space-y-2 text-sm text-slate-400">
              <p>
                Scanne den Code mit deiner Authenticator-App — etwa Aegis, 2FAS, Ente Auth
                oder dem Passwortmanager deiner Wahl.
              </p>
              <p>Geht die Kamera nicht, trage den Schlüssel von Hand ein:</p>
              <code className="block break-all rounded-lg border border-white/8 bg-black/30 px-3 py-2 font-mono text-xs text-violet-200">
                {setup.secret}
              </code>
            </div>
          </div>
          <div className="max-w-xs">
            <label className="field-label" htmlFor="totp-code">
              Code aus der App
            </label>
            <input
              id="totp-code"
              className="field text-center text-lg tracking-[0.35em]"
              value={code}
              onChange={(event) => setCode(event.target.value)}
              inputMode="numeric"
              autoComplete="one-time-code"
              maxLength={7}
              required
              autoFocus
            />
          </div>
          <div className="flex flex-wrap gap-2">
            <button type="submit" className="btn btn-primary" disabled={busy}>
              {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : <Check className="h-4 w-4" />}
              Aktivieren
            </button>
            <button
              type="button"
              className="btn btn-ghost"
              onClick={() => {
                setSetup(null);
                setCode("");
                setNotice(null);
              }}
            >
              Abbrechen
            </button>
          </div>
        </form>
      ) : null}
      {state.enabled && !setup ? (
        <div className="space-y-3">
          <p className="text-sm text-slate-400">
            {state.recoveryCodesLeft > 0 ? (
              <>
                Noch <strong className="text-slate-200">{state.recoveryCodesLeft}</strong>{" "}
                Wiederherstellungscodes übrig.
              </>
            ) : (
              <span className="text-amber-200">
                Keine Wiederherstellungscodes mehr übrig. Ohne sie hilft bei einem verlorenen
                Gerät nichts mehr — bitte neue erzeugen.
              </span>
            )}
          </p>
          {confirming ? (
            <form onSubmit={submitPassword} className="max-w-sm space-y-3">
              <div>
                <label className="field-label" htmlFor="totp-password">
                  Passwort bestätigen
                </label>
                <input
                  id="totp-password"
                  className="field"
                  type="password"
                  value={password}
                  onChange={(event) => setPassword(event.target.value)}
                  autoComplete="current-password"
                  required
                  autoFocus
                />
              </div>
              <div className="flex flex-wrap gap-2">
                <button
                  type="submit"
                  className={cn("btn", confirming === "disable" ? "btn-danger" : "btn-primary")}
                  disabled={busy}
                >
                  {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : null}
                  {confirming === "disable" ? "Abschalten" : "Neue Codes erzeugen"}
                </button>
                <button
                  type="button"
                  className="btn btn-ghost"
                  onClick={() => {
                    setConfirming(null);
                    setPassword("");
                  }}
                >
                  Abbrechen
                </button>
              </div>
            </form>
          ) : (
            <div className="flex flex-wrap gap-2">
              <button
                type="button"
                className="btn btn-ghost"
                onClick={() => setConfirming("recovery")}
              >
                <RefreshCw className="h-4 w-4" />
                Neue Wiederherstellungscodes
              </button>
              <button
                type="button"
                className="btn btn-ghost text-rose-200"
                onClick={() => setConfirming("disable")}
              >
                <ShieldOff className="h-4 w-4" />
                Abschalten
              </button>
            </div>
          )}
        </div>
      ) : null}
      {notice ? (
        <p
          className={cn(
            "mt-3 rounded-lg border px-3 py-2 text-sm",
            notice.ok
              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
          )}
        >
          {notice.text}
        </p>
      ) : null}
    </section>
  );
 }
 /**
 * Die Codes werden nur dieses eine Mal gezeigt. Deshalb Kopieren und
 * Herunterladen direkt daneben – und ein Knopf, der das Wegklicken zu einer
 * bewussten Handlung macht.
 */
 function RecoveryCodes({ codes, onDone }: { codes: string[]; onDone: () => void }) {
  const [copied, setCopied] = useState(false);
  const text = codes.join("\n");
  async function copy() {
    try {
      await navigator.clipboard.writeText(text);
      setCopied(true);
      setTimeout(() => setCopied(false), 2000);
    } catch {
      // Ohne Zwischenablage-Recht bleibt Markieren von Hand.
    }
  }
  function download() {
    const url = URL.createObjectURL(new Blob([`${text}\n`], { type: "text/plain" }));
    const link = document.createElement("a");
    link.href = url;
    link.download = "nebula-wiederherstellungscodes.txt";
    link.click();
    URL.revokeObjectURL(url);
  }
  return (
    <div className="mb-4 rounded-xl border border-amber-500/30 bg-amber-500/8 p-4">
      <h3 className="text-sm font-semibold text-amber-100">Wiederherstellungscodes</h3>
      <p className="mt-1 text-sm text-amber-200/80">
        Jeder Code gilt einmal. Bewahre sie an einem sicheren Ort auf — sie sind der einzige
        Weg zurück, wenn dein Gerät verloren geht. <strong>Sie werden nur jetzt angezeigt.</strong>
      </p>
      <ul className="mt-3 grid grid-cols-2 gap-1.5 font-mono text-sm text-amber-50 sm:grid-cols-2">
        {codes.map((entry) => (
          <li key={entry} className="rounded-md bg-black/25 px-2.5 py-1.5">
            {entry}
          </li>
        ))}
      </ul>
      <div className="mt-3 flex flex-wrap gap-2">
        <button type="button" onClick={copy} className="btn btn-ghost text-xs">
          {copied ? <Check className="h-3.5 w-3.5" /> : <Copy className="h-3.5 w-3.5" />}
          {copied ? "Kopiert" : "Kopieren"}
        </button>
        <button type="button" onClick={download} className="btn btn-ghost text-xs">
          <Download className="h-3.5 w-3.5" />
          Herunterladen
        </button>
        <button type="button" onClick={onDone} className="btn btn-ghost text-xs">
          Ich habe sie gesichert
        </button>
      </div>
    </div>
  );
 }
@@ -5,16 +5,11 @@ import { useRouter } from "next/navigation";
 import {
  Ban,
  CheckCircle2,
  Database,
  Download,
  Fingerprint,
  FolderGit2,
  Hourglass,
  Loader2,
  Lock,
  Plus,
  RefreshCw,
  ShieldAlert,
  ShieldCheck,
  Trash2,
  User,
@@ -41,16 +36,6 @@ export interface AdminUser {
  _count: { credentials: number; projects: number; sessions: number };
 }
 export interface AutoSyncReport {
  at: string;
  trigger: "zeitplan" | "manuell";
  candidates: number;
  synced: number;
  failed: number;
  skipped: number;
  durationMs: number;
 }
 export interface AdminData {
  mode: Mode;
  allowRegistration: boolean;
@@ -58,22 +43,6 @@ export interface AdminData {
  currentUserId: string;
  appUrl: string;
  passkeysAvailable: boolean;
  autoSync: {
    enabled: boolean;
    intervalMinutes: number;
    activeOnly: boolean;
    batchSize: number;
    lastRunAt: string | Date | null;
    lastReport: AutoSyncReport | null;
    /** Projekte mit Repository, die grundsaetzlich in Frage kommen. */
    eligible: number;
  };
  stale: {
    afterDays: number;
    lastCheckAt: string | Date | null;
    /** Wie viele Konten ueberhaupt auf Stillstand hoeren. */
    listeners: number;
  };
 }
 type Notice = { ok: boolean; text: string } | null;
@@ -193,9 +162,6 @@ export function AdminManager({ data }: { data: AdminData }) {
        ) : null}
      </section>
      <AutoSyncSection data={data.autoSync} />
      <StaleSection data={data.stale} />
      {/* ── Instanz ─────────────────────────────────────── */}
      <section className="glass p-5">
        <div className="mb-4 flex items-start gap-3">
@@ -237,40 +203,6 @@ export function AdminManager({ data }: { data: AdminData }) {
        </dl>
      </section>
      {/* ── Sicherung ───────────────────────────────────── */}
      <section className="glass p-5">
        <div className="mb-4 flex items-start gap-3">
          <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-amber-500/12 text-amber-300">
            <Database className="h-4 w-4" />
          </span>
          <div>
            <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
              Sicherung
            </h2>
            <p className="mt-1 max-w-2xl text-sm text-slate-400">
              Vollstaendige Sicherung der Instanz als JSON: Einstellungen, Konten,
              Verbindungen, Projekte und Notizen.
            </p>
          </div>
        </div>
        <a href="/api/admin/backup" download className="btn btn-ghost">
          <Download className="h-4 w-4" />
          Sicherung herunterladen
        </a>
        <p className="mt-3 flex items-start gap-2 rounded-lg border border-amber-500/25 bg-amber-500/8 px-3 py-2 text-[11px] leading-snug text-amber-200/90">
          <ShieldAlert className="mt-0.5 h-3.5 w-3.5 shrink-0" />
          <span>
            Die Datei enthaelt Passwort-Hashes und verschluesselte Git-Tokens. Die Tokens
            sind nur mit demselben <code>APP_SECRET</code> wieder lesbar, Passwoerter
            liegen als scrypt-Hash vor – trotzdem vertraulich behandeln. Fuer eine
            byteweise Sicherung der Datenbank gibt es <code>scripts/backup.ps1</code>{" "}
            beziehungsweise <code>scripts/backup.sh</code> mit <code>pg_dump</code>.
          </span>
        </p>
      </section>
      {/* ── Benutzer ────────────────────────────────────── */}
      <section className="glass p-5">
        <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
@@ -332,374 +264,6 @@ export function AdminManager({ data }: { data: AdminData }) {
  );
 }
 const INTERVALS = [
  { value: 15, label: "alle 15 Minuten" },
  { value: 30, label: "alle 30 Minuten" },
  { value: 60, label: "stuendlich" },
  { value: 180, label: "alle 3 Stunden" },
  { value: 360, label: "alle 6 Stunden" },
  { value: 720, label: "alle 12 Stunden" },
  { value: 1440, label: "taeglich" },
 ];
 function AutoSyncSection({ data }: { data: AdminData["autoSync"] }) {
  const router = useRouter();
  const [enabled, setEnabled] = useState(data.enabled);
  const [interval, setIntervalMinutes] = useState(data.intervalMinutes);
  const [activeOnly, setActiveOnly] = useState(data.activeOnly);
  const [batchSize, setBatchSize] = useState(data.batchSize);
  const [busy, setBusy] = useState(false);
  const [running, setRunning] = useState(false);
  const [notice, setNotice] = useState<Notice>(null);
  async function patch(payload: Record<string, unknown>) {
    setBusy(true);
    setNotice(null);
    try {
      const response = await fetch("/api/admin/settings", {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });
      const body = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(body.error ?? "Speichern fehlgeschlagen.");
      setNotice({ ok: true, text: "Gespeichert." });
      router.refresh();
    } catch (caught) {
      setEnabled(data.enabled);
      setIntervalMinutes(data.intervalMinutes);
      setActiveOnly(data.activeOnly);
      setBatchSize(data.batchSize);
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setBusy(false);
    }
  }
  async function runNow() {
    setRunning(true);
    setNotice(null);
    try {
      const response = await fetch("/api/admin/sync/run", { method: "POST" });
      const body = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(body.error ?? "Abgleich fehlgeschlagen.");
      const report = body.report as AutoSyncReport;
      setNotice({
        ok: true,
        text:
          `${report.synced} aktualisiert, ${report.failed} fehlgeschlagen, ` +
          `${report.skipped} zurueckgestellt (${Math.round(report.durationMs / 1000)} s).`,
      });
      router.refresh();
    } catch (caught) {
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setRunning(false);
    }
  }
  const nextRun =
    enabled && data.lastRunAt
      ? new Date(new Date(data.lastRunAt).getTime() + interval * 60_000)
      : null;
  return (
    <section className="glass p-5">
      <div className="mb-4 flex flex-wrap items-start justify-between gap-3">
        <div className="flex items-start gap-3">
          <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-cyan-500/12 text-cyan-300">
            <RefreshCw className="h-4 w-4" />
          </span>
          <div>
            <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
              Automatischer Abgleich
            </h2>
            <p className="mt-1 max-w-xl text-sm text-slate-400">
              Holt Branches, Tags, Commits und Releases im Hintergrund. Gilt fuer alle
              Konten – die Daten bleiben dabei getrennt, abgeglichen wird nur, was
              ohnehin verknuepft ist.
            </p>
          </div>
        </div>
        <button
          type="button"
          className="btn btn-ghost px-3 py-1.5 text-xs"
          onClick={runNow}
          disabled={running || data.eligible === 0}
          title={data.eligible === 0 ? "Kein Projekt mit Repository verknuepft" : undefined}
        >
          {running ? (
            <Loader2 className="h-3.5 w-3.5 animate-spin" />
          ) : (
            <RefreshCw className="h-3.5 w-3.5" />
          )}
          Jetzt abgleichen
        </button>
      </div>
      <label className="flex cursor-pointer items-start gap-3 rounded-xl border border-white/8 bg-black/20 px-3 py-3">
        <input
          type="checkbox"
          checked={enabled}
          disabled={busy}
          onChange={(event) => {
            setEnabled(event.target.checked);
            void patch({ autoSyncEnabled: event.target.checked });
          }}
          className="mt-0.5 h-4 w-4 accent-violet-500"
        />
        <span>
          <span className="block text-sm text-slate-200">Regelmaessig abgleichen</span>
          <span className="mt-0.5 block text-[11px] text-slate-500">
            Standardmaessig aus. Jeder Durchlauf verbraucht Kontingent bei GitHub,
            GitLab und Gitea – ohne Token ist das schnell erschoepft.
          </span>
        </span>
      </label>
      {enabled ? (
        <>
          <div className="mt-4 grid gap-4 sm:grid-cols-2">
            <div>
              <label className="field-label" htmlFor="autosync-interval">
                Abstand
              </label>
              <select
                id="autosync-interval"
                className="field"
                value={interval}
                disabled={busy}
                onChange={(event) => {
                  const value = Number(event.target.value);
                  setIntervalMinutes(value);
                  void patch({ autoSyncIntervalMinutes: value });
                }}
              >
                {INTERVALS.map((option) => (
                  <option key={option.value} value={option.value}>
                    {option.label}
                  </option>
                ))}
              </select>
            </div>
            <div>
              <label className="field-label" htmlFor="autosync-batch">
                Projekte je Durchlauf: {batchSize}
              </label>
              <input
                id="autosync-batch"
                type="range"
                min={1}
                max={100}
                step={1}
                value={batchSize}
                disabled={busy}
                onChange={(event) => setBatchSize(Number(event.target.value))}
                onMouseUp={() => patch({ autoSyncBatchSize: batchSize })}
                onTouchEnd={() => patch({ autoSyncBatchSize: batchSize })}
                onKeyUp={() => patch({ autoSyncBatchSize: batchSize })}
                className="range mt-2"
                style={{ "--fill": `${batchSize}%` } as React.CSSProperties}
              />
              <p className="mt-1.5 text-[11px] text-slate-500">
                Am laengsten nicht abgeglichene zuerst. Der Rest kommt beim naechsten Mal.
              </p>
            </div>
          </div>
          <label className="mt-3 flex cursor-pointer items-start gap-3 rounded-xl border border-white/8 bg-black/20 px-3 py-3">
            <input
              type="checkbox"
              checked={activeOnly}
              disabled={busy}
              onChange={(event) => {
                setActiveOnly(event.target.checked);
                void patch({ autoSyncActiveOnly: event.target.checked });
              }}
              className="mt-0.5 h-4 w-4 accent-violet-500"
            />
            <span>
              <span className="block text-sm text-slate-200">
                Fertige und archivierte Projekte auslassen
              </span>
              <span className="mt-0.5 block text-[11px] text-slate-500">
                Dort aendert sich selten noch etwas.
              </span>
            </span>
          </label>
        </>
      ) : null}
      {/* Zustand */}
      <dl className="mt-4 grid gap-3 sm:grid-cols-3">
        <div className="glass-soft px-3 py-2.5">
          <dt className="text-[11px] uppercase tracking-wider text-slate-500">
            Verknuepfte Projekte
          </dt>
          <dd className="mt-1 text-sm tabular-nums text-slate-200">{data.eligible}</dd>
        </div>
        <div className="glass-soft px-3 py-2.5">
          <dt className="text-[11px] uppercase tracking-wider text-slate-500">
            Letzter Durchlauf
          </dt>
          <dd className="mt-1 text-sm text-slate-200" suppressHydrationWarning>
            {data.lastRunAt ? formatRelative(data.lastRunAt) : "noch keiner"}
          </dd>
        </div>
        <div className="glass-soft px-3 py-2.5">
          <dt className="text-[11px] uppercase tracking-wider text-slate-500">
            Naechster Durchlauf
          </dt>
          <dd className="mt-1 text-sm text-slate-200" suppressHydrationWarning>
            {enabled ? (nextRun ? formatDateTime(nextRun) : "in Kuerze") : "abgeschaltet"}
          </dd>
        </div>
      </dl>
      {data.lastReport ? (
        <p className="mt-3 text-[11px] text-slate-500" suppressHydrationWarning>
          Zuletzt ({data.lastReport.trigger}): {data.lastReport.synced} aktualisiert,{" "}
          {data.lastReport.failed} fehlgeschlagen, {data.lastReport.skipped} zurueckgestellt
          in {Math.round(data.lastReport.durationMs / 1000)} s.
        </p>
      ) : null}
      {notice ? (
        <p
          className={cn(
            "mt-3 rounded-lg border px-3 py-2 text-sm",
            notice.ok
              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
          )}
        >
          {notice.text}
        </p>
      ) : null}
    </section>
  );
 }
 const STALE_OPTIONS = [14, 30, 60, 90, 180, 365];
 function StaleSection({ data }: { data: AdminData["stale"] }) {
  const router = useRouter();
  const [days, setDays] = useState(data.afterDays);
  const [busy, setBusy] = useState(false);
  const [notice, setNotice] = useState<Notice>(null);
  async function save(value: number) {
    setBusy(true);
    setNotice(null);
    try {
      const response = await fetch("/api/admin/settings", {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ staleAfterDays: value }),
      });
      const body = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(body.error ?? "Speichern fehlgeschlagen.");
      setNotice({ ok: true, text: "Gespeichert." });
      router.refresh();
    } catch (caught) {
      setDays(data.afterDays);
      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
    } finally {
      setBusy(false);
    }
  }
  return (
    <section className="glass p-5">
      <div className="mb-4 flex items-start gap-3">
        <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-amber-500/12 text-amber-300">
          <Hourglass className="h-4 w-4" />
        </span>
        <div>
          <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
            Stillstand
          </h2>
          <p className="mt-1 max-w-xl text-sm text-slate-400">
            Ab wann ein Projekt als eingeschlafen gilt. Massstab ist der letzte Commit im
            verknuepften Repository – das Aenderungsdatum taugt nicht, weil jeder Abgleich
            es anfasst. Projekte ohne Repository bleiben aussen vor, ebenso fertige und
            archivierte.
          </p>
        </div>
      </div>
      <div className="grid gap-4 sm:grid-cols-2">
        <div>
          <label className="field-label" htmlFor="stale-days">
            Schwelle
          </label>
          <select
            id="stale-days"
            className="field"
            value={days}
            disabled={busy}
            onChange={(event) => {
              const value = Number(event.target.value);
              setDays(value);
              void save(value);
            }}
          >
            {STALE_OPTIONS.map((value) => (
              <option key={value} value={value}>
                nach {value} Tagen ohne Commit
              </option>
            ))}
          </select>
        </div>
        <dl className="grid grid-cols-2 gap-3">
          <div className="glass-soft px-3 py-2.5">
            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
              Letzte Pruefung
            </dt>
            <dd className="mt-1 text-sm text-slate-200" suppressHydrationWarning>
              {data.lastCheckAt ? formatRelative(data.lastCheckAt) : "noch keine"}
            </dd>
          </div>
          <div className="glass-soft px-3 py-2.5">
            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
              Empfaenger
            </dt>
            <dd className="mt-1 text-sm tabular-nums text-slate-200">{data.listeners}</dd>
          </div>
        </dl>
      </div>
      {data.listeners === 0 ? (
        <p className="mt-3 text-[11px] text-slate-600">
          Niemand hoert derzeit auf diesen Anlass – die Pruefung laeuft dann gar nicht
          erst. Einzurichten unter „Mein Konto → Benachrichtigungen“.
        </p>
      ) : (
        <p className="mt-3 text-[11px] text-slate-600">
          Die Pruefung laeuft hoechstens einmal am Tag. Je Projekt wird einmal gemeldet;
          erneut erst, wenn danach wieder ein Commit kam und es wieder still wurde.
        </p>
      )}
      {notice ? (
        <p
          className={cn(
            "mt-3 rounded-lg border px-3 py-2 text-sm",
            notice.ok
              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
          )}
        >
          {notice.text}
        </p>
      ) : null}
    </section>
  );
 }
 function ModeCard({
  active,
  disabled,
@@ -4,7 +4,7 @@ import { useState } from "react";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import { startAuthentication } from "@simplewebauthn/browser";
-import { Fingerprint, KeyRound, Loader2, LogIn, ShieldCheck } from "lucide-react";
+import { Fingerprint, KeyRound, Loader2, LogIn } from "lucide-react";
 export function LoginForm({
  passkeysAvailable,
@@ -18,11 +18,8 @@ export function LoginForm({
  const router = useRouter();
  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
-  const [busy, setBusy] = useState<"password" | "passkey" | "code" | null>(null);
+  const [busy, setBusy] = useState<"password" | "passkey" | null>(null);
  const [error, setError] = useState<string | null>(null);
  /** Passwort stimmt, jetzt fehlt der zweite Faktor. */
  const [mfa, setMfa] = useState(false);
  const [code, setCode] = useState("");
  function done() {
    // replace statt push: die Anmeldeseite soll nicht im Verlauf landen.
@@ -42,14 +39,6 @@ export function LoginForm({
      });
      const payload = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(payload.error ?? "Anmeldung fehlgeschlagen.");
      // Zweiter Faktor eingerichtet: das Passwort allein reicht nicht.
      if (payload.mfaRequired) {
        setMfa(true);
        setPassword("");
        setBusy(null);
        return;
      }
      done();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
@@ -57,26 +46,6 @@ export function LoginForm({
    }
  }
  async function submitCode(event: React.FormEvent) {
    event.preventDefault();
    setBusy("code");
    setError(null);
    try {
      const response = await fetch("/api/auth/mfa", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ code }),
      });
      const payload = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(payload.error ?? "Der Code stimmt nicht.");
      done();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
      setCode("");
      setBusy(null);
    }
  }
  async function loginWithPasskey() {
    setBusy("passkey");
    setError(null);
@@ -113,70 +82,6 @@ export function LoginForm({
    }
  }
  // Beim zweiten Schritt bleibt nur noch der Code stehen. Benutzername und
  // Passwort daneben einzublenden wuerde nur zum erneuten Absenden verleiten.
  if (mfa) {
    return (
      <form onSubmit={submitCode} className="space-y-4">
        <div className="flex items-start gap-2 rounded-lg border border-white/8 bg-black/25 px-3 py-2 text-sm text-slate-400">
          <ShieldCheck className="mt-0.5 h-4 w-4 shrink-0 text-violet-300" />
          <span>
            Bitte den sechsstelligen Code aus deiner Authenticator-App eingeben. Kein
            Zugriff darauf? Ein Wiederherstellungscode geht auch.
          </span>
        </div>
        <div>
          <label className="field-label" htmlFor="login-code">
            Code
          </label>
          <input
            id="login-code"
            className="field text-center text-lg tracking-[0.35em]"
            value={code}
            onChange={(event) => setCode(event.target.value)}
            // Nicht type="number": das schluckt fuehrende Nullen und die
            // Bindestriche der Wiederherstellungscodes.
            inputMode="text"
            autoComplete="one-time-code"
            autoCapitalize="none"
            spellCheck={false}
            maxLength={40}
            required
            autoFocus
          />
        </div>
        {error ? (
          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
            {error}
          </p>
        ) : null}
        <button type="submit" className="btn btn-primary w-full py-2.5" disabled={busy !== null}>
          {busy === "code" ? (
            <Loader2 className="h-4 w-4 animate-spin" />
          ) : (
            <LogIn className="h-4 w-4" />
          )}
          Bestätigen
        </button>
        <button
          type="button"
          onClick={() => {
            setMfa(false);
            setCode("");
            setError(null);
          }}
          className="w-full text-center text-sm text-slate-500 hover:text-slate-300"
        >
          Abbrechen
        </button>
      </form>
    );
  }
  return (
    <div className="space-y-5">
      {passkeysAvailable ? (
@@ -1,329 +0,0 @@
 "use client";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { useRouter } from "next/navigation";
 import {
  DndContext,
  DragOverlay,
  PointerSensor,
  TouchSensor,
  pointerWithin,
  useDroppable,
  useSensor,
  useSensors,
  type DragEndEvent,
  type DragOverEvent,
  type DragStartEvent,
 } from "@dnd-kit/core";
 import { restrictToWindowEdges } from "@dnd-kit/modifiers";
 import { SortableContext, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
 import { CheckSquare, Loader2, Plus } from "lucide-react";
 import type { Task, TaskStatus } from "@prisma/client";
 import { TaskCard } from "@/components/tasks/TaskCard";
 import { TaskDialog } from "@/components/tasks/TaskDialog";
 import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 type Columns = Record<TaskStatus, Task[]>;
 function group(tasks: Task[]): Columns {
  const columns = { TODO: [], DOING: [], BLOCKED: [], DONE: [] } as Columns;
  for (const task of [...tasks].sort((a, b) => a.position - b.position)) {
    columns[task.status].push(task);
  }
  return columns;
 }
 /**
 * Aufgabenbrett eines Projekts.
 *
 * Anders als beim Projektbrett ist die Reihenfolge innerhalb einer Spalte
 * hier bedeutsam, deshalb @dnd-kit/sortable statt einfacher Ablageflaechen.
 * Waehrend des Ziehens fuehrt der oertliche Zustand, danach wird die neue
 * Ordnung als Ganzes gespeichert: je Spalte die vollstaendige Liste. Das ist
 * wiederholbar und kommt ohne Nachrechnen von Positionen im Browser aus.
 */
 export function TaskBoard({
  projectId,
  tasks,
  progressFromTasks,
 }: {
  projectId: string;
  tasks: Task[];
  progressFromTasks: boolean;
 }) {
  const router = useRouter();
  const [columns, setColumns] = useState<Columns>(() => group(tasks));
  const [activeId, setActiveId] = useState<string | null>(null);
  const [editing, setEditing] = useState<Task | null>(null);
  const [creatingIn, setCreatingIn] = useState<TaskStatus | null>(null);
  const [saving, setSaving] = useState(false);
  const dragging = useRef(false);
  // Serverstand uebernehmen, solange nicht gerade gezogen wird – sonst
  // wuerde die Karte mitten in der Bewegung zurueckspringen.
  useEffect(() => {
    if (!dragging.current) setColumns(group(tasks));
  }, [tasks]);
  const sensors = useSensors(
    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
    useSensor(TouchSensor, { activationConstraint: { delay: 180, tolerance: 8 } }),
  );
  const allTasks = useMemo(() => Object.values(columns).flat(), [columns]);
  const active = activeId ? allTasks.find((task) => task.id === activeId) ?? null : null;
  const total = allTasks.length;
  const done = columns.DONE.length;
  function containerOf(id: string): TaskStatus | null {
    if (TASK_STATUS_ORDER.includes(id as TaskStatus)) return id as TaskStatus;
    for (const status of TASK_STATUS_ORDER) {
      if (columns[status].some((task) => task.id === id)) return status;
    }
    return null;
  }
  function onDragStart(event: DragStartEvent) {
    dragging.current = true;
    setActiveId(String(event.active.id));
  }
  /** Wechsel der Spalte passiert schon beim Darueberziehen, nicht erst beim Ablegen. */
  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((task) => task.id === activeKey);
      if (!moved) return current;
      const targetIndex = current[to].findIndex((task) => task.id === overKey);
      const insertAt = targetIndex >= 0 ? targetIndex : current[to].length;
      return {
        ...current,
        [from]: current[from].filter((task) => task.id !== activeKey),
        [to]: [
          ...current[to].slice(0, insertAt),
          { ...moved, status: to },
          ...current[to].slice(insertAt),
        ],
      };
    });
  }
  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 overContainer = containerOf(overKey);
      if (container && container === overContainer) {
        const list = columns[container];
        const oldIndex = list.findIndex((task) => task.id === activeKey);
        const newIndex = list.findIndex((task) => task.id === overKey);
        if (oldIndex >= 0 && newIndex >= 0 && oldIndex !== newIndex) {
          const reordered = [...list];
          const [moved] = reordered.splice(oldIndex, 1);
          reordered.splice(newIndex, 0, moved);
          next = { ...columns, [container]: reordered };
          setColumns(next);
        }
      }
    }
    setActiveId(null);
    dragging.current = false;
    await persist(next);
  }
  async function persist(next: Columns) {
    setSaving(true);
    try {
      const payload = {
        columns: Object.fromEntries(
          TASK_STATUS_ORDER.map((status) => [status, next[status].map((task) => task.id)]),
        ),
      };
      const response = await fetch(`/api/projects/${projectId}/tasks/reorder`, {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });
      if (!response.ok) throw new Error("failed");
      router.refresh();
    } catch {
      // Zurueck auf den Serverstand – die Bewegung war dann nur optisch.
      setColumns(group(tasks));
    } finally {
      setSaving(false);
    }
  }
  return (
    <section className="glass p-5">
      <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
        <div className="flex items-center gap-3">
          <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-violet-500/12 text-violet-300">
            <CheckSquare className="h-4 w-4" />
          </span>
          <div>
            <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-200">
              Aufgaben
              {total > 0 ? (
                <span className="rounded-full bg-white/6 px-2 py-0.5 text-[11px] tabular-nums text-slate-400">
                  {done}/{total}
                </span>
              ) : null}
              {saving ? <Loader2 className="h-3 w-3 animate-spin text-slate-500" /> : null}
            </h2>
            <p className="mt-0.5 text-[11px] text-slate-500">
              {progressFromTasks
                ? "Der Fortschritt des Projekts folgt diesen Aufgaben."
                : "Ziehen zum Verschieben und Sortieren."}
            </p>
          </div>
        </div>
        <button
          type="button"
          className="btn btn-ghost px-3 py-1.5 text-xs"
          onClick={() => setCreatingIn("TODO")}
        >
          <Plus className="h-3.5 w-3.5" />
          Aufgabe
        </button>
      </div>
      <DndContext
        sensors={sensors}
        collisionDetection={pointerWithin}
        modifiers={[restrictToWindowEdges]}
        onDragStart={onDragStart}
        onDragOver={onDragOver}
        onDragEnd={onDragEnd}
        onDragCancel={() => {
          setActiveId(null);
          dragging.current = false;
          setColumns(group(tasks));
        }}
      >
        <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-4">
          {TASK_STATUS_ORDER.map((status) => (
            <TaskColumn
              key={status}
              status={status}
              tasks={columns[status]}
              onAdd={() => setCreatingIn(status)}
              onEdit={setEditing}
            />
          ))}
        </div>
        <DragOverlay dropAnimation={{ duration: 180, easing: "cubic-bezier(0.22, 1, 0.36, 1)" }}>
          {active ? <TaskCard task={active} overlay /> : null}
        </DragOverlay>
      </DndContext>
      <TaskDialog
        open={creatingIn !== null || editing !== null}
        projectId={projectId}
        task={editing}
        initialStatus={creatingIn ?? "TODO"}
        onClose={() => {
          setCreatingIn(null);
          setEditing(null);
        }}
      />
    </section>
  );
 }
 function TaskColumn({
  status,
  tasks,
  onAdd,
  onEdit,
 }: {
  status: TaskStatus;
  tasks: Task[];
  onAdd: () => void;
  onEdit: (task: Task) => void;
 }) {
  const meta = TASK_STATUS_META[status];
  const { setNodeRef, isOver } = useDroppable({ id: status });
  return (
    <div
      ref={setNodeRef}
      data-task-column={status}
      className={cn(
        "flex min-h-[8rem] flex-col rounded-xl border border-white/6 bg-black/20 p-2 transition-colors",
        isOver && "border-violet-400/40 bg-violet-500/6",
      )}
    >
      <div className="mb-2 flex items-center gap-2 px-1">
        <span
          className="h-1.5 w-1.5 rounded-full"
          style={{ backgroundColor: meta.color }}
          aria-hidden="true"
        />
        <h3 className="text-[11px] font-semibold uppercase tracking-wider text-slate-400">
          {meta.label}
        </h3>
        <span className="ml-auto text-[10px] tabular-nums text-slate-600">{tasks.length}</span>
      </div>
      <SortableContext
        items={tasks.map((task) => task.id)}
        strategy={verticalListSortingStrategy}
      >
        <div className="flex flex-1 flex-col gap-1.5">
          {tasks.map((task) => (
            <SortableTask key={task.id} task={task} onEdit={onEdit} />
          ))}
          {tasks.length === 0 ? (
            <p className="rounded-lg border border-dashed border-white/8 px-2 py-4 text-center text-[10px] text-slate-600">
              {isOver ? "Hier ablegen" : "leer"}
            </p>
          ) : null}
        </div>
      </SortableContext>
      <button
        type="button"
        onClick={onAdd}
        className="mt-1.5 flex items-center gap-1.5 rounded-lg px-2 py-1.5 text-[11px] text-slate-600 transition-colors hover:bg-white/5 hover:text-slate-300"
      >
        <Plus className="h-3 w-3" />
        hinzufuegen
      </button>
    </div>
  );
 }
 function SortableTask({ task, onEdit }: { task: Task; onEdit: (task: Task) => void }) {
  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
    id: task.id,
  });
  return (
    <div
      ref={setNodeRef}
      style={{ transform: CSS.Translate.toString(transform), transition }}
      className={cn(isDragging && "opacity-30")}
    >
      <TaskCard task={task} onEdit={onEdit} dragHandle={{ ...attributes, ...listeners }} />
    </div>
  );
 }
@@ -1,96 +0,0 @@
 "use client";
 import { AlignLeft, CalendarClock, GripVertical } from "lucide-react";
 import type { Task } from "@prisma/client";
 import { cn, formatDate } from "@/lib/utils";
 /** Faelligkeit einordnen: ueberfaellig, heute, demnaechst. */
 function dueTone(due: Date | string | null, done: boolean) {
  if (!due || done) return null;
  const date = new Date(due);
  if (Number.isNaN(date.getTime())) return null;
  const today = new Date();
  today.setHours(0, 0, 0, 0);
  const target = new Date(date);
  target.setHours(0, 0, 0, 0);
  const days = Math.round((target.getTime() - today.getTime()) / 86_400_000);
  if (days < 0) return { className: "text-rose-300", label: "ueberfaellig" };
  if (days === 0) return { className: "text-amber-300", label: "heute" };
  if (days <= 3) return { className: "text-amber-200/70", label: null };
  return { className: "text-slate-500", label: null };
 }
 export function TaskCard({
  task,
  onEdit,
  dragHandle,
  overlay = false,
 }: {
  task: Task;
  onEdit?: (task: Task) => void;
  dragHandle?: Record<string, unknown>;
  overlay?: boolean;
 }) {
  const done = task.status === "DONE";
  const due = dueTone(task.dueDate, done);
  return (
    <article
      className={cn(
        "group rounded-lg border border-white/8 bg-[#0b0d1c] p-2 transition-colors",
        !overlay && "hover:border-white/16",
        overlay && "rotate-2 cursor-grabbing shadow-2xl ring-1 ring-violet-400/40",
      )}
    >
      <div className="flex items-start gap-1.5">
        <button
          type="button"
          className="mt-0.5 shrink-0 cursor-grab touch-none rounded p-0.5 text-slate-700 transition-colors hover:text-slate-400 active:cursor-grabbing"
          aria-label={`${task.title} verschieben`}
          {...dragHandle}
        >
          <GripVertical className="h-3 w-3" />
        </button>
        <button
          type="button"
          onClick={() => onEdit?.(task)}
          disabled={!onEdit}
          className="min-w-0 flex-1 text-left"
        >
          <p
            className={cn(
              "break-words text-xs leading-snug text-slate-200",
              done && "text-slate-500 line-through",
            )}
          >
            {task.title}
          </p>
          {(task.description || task.dueDate || task.labels.length > 0) && (
            <div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-[10px]">
              {task.description ? (
                <AlignLeft className="h-2.5 w-2.5 text-slate-600" aria-label="hat Beschreibung" />
              ) : null}
              {task.dueDate ? (
                <span className={cn("inline-flex items-center gap-1", due?.className)}>
                  <CalendarClock className="h-2.5 w-2.5" />
                  {due?.label ?? formatDate(task.dueDate)}
                </span>
              ) : null}
              {task.labels.slice(0, 3).map((label) => (
                <span key={label} className="rounded bg-white/6 px-1 py-0.5 text-slate-400">
                  {label}
                </span>
              ))}
            </div>
          )}
        </button>
      </div>
    </article>
  );
 }
@@ -1,233 +0,0 @@
 "use client";
 import { useEffect, useState } from "react";
 import { useRouter } from "next/navigation";
 import { Loader2, Trash2 } from "lucide-react";
 import type { Task, TaskStatus } from "@prisma/client";
 import { Modal } from "@/components/ui/Modal";
 import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
 import { cn, parseTags } from "@/lib/utils";
 /** Datum fuer <input type="date"> – ortszeitbezogen, nicht UTC. */
 function toDateInput(value: Date | string | null): string {
  if (!value) return "";
  const date = new Date(value);
  if (Number.isNaN(date.getTime())) return "";
  const offset = date.getTimezoneOffset() * 60_000;
  return new Date(date.getTime() - offset).toISOString().slice(0, 10);
 }
 export function TaskDialog({
  open,
  projectId,
  task,
  initialStatus,
  onClose,
 }: {
  open: boolean;
  projectId: string;
  task: Task | null;
  initialStatus: TaskStatus;
  onClose: () => void;
 }) {
  const router = useRouter();
  const [title, setTitle] = useState("");
  const [description, setDescription] = useState("");
  const [status, setStatus] = useState<TaskStatus>(initialStatus);
  const [dueDate, setDueDate] = useState("");
  const [labels, setLabels] = useState("");
  const [busy, setBusy] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const isEdit = Boolean(task);
  useEffect(() => {
    if (!open) return;
    setTitle(task?.title ?? "");
    setDescription(task?.description ?? "");
    setStatus(task?.status ?? initialStatus);
    setDueDate(toDateInput(task?.dueDate ?? null));
    setLabels(task?.labels.join(", ") ?? "");
    setError(null);
  }, [open, task, initialStatus]);
  async function submit(event: React.FormEvent) {
    event.preventDefault();
    setBusy(true);
    setError(null);
    const body = {
      title,
      description,
      status,
      // Ohne Uhrzeit auf Mittag legen, damit Zeitzonenverschiebungen das
      // Datum nicht auf den Vortag ziehen.
      dueDate: dueDate ? `${dueDate}T12:00:00` : null,
      labels: parseTags(labels),
    };
    try {
      const response = await fetch(
        isEdit ? `/api/tasks/${task?.id}` : `/api/projects/${projectId}/tasks`,
        {
          method: isEdit ? "PATCH" : "POST",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify(body),
        },
      );
      const payload = await response.json().catch(() => ({}));
      if (!response.ok) throw new Error(payload.error ?? "Speichern fehlgeschlagen.");
      onClose();
      router.refresh();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setBusy(false);
    }
  }
  async function remove() {
    if (!task) return;
    if (!window.confirm(`Aufgabe „${task.title}“ loeschen?`)) return;
    setBusy(true);
    try {
      const response = await fetch(`/api/tasks/${task.id}`, { method: "DELETE" });
      if (!response.ok) throw new Error("Loeschen fehlgeschlagen.");
      onClose();
      router.refresh();
    } catch (caught) {
      setError(caught instanceof Error ? caught.message : String(caught));
    } finally {
      setBusy(false);
    }
  }
  return (
    <Modal
      open={open}
      onClose={onClose}
      width="md"
      title={isEdit ? "Aufgabe bearbeiten" : "Neue Aufgabe"}
      description={isEdit ? undefined : "Titel genuegt – alles andere ist optional."}
    >
      <form onSubmit={submit} className="space-y-4">
        <div>
          <label className="field-label" htmlFor="task-title">
            Titel *
          </label>
          <input
            id="task-title"
            className="field"
            value={title}
            onChange={(event) => setTitle(event.target.value)}
            required
            maxLength={200}
            autoFocus
          />
        </div>
        <div>
          <span className="field-label">Spalte</span>
          <div className="grid grid-cols-2 gap-2 sm:grid-cols-4">
            {TASK_STATUS_ORDER.map((value) => {
              const meta = TASK_STATUS_META[value];
              return (
                <button
                  key={value}
                  type="button"
                  onClick={() => setStatus(value)}
                  className={cn(
                    "rounded-lg border px-2 py-2 text-xs transition-all",
                    status === value
                      ? "border-violet-400/60 bg-violet-500/12 text-white"
                      : "border-white/9 text-slate-400 hover:border-white/20",
                  )}
                >
                  <span className="flex items-center justify-center gap-1.5">
                    <span
                      className="h-1.5 w-1.5 rounded-full"
                      style={{ backgroundColor: meta.color }}
                    />
                    {meta.label}
                  </span>
                </button>
              );
            })}
          </div>
        </div>
        <div>
          <label className="field-label" htmlFor="task-description">
            Beschreibung
          </label>
          <textarea
            id="task-description"
            className="field min-h-24 resize-y font-mono text-[13px]"
            value={description}
            onChange={(event) => setDescription(event.target.value)}
            placeholder="Markdown wird dargestellt."
          />
        </div>
        <div className="grid gap-4 sm:grid-cols-2">
          <div>
            <label className="field-label" htmlFor="task-due">
              Faellig am
            </label>
            <input
              id="task-due"
              className="field"
              type="date"
              value={dueDate}
              onChange={(event) => setDueDate(event.target.value)}
            />
          </div>
          <div>
            <label className="field-label" htmlFor="task-labels">
              Labels (kommagetrennt)
            </label>
            <input
              id="task-labels"
              className="field"
              value={labels}
              onChange={(event) => setLabels(event.target.value)}
              placeholder="bug, ui"
            />
          </div>
        </div>
        {error ? (
          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
            {error}
          </p>
        ) : null}
        <div className="flex items-center justify-between gap-2 pt-1">
          {isEdit ? (
            <button
              type="button"
              className="btn btn-danger px-3 py-1.5 text-xs"
              onClick={remove}
              disabled={busy}
            >
              <Trash2 className="h-3.5 w-3.5" />
              Loeschen
            </button>
          ) : (
            <span />
          )}
          <div className="flex gap-2">
            <button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
              Abbrechen
            </button>
            <button type="submit" className="btn btn-primary" disabled={busy || !title.trim()}>
              {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : null}
              {isEdit ? "Speichern" : "Anlegen"}
            </button>
          </div>
        </div>
      </form>
    </Modal>
  );
 }
@@ -1,7 +1,6 @@
 "use client";
-import { useEffect, useState } from "react";
+import { useEffect } from "react";
 import { createPortal } from "react-dom";
 import { X } from "lucide-react";
 import { cn } from "@/lib/utils";
@@ -15,14 +14,6 @@ interface ModalProps {
  width?: "md" | "lg" | "xl";
 }
 /**
 * Dialog per Portal am body.
 *
 * Ohne Portal waere "position: fixed" wirkungslos: Dialoge werden aus Karten
 * heraus geoeffnet, und deren backdrop-filter erzeugt einen neuen
 * Bezugsrahmen. Der Dialog wuerde sich dann an der Karte ausrichten statt am
 * Fenster.
 */
 export function Modal({
  open,
  title,
@@ -32,10 +23,6 @@ export function Modal({
  footer,
  width = "lg",
 }: ModalProps) {
  const [mounted, setMounted] = useState(false);
  useEffect(() => setMounted(true), []);
  useEffect(() => {
    if (!open) return;
    const onKey = (event: KeyboardEvent) => {
@@ -50,22 +37,22 @@ export function Modal({
    };
  }, [open, onClose]);
-  if (!mounted || !open) return null;
+  if (!open) return null;
-  return createPortal(
+  return (
-    <div className="fixed inset-0 z-[120] flex items-start justify-center overflow-y-auto p-4 sm:p-8">
+    <div className="fixed inset-0 z-50 flex items-start justify-center overflow-y-auto p-4 sm:p-8">
      <button
        type="button"
        aria-label="Dialog schliessen"
        onClick={onClose}
-        className="fixed inset-0 cursor-default bg-[#03040c]/85 backdrop-blur-sm"
+        className="fixed inset-0 cursor-default bg-[#03040c]/80 backdrop-blur-sm"
      />
      <div
        role="dialog"
        aria-modal="true"
        aria-label={title}
        className={cn(
-          "popover fade-up relative z-10 my-auto w-full rounded-2xl p-6",
+          "glass fade-up relative z-10 my-auto w-full p-6",
          width === "md" && "max-w-lg",
          width === "lg" && "max-w-2xl",
          width === "xl" && "max-w-4xl",
@@ -92,7 +79,6 @@ export function Modal({
        {footer ? <div className="mt-6 flex justify-end gap-2">{footer}</div> : null}
      </div>
-    </div>,
+    </div>
    document.body,
  );
 }
@@ -1,141 +0,0 @@
 "use client";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { cn } from "@/lib/utils";
 /**
 * Schwebendes Menue, das per Portal am body haengt.
 *
 * Warum nicht einfach ein absolut positioniertes Kind?
 *
 *  1. Unsere Karten setzen overflow-hidden (fuer den Akzentstreifen und den
 *     Farbverlaufsrand). Ein Kind wuerde daran abgeschnitten.
 *  2. .glass setzt backdrop-filter, und die Projektkarte bekommt beim Hovern
 *     ein transform. Beides erzeugt einen Stacking-Context und einen neuen
 *     Bezugsrahmen: z-index wirkt dann nur noch innerhalb der Karte, und
 *     selbst position: fixed bezieht sich auf die Karte statt auf das
 *     Fenster.
 *
 * Am body haengend entfaellt beides. Die Position wird aus dem Ankerelement
 * berechnet und beim Scrollen und bei Groessenaenderungen nachgefuehrt.
 */
 export function Popover({
  anchorRef,
  open,
  onClose,
  children,
  align = "end",
  width = 240,
  className,
  labelledBy,
  role = "menu",
 }: {
  anchorRef: React.RefObject<HTMLElement | null>;
  open: boolean;
  onClose: () => void;
  children: React.ReactNode;
  /** "end" richtet die rechte Kante am Anker aus. */
  align?: "start" | "end";
  width?: number;
  className?: string;
  labelledBy?: string;
  role?: "menu" | "listbox" | "dialog";
 }) {
  const panelRef = useRef<HTMLDivElement>(null);
  const [mounted, setMounted] = useState(false);
  const [position, setPosition] = useState<{ top: number; left: number } | null>(null);
  useEffect(() => setMounted(true), []);
  const place = useCallback(() => {
    const anchor = anchorRef.current;
    if (!anchor) return;
    const rect = anchor.getBoundingClientRect();
    const margin = 8;
    const gap = 6;
    // Bevorzugte Ausrichtung, bei Ueberlauf auf die andere Seite wechseln.
    // Nur Festklemmen am Fensterrand waere schlecht: bei einem Ausloeser weit
    // links stuende das Menue sonst quer ueber der Seite statt an seinem
    // Ausloeser.
    let left = align === "end" ? rect.right - width : rect.left;
    if (left < margin) left = rect.left;
    if (left + width > window.innerWidth - margin) left = rect.right - width;
    left = Math.min(Math.max(margin, left), window.innerWidth - width - margin);
    const panelHeight = panelRef.current?.offsetHeight ?? 0;
    let top = rect.bottom + gap;
    // Nach oben klappen, wenn unten kein Platz ist, oben aber schon.
    const fitsBelow = top + panelHeight <= window.innerHeight - margin;
    const fitsAbove = rect.top - gap - panelHeight >= margin;
    if (!fitsBelow && fitsAbove) top = rect.top - gap - panelHeight;
    setPosition({ top, left });
  }, [anchorRef, align, width]);
  // Bewusst useEffect statt useLayoutEffect: Letzteres warnt beim
  // Server-Rendering. Ein Aufblitzen an falscher Stelle gibt es trotzdem
  // nicht, weil das Panel bis zur berechneten Position unsichtbar bleibt.
  useEffect(() => {
    if (!open) {
      setPosition(null);
      return;
    }
    place();
  }, [open, place]);
  useEffect(() => {
    if (!open) return;
    // capture: true, damit auch das Scrollen innerer Container ankommt.
    const onScroll = () => place();
    window.addEventListener("scroll", onScroll, true);
    window.addEventListener("resize", onScroll);
    function onPointerDown(event: MouseEvent) {
      const target = event.target as Node;
      if (panelRef.current?.contains(target)) return;
      if (anchorRef.current?.contains(target)) return;
      onClose();
    }
    function onKey(event: KeyboardEvent) {
      if (event.key === "Escape") onClose();
    }
    document.addEventListener("mousedown", onPointerDown);
    document.addEventListener("keydown", onKey);
    return () => {
      window.removeEventListener("scroll", onScroll, true);
      window.removeEventListener("resize", onScroll);
      document.removeEventListener("mousedown", onPointerDown);
      document.removeEventListener("keydown", onKey);
    };
  }, [open, place, onClose, anchorRef]);
  if (!mounted || !open) return null;
  return createPortal(
    <div
      ref={panelRef}
      role={role}
      aria-labelledby={labelledBy}
      style={{
        position: "fixed",
        top: position?.top ?? -9999,
        left: position?.left ?? -9999,
        width,
        // Bis die Position steht, unsichtbar halten – sonst blitzt das
        // Menue kurz an der falschen Stelle auf.
        visibility: position ? "visible" : "hidden",
      }}
      className={cn("popover fade-up z-[100] overflow-hidden p-1.5", className)}
    >
      {children}
    </div>,
    document.body,
  );
 }
@@ -1,22 +0,0 @@
 /**
 * Wird von Next einmal beim Start des Servers ausgefuehrt.
 *
 * Hier haengt der Zeitgeber fuer den automatischen Abgleich.
 *
 * Wichtig ist die Form der Abfrage: Next uebersetzt diese Datei auch fuer den
 * Edge-Runtime (weil es eine Middleware gibt). Dort gibt es weder node:crypto
 * noch node:net, die der Abgleich mitbringt. Der Import muss deshalb *in* der
 * positiven Bedingung stehen – dann ersetzt der Bundler NEXT_RUNTIME beim
 * Bauen und entfernt den ganzen Block aus dem Edge-Bundle. Mit einem frueh
 * abbrechenden "if (… !== 'nodejs') return" bliebe der Import stehen und der
 * Build schluege fehl.
 */
 export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    const { describeConfig } = await import("@/lib/config");
    console.log(`[nebula] Konfiguration: ${describeConfig()}`);
    const { startAutoSyncScheduler } = await import("@/lib/sync/scheduler");
    startAutoSyncScheduler();
  }
 }
@@ -1,57 +0,0 @@
 import { describe, expect, it } from "vitest";
 import { describeFields, describeStatus, shorten } from "./activity";
 describe("describeFields", () => {
  it("nennt ein einzelnes Feld beim Namen", () => {
    expect(describeFields(["name"])).toBe("Name geändert");
  });
  it("zaehlt zwei und drei Felder auf", () => {
    expect(describeFields(["name", "tags"])).toBe("Name und Tags geändert");
    expect(describeFields(["name", "tags", "priority"])).toBe(
      "Name, Tags und Priorität geändert",
    );
  });
  it("fasst ab vier Feldern zusammen, statt eine Litanei zu bilden", () => {
    expect(describeFields(["name", "tags", "priority", "accent"])).toBe("4 Felder geändert");
  });
  it("zaehlt zusammengehoerende Felder nur einmal", () => {
    // repoOwner und repoName sind fuer den Leser eine einzige Aenderung.
    expect(describeFields(["repoOwner", "repoName"])).toBe("Repository geändert");
  });
  it("liefert null, wenn nichts Nennenswertes dabei war", () => {
    // slug wird nur mitgeschrieben, wenn sich der Name aendert – der Name
    // steht dann ohnehin schon in der Liste.
    expect(describeFields([])).toBeNull();
    expect(describeFields(["slug", "updatedAt"])).toBeNull();
  });
 });
 describe("describeStatus", () => {
  it("uebersetzt beide Seiten in die Anzeigenamen", () => {
    expect(describeStatus("IDEA", "IN_DEVELOPMENT")).toBe("Status: Idee → In Entwicklung");
  });
  it("laesst unbekannte Werte stehen, statt sie zu verschlucken", () => {
    expect(describeStatus("IDEA", "PHANTASIE")).toBe("Status: Idee → PHANTASIE");
  });
 });
 describe("shorten", () => {
  it("laesst Kurzes unangetastet", () => {
    expect(shorten("Kurzer Titel")).toBe("Kurzer Titel");
  });
  it("kuerzt auf die vorgegebene Laenge einschliesslich Auslassungszeichen", () => {
    const gekuerzt = shorten("x".repeat(100), 20);
    expect(gekuerzt).toHaveLength(20);
    expect(gekuerzt.endsWith("…")).toBe(true);
  });
  it("macht aus Zeilenumbruechen eine Zeile", () => {
    expect(shorten("Erste Zeile\n\n  zweite  Zeile ")).toBe("Erste Zeile zweite Zeile");
  });
 });
@@ -1,135 +0,0 @@
 import type { ActivityKind, Prisma } from "@prisma/client";
 import { prisma } from "@/lib/db";
 import { STATUS_META } from "@/lib/status";
 /**
 * Verlauf je Projekt: was ist wann passiert.
 *
 * Der Einzeiler wird beim Schreiben formuliert und nicht erst beim Anzeigen.
 * Das ist Absicht: ein Eintrag soll auch dann noch lesbar sein, wenn es die
 * Notiz oder die Aufgabe, um die es ging, laengst nicht mehr gibt.
 */
 /** Wie viele Eintraege je Projekt aufgehoben werden. */
 export const ACTIVITY_LIMIT = 200;
 type Entry = {
  projectId: string;
  /** null = die Anwendung selbst, etwa der Zeitgeber beim Abgleich. */
  userId?: string | null;
  kind: ActivityKind;
  summary: string;
  meta?: Prisma.InputJsonValue;
 };
 /**
 * Haelt einen Vorgang fest. Wirft nie: der Verlauf ist Beiwerk, und daran
 * darf die eigentliche Aenderung nicht scheitern.
 */
 export async function recordActivity(entry: Entry): Promise<void> {
  try {
    await prisma.activity.create({
      data: {
        projectId: entry.projectId,
        userId: entry.userId ?? null,
        kind: entry.kind,
        summary: entry.summary,
        meta: entry.meta,
      },
    });
  } catch (error) {
    console.error("[activity] konnte nicht geschrieben werden:", error);
  }
 }
 /** Mehrere Vorgaenge auf einmal – ein Rundgang statt vieler. */
 export async function recordActivities(entries: Entry[]): Promise<void> {
  if (entries.length === 0) return;
  try {
    await prisma.activity.createMany({
      data: entries.map((entry) => ({
        projectId: entry.projectId,
        userId: entry.userId ?? null,
        kind: entry.kind,
        summary: entry.summary,
        meta: entry.meta,
      })),
    });
  } catch (error) {
    console.error("[activity] konnte nicht geschrieben werden:", error);
  }
 }
 // ── Formulierungshilfen ──────────────────────────────────────
 const FIELD_LABELS: Record<string, string> = {
  name: "Name",
  summary: "Kurzbeschreibung",
  description: "Beschreibung",
  priority: "Priorität",
  progress: "Fortschritt",
  accent: "Farbe",
  tags: "Tags",
  favorite: "Favorit",
  autoSync: "Automatischer Abgleich",
  progressFromTasks: "Fortschritt aus Aufgaben",
  connectionId: "Git-Verbindung",
  repoUrl: "Repository",
  repoOwner: "Repository",
  repoName: "Repository",
  defaultBranch: "Standard-Branch",
 };
 /**
 * Aus geaenderten Feldnamen einen lesbaren Satz machen: "Name und Tags
 * geändert". Doppelte Bezeichnungen fallen weg – wer repoOwner und repoName
 * zusammen setzt, hat einmal das Repository geaendert, nicht zweimal.
 */
 export function describeFields(fields: string[]): string | null {
  const labels: string[] = [];
  for (const field of fields) {
    const label = FIELD_LABELS[field];
    if (label && !labels.includes(label)) labels.push(label);
  }
  if (labels.length === 0) return null;
  if (labels.length === 1) return `${labels[0]} geändert`;
  // Ab vier Feldern wird die Aufzaehlung laenger als sie nuetzt.
  if (labels.length > 3) return `${labels.length} Felder geändert`;
  return `${labels.slice(0, -1).join(", ")} und ${labels.at(-1)} geändert`;
 }
 /** "Idee → In Entwicklung" */
 export function describeStatus(from: string, to: string): string {
  const label = (value: string) =>
    STATUS_META[value as keyof typeof STATUS_META]?.label ?? value;
  return `Status: ${label(from)} → ${label(to)}`;
 }
 /** Kuerzt lange Titel, damit ein Eintrag eine Zeile bleibt. */
 export function shorten(text: string, max = 70): string {
  const clean = text.replace(/\s+/g, " ").trim();
  return clean.length <= max ? clean : `${clean.slice(0, max - 1)}…`;
 }
 /**
 * Stutzt den Verlauf auf die neuesten Eintraege je Projekt zurueck. Laeuft
 * im taeglichen Durchgang des Zeitgebers mit – bei jedem Schreiben zu
 * pruefen waere eine zusaetzliche Abfrage fuer nichts.
 */
 export async function pruneActivities(): Promise<number> {
  const rows = await prisma.$queryRaw<{ count: bigint }[]>`
    WITH nummeriert AS (
      SELECT "id", ROW_NUMBER() OVER (
        PARTITION BY "projectId" ORDER BY "createdAt" DESC, "id" DESC
      ) AS rang
      FROM "Activity"
    ), geloescht AS (
      DELETE FROM "Activity"
      WHERE "id" IN (SELECT "id" FROM nummeriert WHERE rang > ${ACTIVITY_LIMIT})
      RETURNING 1
    )
    SELECT COUNT(*)::bigint AS count FROM geloescht
  `;
  return Number(rows[0]?.count ?? 0);
 }
@@ -1,128 +0,0 @@
 import { createHash, randomBytes } from "node:crypto";
 import { cookies } from "next/headers";
 import type { NextResponse } from "next/server";
 import { COOKIES_SECURE, MFA_COOKIE, MFA_TTL_MS } from "@/lib/config";
 import { tryDecryptSecret } from "@/lib/crypto";
 import { prisma } from "@/lib/db";
 /**
 * Der Zwischenzustand zwischen Passwort und zweitem Faktor.
 *
 * Bewusst nicht als halbfertige Sitzung: eine Sitzungszeile mit einem
 * "noch nicht gueltig"-Merker waere eine Zeile, die bei einem vergessenen
 * Filter irgendwo doch als Anmeldung durchgeht. Ein eigenes Modell kann
 * dieses Versehen nicht passieren.
 */
 /** Nach so vielen Fehlversuchen ist der Vorgang verbrannt. */
 export const MFA_MAX_ATTEMPTS = 5;
 function hashToken(token: string): string {
  return createHash("sha256").update(token).digest("base64url");
 }
 export async function createPendingLogin(userId: string): Promise<string> {
  const token = randomBytes(32).toString("base64url");
  // Aeltere Vorgaenge desselben Kontos verwerfen: es kann nur einen geben,
  // sonst sammeln sich bei jedem Anlauf neue Rateversuche an.
  await prisma.pendingLogin.deleteMany({
    where: { OR: [{ userId }, { expiresAt: { lt: new Date() } }] },
  });
  await prisma.pendingLogin.create({
    data: {
      userId,
      tokenHash: hashToken(token),
      expiresAt: new Date(Date.now() + MFA_TTL_MS),
    },
  });
  return token;
 }
 export function setMfaCookie(response: NextResponse, token: string) {
  response.cookies.set({
    name: MFA_COOKIE,
    value: token,
    httpOnly: true,
    sameSite: "lax",
    secure: COOKIES_SECURE,
    path: "/",
    maxAge: Math.floor(MFA_TTL_MS / 1000),
  });
 }
 export function clearMfaCookie(response: NextResponse) {
  response.cookies.set({
    name: MFA_COOKIE,
    value: "",
    httpOnly: true,
    sameSite: "lax",
    secure: COOKIES_SECURE,
    path: "/",
    maxAge: 0,
  });
 }
 export interface PendingLoginState {
  id: string;
  attempts: number;
  user: {
    id: string;
    username: string;
    role: "ADMIN" | "USER";
    isActive: boolean;
    /** Entschluesselter TOTP-Schluessel; null, wenn er nicht lesbar ist. */
    totpSecret: string | null;
  };
 }
 /** Liest den laufenden Vorgang aus dem Cookie. */
 export async function readPendingLogin(): Promise<PendingLoginState | null> {
  const store = await cookies();
  const token = store.get(MFA_COOKIE)?.value;
  if (!token) return null;
  const pending = await prisma.pendingLogin.findUnique({
    where: { tokenHash: hashToken(token) },
    include: { user: true },
  });
  if (!pending) return null;
  if (pending.expiresAt.getTime() <= Date.now()) {
    await prisma.pendingLogin.delete({ where: { id: pending.id } }).catch(() => undefined);
    return null;
  }
  return {
    id: pending.id,
    attempts: pending.attempts,
    user: {
      id: pending.user.id,
      username: pending.user.username,
      role: pending.user.role,
      isActive: pending.user.isActive,
      totpSecret: tryDecryptSecret(pending.user.totpSecretCipher),
    },
  };
 }
 /** Zaehlt einen Fehlversuch. Gibt zurueck, ob noch Versuche offen sind. */
 export async function noteMfaFailure(id: string): Promise<boolean> {
  const updated = await prisma.pendingLogin.update({
    where: { id },
    data: { attempts: { increment: 1 } },
    select: { attempts: true },
  });
  if (updated.attempts >= MFA_MAX_ATTEMPTS) {
    await prisma.pendingLogin.delete({ where: { id } }).catch(() => undefined);
    return false;
  }
  return true;
 }
 export async function discardPendingLogin(id: string): Promise<void> {
  await prisma.pendingLogin.delete({ where: { id } }).catch(() => undefined);
 }
@@ -1,66 +0,0 @@
 import { describe, expect, it } from "vitest";
 import { PASSWORD_MIN_LENGTH } from "./constants";
 import { hashPassword, validatePasswordStrength, verifyPassword } from "./password";
 describe("hashPassword und verifyPassword", () => {
  it("erkennt das richtige Passwort wieder", async () => {
    const hash = await hashPassword("ein-langes-testpasswort");
    await expect(verifyPassword("ein-langes-testpasswort", hash)).resolves.toBe(true);
  });
  it("weist ein falsches Passwort ab", async () => {
    const hash = await hashPassword("ein-langes-testpasswort");
    await expect(verifyPassword("etwas-anderes", hash)).resolves.toBe(false);
  });
  it("erzeugt fuer dasselbe Passwort unterschiedliche Hashes", async () => {
    // Unterschiedliches Salz – sonst waere an gleichen Hashes ablesbar,
    // wer dasselbe Passwort benutzt.
    const a = await hashPassword("ein-langes-testpasswort");
    const b = await hashPassword("ein-langes-testpasswort");
    expect(a).not.toBe(b);
  });
  it("haelt das erwartete Ablageformat ein", async () => {
    const hash = await hashPassword("ein-langes-testpasswort");
    expect(hash).toMatch(/^scrypt\$\d+\$\d+\$\d+\$[\w-]+\$[\w-]+$/);
  });
  it("stuerzt bei kaputten oder fehlenden Hashes nicht ab", async () => {
    await expect(verifyPassword("x", null)).resolves.toBe(false);
    await expect(verifyPassword("x", "")).resolves.toBe(false);
    await expect(verifyPassword("x", "voelliger-unsinn")).resolves.toBe(false);
    await expect(verifyPassword("x", "scrypt$a$b$c$d$e")).resolves.toBe(false);
  });
  it("behandelt gleichwertige Unicode-Schreibweisen gleich", async () => {
    // "é" als ein Zeichen und als e + Akzent kombiniert.
    const hash = await hashPassword("passwort-café-lang");
    await expect(verifyPassword("passwort-café-lang", hash)).resolves.toBe(true);
  });
 });
 describe("validatePasswordStrength", () => {
  it("nimmt ein ausreichend langes Passwort an", () => {
    expect(validatePasswordStrength("ein-langes-testpasswort")).toBeNull();
  });
  it("weist zu kurze Passwoerter ab", () => {
    expect(validatePasswordStrength("a".repeat(PASSWORD_MIN_LENGTH - 1))).toMatch(
      /mindestens/,
    );
  });
  it("weist naheliegende Passwoerter ab", () => {
    expect(validatePasswordStrength("password")).toBeTruthy();
    expect(validatePasswordStrength("Passwort")).toBeTruthy();
  });
  it("weist reine Ziffernfolgen ab", () => {
    expect(validatePasswordStrength("1234567890123")).toMatch(/Ziffern/);
  });
  it("weist uebermaessig lange Passwoerter ab", () => {
    expect(validatePasswordStrength("a".repeat(300))).toMatch(/hoechstens/);
  });
 });
@@ -1,34 +0,0 @@
 import { describe, expect, it } from "vitest";
 import { hashCode, normalizeCode } from "./recovery";
 describe("normalizeCode", () => {
  it("setzt den Bindestrich, wenn er beim Abtippen fehlt", () => {
    expect(normalizeCode("a7k2mp9xqd")).toBe("a7k2m-p9xqd");
  });
  it("nimmt Grossschreibung und Leerzeichen hin", () => {
    // Aus einem Ausdruck abgeschrieben sieht ein Code selten so aus wie
    // beim Erzeugen.
    expect(normalizeCode("A7K2M-P9XQD")).toBe("a7k2m-p9xqd");
    expect(normalizeCode(" a7k2m p9xqd ")).toBe("a7k2m-p9xqd");
    expect(normalizeCode("a7k2m—p9xqd")).toBe("a7k2m-p9xqd");
  });
  it("laesst zu kurze Eingaben unveraendert, statt sie zurechtzubiegen", () => {
    expect(normalizeCode("abc")).toBe("abc");
  });
 });
 describe("hashCode", () => {
  it("bildet Schreibweisen desselben Codes auf denselben Hash ab", () => {
    expect(hashCode("A7K2M-P9XQD")).toBe(hashCode("a7k2mp9xqd"));
  });
  it("unterscheidet verschiedene Codes", () => {
    expect(hashCode("a7k2m-p9xqd")).not.toBe(hashCode("a7k2m-p9xqe"));
  });
  it("gibt den Code nicht preis", () => {
    expect(hashCode("a7k2m-p9xqd")).not.toContain("a7k2m");
  });
 });
@@ -1,100 +0,0 @@
 import { createHash, randomInt, timingSafeEqual } from "node:crypto";
 import { prisma } from "@/lib/db";
 /**
 * Wiederherstellungscodes fuer den Fall, dass der Authenticator verloren geht.
 *
 * Ohne sie waere die Zwei-Faktor-Anmeldung eine Falle: ein neues Handy, und
 * das Konto ist zu. Ein Administrator kann zwar aushelfen – im
 * Einzelbenutzerbetrieb ist der Administrator aber genau die ausgesperrte
 * Person.
 */
 /** Wie viele Codes bei der Einrichtung erzeugt werden. */
 export const RECOVERY_CODE_COUNT = 10;
 /**
 * Alphabet ohne die Paare, die man beim Abschreiben verwechselt: kein O/0,
 * kein I/l/1, kein B/8. Die Codes werden von Hand aus einem Ausdruck oder
 * Passwortmanager uebertragen, oft unter Zeitdruck.
 */
 const ALPHABET = "abcdefghjkmnpqrstuvwxyz23456789";
 const GROUP = 5;
 /** Ein Code der Form "a7k2m-p9xqd" – rund 50 Bit Zufall. */
 function generateCode(): string {
  const zeichen = Array.from(
    { length: GROUP * 2 },
    () => ALPHABET[randomInt(ALPHABET.length)],
  ).join("");
  return `${zeichen.slice(0, GROUP)}-${zeichen.slice(GROUP)}`;
 }
 /** Vereinheitlicht Eingaben: Grossschreibung und fehlender Bindestrich. */
 export function normalizeCode(input: string): string {
  const clean = input.toLowerCase().replace(/[^a-z0-9]/g, "");
  if (clean.length !== GROUP * 2) return clean;
  return `${clean.slice(0, GROUP)}-${clean.slice(GROUP)}`;
 }
 export function hashCode(code: string): string {
  return createHash("sha256").update(normalizeCode(code)).digest("base64url");
 }
 /**
 * Erzeugt einen frischen Satz und verwirft den alten. Gibt die Codes im
 * Klartext zurueck – das ist die einzige Gelegenheit, sie zu sehen.
 */
 export async function issueRecoveryCodes(userId: string): Promise<string[]> {
  const codes = Array.from({ length: RECOVERY_CODE_COUNT }, generateCode);
  await prisma.$transaction([
    prisma.recoveryCode.deleteMany({ where: { userId } }),
    prisma.recoveryCode.createMany({
      data: codes.map((code) => ({ userId, codeHash: hashCode(code) })),
    }),
  ]);
  return codes;
 }
 /**
 * Loest einen Code ein. Ein Code gilt genau einmal; verbraucht wird er auch
 * dann, wenn die Anmeldung danach aus anderem Grund scheitert – lieber ein
 * Code zu viel verbraucht als einer, der zweimal geht.
 */
 export async function redeemRecoveryCode(userId: string, input: string): Promise<boolean> {
  const eingabe = normalizeCode(input);
  if (eingabe.length < GROUP * 2) return false;
  const offen = await prisma.recoveryCode.findMany({
    where: { userId, usedAt: null },
    select: { id: true, codeHash: true },
  });
  const gesucht = Buffer.from(hashCode(eingabe), "utf8");
  let treffer: string | null = null;
  for (const code of offen) {
    const vorhanden = Buffer.from(code.codeHash, "utf8");
    // Nicht abbrechen, sobald es passt: die Laufzeit soll nicht verraten,
    // an welcher Stelle der Liste der Code stand.
    if (vorhanden.length === gesucht.length && timingSafeEqual(vorhanden, gesucht)) {
      treffer = code.id;
    }
  }
  if (!treffer) return false;
  // updateMany mit der Bedingung "noch unbenutzt": zwei gleichzeitige
  // Versuche mit demselben Code koennen so nicht beide durchkommen.
  const result = await prisma.recoveryCode.updateMany({
    where: { id: treffer, usedAt: null },
    data: { usedAt: new Date() },
  });
  return result.count === 1;
 }
 /** Wie viele Codes noch ungenutzt sind – fuer den Hinweis im Konto. */
 export async function countUnusedRecoveryCodes(userId: string): Promise<number> {
  return prisma.recoveryCode.count({ where: { userId, usedAt: null } });
 }
--- a/Show More
+++ b/Show More