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

Behebt florian.wilde/nebula#1.

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

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

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

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

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

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

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

.env.example

@@ -69,9 +69,14 @@ ADMINER_PORT="127.0.0.1:8080"
 # und Passkeys sind davon nicht betroffen.
 APP_SECRET="bitte-aendern-mindestens-32-zeichen-langer-zufallswert"
 
-# Lebensdauer einer Anmeldung in Tagen.
+# Absolute Lebensdauer einer Anmeldung in Tagen – ab dem Anmelden gerechnet
+# und nicht verlaengerbar.
 SESSION_TTL_DAYS="30"
 
+# Leerlauffrist in Stunden: so lange darf eine Sitzung unbenutzt bleiben.
+# Wird bei jeder Nutzung neu angestossen. 0 schaltet die Pruefung ab.
+SESSION_IDLE_HOURS="8"
+
 # ── Benachrichtigungen ───────────────────────────────────────
 # ntfy und Webhook brauchen nichts weiter – die Ziele werden in der
 # Anwendung unter "Mein Konto" eingerichtet.

FEATURES.md

@@ -22,8 +22,19 @@ sonst würden Konten ausgesperrt. Nach der Einrichtung ist `/setup` dauerhaft ge
 
 ### 0.2 Anmeldung
 
-- **Benutzername und Passwort.** Mindestens 10 Zeichen, offensichtliche Passwörter werden
+- **Benutzername und Passwort.** Mindestens 10 Zeichen. Abgelehnt werden naheliegende
-  abgelehnt. Hashing mit scrypt.
+  Passwörter, reine Ziffernfolgen, zu wenig verschiedene Zeichen (`abababab`),
+  durchlaufende Folgen (`abcdefgh`) und alles, was den eigenen Benutzernamen enthält.
+  **Keine Zusammensetzungsregeln** — ASVS 2.1.9 rät ausdrücklich davon ab, weil sie zu
+  `Passwort1!` führen statt zu Entropie.
+- **Hashing mit scrypt**, `N = 2^17, r = 8, p = 1` nach dem OWASP Password Storage Cheat
+  Sheet (rund 0,5 s und 128 MiB je Prüfung). Die Parameter stehen im Hash, ältere bleiben
+  also lesbar — und werden bei der nächsten Anmeldung still auf den aktuellen Stand
+  gehoben. Das ist der einzige Moment, in dem das Klartextpasswort vorliegt.
+- **Gleiche Antwort für alles Fehlgeschlagene.** Ob ein Konto existiert, gesperrt,
+  deaktiviert oder reines Passkey-Konto ist, sagt die Anmeldung erst, wenn das Passwort
+  stimmt. Davor gibt es genau einen Text und eine vergleichbare Antwortzeit
+  (`fakeVerifyDelay`), damit sich Benutzernamen nicht durchprobieren lassen.
 - **Passkey (WebAuthn).** Fingerabdruck, Gesichtserkennung oder Sicherheitsschlüssel. Die
   Anmeldung läuft über auffindbare Credentials, ein Benutzername ist also nicht nötig.
   Mehrere Passkeys pro Konto, benennbar und einzeln entfernbar.
@@ -503,6 +514,103 @@ Dateneinsicht. Ein Administrator sieht dadurch weiterhin keine fremden Projekte.
 - **Zeitlimit** pro Aufruf über `GIT_API_TIMEOUT_MS` einstellbar; die Teilabfragen laufen
   parallel, eine fehlschlagende Liste bricht den restlichen Sync nicht ab.
 
+### 4.6 Aufgabe ↔ Git-Issue
+
+Die Verbindung geht in beide Richtungen — mit einer bewussten Grenze.
+
+**Nebula → Git.** Ein Knopf im Aufgabendialog legt zur Aufgabe ein Issue im
+verknüpften Repository an. Nummer und Adresse landen an der Aufgabe (`sourceIssue`,
+`sourceUrl`, `sourceRepositoryId` — dieselben Felder, die die Übernahme aus Issues seit
+v0.9.0 füllt, samt Eindeutigkeit je Repository gegen Dubletten). In den Rumpf kommt ein
+Rückverweis auf das Projekt.
+
+Ausdrücklich **per Knopf und nie nebenbei**: was in ein fremdes System geschrieben wird,
+soll jemand gewollt haben. Danach wandert der Zustand allerdings mit — erledigt schließt
+das Issue, ein Zurückziehen öffnet es wieder. Schlägt der Aufruf fehl, zieht die Aufgabe
+trotzdem um; ein nicht erreichbares Git-System darf das Abhaken nicht verhindern.
+
+**Git → Nebula** auf zwei Wegen, die sich ergänzen:
+
+- **Webhook** — sofort, sobald das Issue geschlossen wird. Setzt voraus, dass die Instanz
+  von außen erreichbar ist und der Haken eingetragen wurde (siehe 4.7).
+- **Beim Abgleich** — verzögert, aber verlässlich. Der Abgleich fragt den Zustand
+  verknüpfter Issues nach und hakt ab, was in Git geschlossen ist. Damit funktioniert der
+  Rückweg auch ohne Webhook, ohne öffentliche Erreichbarkeit und selbst dann, wenn ein
+  Haken einmal ausfällt.
+
+  Gespart wird, wo es geht: Nummern, die der gerade geholte Snapshot als offen führt,
+  werden nicht einzeln nachgefragt. Umgekehrt gilt das nicht — die Liste der offenen
+  Issues ist gedeckelt, aus dem Fehlen einer Nummer folgt also nichts. Pro Durchgang
+  fragt der Abgleich höchstens 25 Issues nach.
+
+  **Der Abgleich hakt nur ab, er nimmt nie zurück.** Er sieht Zustände, keine Ereignisse:
+  ein offenes Issue kann auch bedeuten, dass das Schließen von Nebula aus fehlgeschlagen
+  ist. Ein symmetrischer Abgleich würde dann eine bewusst erledigte Aufgabe wieder
+  aufmachen. Das Zurücknehmen bleibt dem Webhook vorbehalten, der ein echtes „reopened“
+  sieht.
+
+  Ein gelöschtes Issue ist kein erledigtes — die Aufgabe bleibt stehen.
+
+In beiden Fällen bewirkt ein geschlossenes Issue dasselbe wie ein Haken in der
+Oberfläche: bei einer wiederkehrenden Aufgabe entsteht die nächste Fassung, und der
+Vorgang landet im Projektverlauf (ohne Benutzer — das hat nicht jemand in Nebula getan,
+sondern das Git-System gemeldet).
+
+**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
+`Offen · In Arbeit · Blockiert · Erledigt`, ein Issue nur offen oder geschlossen. Nach
+außen geht deshalb nur die Grenze um „erledigt“; ein Rundlauf verliert *In Arbeit* und
+*Blockiert*. Labels wie `nebula:doing` wären die Alternative, würden aber den
+Issue-Tracker mit Zuständen füllen, die dort niemand pflegt. Die feine Abstufung bleibt
+in Nebula.
+
+Eine echte beidseitige Synchronisation mit Konfliktauflösung gibt es **nicht** — das ist
+der klassische Ort für stillen Datenverlust.
+
+**Kein Widerspruch zu „keine eigenen Git-Operationen“:** Issues laufen über die HTTP-API
+der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`, SSRF-Schutz
+inklusive). Kein Klon, kein Arbeitsverzeichnis. Schreibende Aufrufe folgen dabei
+**keinen Umleitungen** — ein 307 auf eine interne Adresse nähme den Rumpf und den Token
+im Header mit.
+
+### 4.7 Webhooks
+
+Ein Push aktualisiert den Stand sofort, statt bis zum nächsten Durchlauf des Zeitgebers
+zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Der Zeitplan bleibt als
+Rückfalllösung bestehen.
+
+Einzurichten am Repository (Funksymbol im Git-Bereich): Nebula erzeugt URL und
+Geheimnis, eingetragen wird der Haken im Git-System von Hand. Über die API anzulegen
+wäre machbar, verlangte aber Administrationsrechte am Repository — deutlich mehr, als
+Nebula sonst braucht.
+
+Das Geheimnis ist **genau einmal** zu sehen; danach liegt es verschlüsselt in der
+Datenbank, wie die Zugangstoken, und verlässt den Server nicht mehr.
+
+| System | Ausweis | Kopfzeile |
+| --- | --- | --- |
+| GitHub | HMAC-SHA256 über den Rumpf | `X-Hub-Signature-256: sha256=…` |
+| Gitea | dieselbe Rechnung, ohne Präfix | `X-Gitea-Signature` (ältere: `X-Hub-Signature-256`) |
+| GitLab | das Geheimnis im Klartext | `X-Gitlab-Token` |
+
+GitLabs Verfahren ist schwächer: es beweist nur, dass der Absender das Geheimnis kennt,
+nicht dass der Rumpf unverändert ist. Mehr gibt die Plattform nicht her; verglichen wird
+trotzdem zeitkonstant.
+
+Geprüft wird gegen den **rohen** Rumpf — durch `JSON.parse` und `JSON.stringify` gedreht
+käme eine andere Zeichenfolge heraus und die Signatur passte nie.
+
+Was der Endpunkt bewusst **nicht** tut: den Rumpf als Quelle für Inhalte benutzen. Titel,
+Beschreibung und Zustand kommen weiter aus Nebula beziehungsweise beim nächsten Abgleich
+aus der API. Wer das Geheimnis kennt, kann also höchstens eine Aufgabe auf- oder zumachen
+und einen Abgleich auslösen — keine beliebigen Daten einschleusen.
+
+Unbekannte Ereignisse werden angenommen und liegen gelassen. Ein Fehler brächte das
+Git-System zum Wiederholen und irgendwann zum Abschalten des Hakens.
+
+Der Endpunkt ist der einzige ohne Anmeldung, der schreibt. Deshalb: Ratenbegrenzung je
+Repository (60/Minute), Deckel auf die Rumpfgröße, und ein unbekanntes Repository
+antwortet wie ein nicht eingerichtetes — mit 404, damit die ID nicht bestätigt wird.
+
 ---
 
 ## 4a. Export, Import und Sicherung
@@ -688,6 +796,16 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
   `GIT_BLOCK_PRIVATE` und `GIT_ALLOWED_HOSTS`.
 - **Rate-Limiting** für Anmeldung (je IP und je Konto), ausgehende Git-Aufrufe und
   WebAuthn-Optionen.
+- **Sitzungen**: Zufallstoken mit 256 Bit, in der Datenbank nur als SHA-256-Hash — wer die
+  Datenbank liest, kann keine Sitzung übernehmen. Geprüft wird bei jeder Anfrage, Abmelden
+  und Sperren wirken also sofort. Zwei Fristen nach ASVS 3.3.2: **absolut** 30 Tage ab
+  Anmeldung (`SESSION_TTL_DAYS`) und **im Leerlauf** 8 Stunden (`SESSION_IDLE_HOURS`).
+  Ein Passwortwechsel entwertet alle Sitzungen und stellt für das eigene Gerät eine neue
+  aus.
+- **Cookies**: `HttpOnly`, `SameSite=Strict`, `Secure` sobald die App über HTTPS läuft, und
+  dann zusätzlich mit dem Präfix `__Host-`. Der Präfix lässt den Browser selbst erzwingen,
+  dass kein `Domain` gesetzt ist — eine andere Subdomain kann den Cookie damit nicht
+  überschreiben und keine Sitzung unterschieben.
 - Access Tokens verschlüsselt mit **AES-256-GCM**, Schlüssel per **scrypt** aus
   `APP_SECRET` abgeleitet, Chiffrat versioniert (`v1.<iv>.<tag>.<data>`).
 - Tokens werden nie an den Browser gesendet — alle API-Antworten nutzen eine Feldauswahl

README.md

@@ -118,7 +118,8 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `APP_URL` | Öffentliche Adresse — bestimmt die WebAuthn-RP-ID | `http://localhost:3000` |
 | `DATABASE_URL` | PostgreSQL-Verbindung (Prisma) | `postgresql://nebula:nebula@localhost:5432/nebula` |
 | `APP_SECRET` | Schlüssel für die Token-Verschlüsselung (AES-256-GCM) | — **unbedingt setzen** |
-| `SESSION_TTL_DAYS` | Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_TTL_DAYS` | Absolute Lebensdauer einer Anmeldung in Tagen | `30` |
+| `SESSION_IDLE_HOURS` | Nach so vielen Stunden ohne Nutzung läuft die Sitzung ab (`0` = aus) | `8` |
 | `PORT` | Port der Anwendung | `3000` |
 | `APP_PORT` | Host-Port-Mapping des App-Containers | `127.0.0.1:3000` |
 | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |

ROADMAP.md

@@ -27,15 +27,6 @@ Migration wert.
 
 ---
 
-### 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.
-
----
-
 ### 1.2 Läuft es noch? `M`
 
 Eine Health-Check-URL je Projekt, die der Zeitgeber regelmäßig anpingt.
@@ -52,47 +43,21 @@ Sitzungen.
 
 ---
 
-### 1.4 v1.7.0 „Aufgaben und Issues" `M` + `M`
+### 1.4 Aufgaben ↔ Issues: was noch fehlt `S`
 
-Nachverfolgbarkeit zwischen Nebula-Aufgabe und Git. Die Zuordnung steht im
+Mit v1.7.0 stehen beide Richtungen: „als Issue anlegen“ und der Rückweg über
-Schema bereits: `sourceIssue`, `sourceUrl`, `sourceRepositoryId` samt
+Webhooks. Offen geblieben ist Kleinkram:
-`@@unique`. Die Richtung **Git → Nebula** gibt es seit v0.9.0
-(`tasks/from-issues`); es fehlt die Gegenrichtung.
 
-**Kein Widerspruch zu „Bewusst nicht".** Ausgeschlossen sind dort *eigene
+- **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
-Git-Operationen* — klonen, committen, pushen. Issues laufen über die
+  Projekt aus Frontend und Backend fehlt die Wahl.
-HTTP-API der Provider, dieselbe Schicht wie alles andere (`lib/git/http.ts`,
+- **Beim Übernehmen aus Issues** wird der Rückweg nicht automatisch
-SSRF-Schutz inklusive). Kein Klon, kein Arbeitsverzeichnis.
+  eingerichtet — der Webhook ist getrennt zu setzen.
 
-Warum Issues und nicht eine Datei im Repo: **dort verlinkt Git ohnehin.**
+Was **nicht** kommt, bleibt wie besprochen: eine echte beidseitige
-Ein `fixes #12` in der Commit-Nachricht stellt die Verbindung von selbst
+Synchronisation mit Konfliktauflösung. Die Zustände passen ohnehin nicht
-her — die Kette Aufgabe → Commit → PR gibt es geschenkt, statt sie zu bauen.
+aufeinander — ein Issue kennt nur offen und geschlossen, `DOING` und
-Damit erledigt sich auch „Aufgabe ↔ Commit verknüpfen" aus Abschnitt 3.
+`BLOCKED` gehen im Rundlauf verloren. Das ist hingenommen, statt den
-
+Issue-Tracker mit Labels zu füllen, die dort niemand pflegt.
-**Stufe 1 — eine Richtung, ausdrücklich** `M`
-Ein Knopf „als Issue anlegen" an der Aufgabe. Nummer und URL wandern in die
-vorhandenen Felder. Kein Automatismus: was nach außen geht, wird
-angestoßen, nicht nebenbei mitgeschrieben.
-
-**Stufe 2 — Rückweg über Webhooks** `M`
-Setzt 1.1 voraus. Geschlossenes Issue → Aufgabe nach `DONE`. Erst damit ist
-„synchron" ehrlich, ohne im Minutentakt fremde APIs zu fragen.
-
-**Die Zustände passen nicht aufeinander, und das bleibt so.** Nebula kennt
-`TODO/DOING/BLOCKED/DONE`, ein Issue nur offen/geschlossen. Ein Rundlauf
-verliert also `DOING` und `BLOCKED` — bewusst hingenommen: die feine
-Abstufung bleibt in Nebula, nach Git geht nur offen/zu. Labels wie
-`nebula:doing` wären die Alternative, würden aber den Issue-Tracker mit
-Zuständen zumüllen, die dort niemand pflegt.
-
-**Echte beidseitige Synchronisation mit Konfliktauflösung ist nicht
-vorgesehen.** Das ist der klassische Ort für stillen Datenverlust, und für
-ein persönliches Dashboard steht der Aufwand in keinem Verhältnis.
-
-Für Projekte ohne Issue-Tracker wäre eine `.nebula/tasks.md` über die
-Contents-API denkbar — aber nur als **einseitiger Spiegel**, nicht als
-Synchronisation: zwei Schreiber auf einer Datei, und jede Statusänderung
-ein Commit.
 
 ---
 
@@ -172,6 +137,7 @@ Damit klar ist, was **nicht** kommt und warum:
 | **v1.4.0** README-Vorschau auf der Projektseite | ✓ |
 | **v1.5.0** Sicherheitsdurchsicht, Server-Anleitung und Update-Skript | ✓ |
 | **v1.6.0** Mobile Ansicht, Listenansicht, Schnellerfassung, Aufgaben über alle Projekte | ✓ |
+| **v1.7.0** Aufgabe als Git-Issue anlegen, Webhooks für Push und Issues | ✓ |
 
 Zur Entscheidung beim Export: Git-Tokens gehen **nicht** mit. Die Verbindung wird nur
 beschrieben, das Token ist nach dem Import neu zu hinterlegen. Snapshots bleiben

e2e/api.spec.ts

@@ -1,4 +1,13 @@
 import { expect, test, type APIRequestContext } from "@playwright/test";
+import { PrismaClient } from "@prisma/client";
+
+/**
+ * Dieselbe Datenbank wie global-setup.ts. Gebraucht fuer den einen Fall, in
+ * dem ein Zustand herzustellen ist, den die API bewusst nicht anbietet.
+ */
+const DATABASE_URL =
+  process.env.E2E_DATABASE_URL ??
+  "postgresql://nebula:nebula@localhost:5432/nebula_e2e_test?schema=public";
 
 /**
  * Tests ueber HTTP gegen die laufende Anwendung – also durch Middleware,
@@ -279,6 +288,228 @@ test("Mehrere Repositories je Projekt", async ({ request, playwright }) => {
   expect(zumSchluss.repositories[0].repoName).toBe("swr");
 });
 
+test("Die Anmeldung verraet nicht, welche Konten es gibt", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Ein Konto anlegen und stilllegen.
+  const angelegt = await request.post("/api/admin/users", {
+    data: {
+      username: "stillgelegt",
+      password: "ein-ausreichend-langes-passwort",
+      role: "USER",
+    },
+  });
+  expect(angelegt.status()).toBe(201);
+  const id = (await angelegt.json()).user.id;
+  expect((await request.patch(`/api/admin/users/${id}`, { data: { isActive: false } })).ok())
+    .toBeTruthy();
+
+  const anonym = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+
+  // Falsches Passwort auf dem stillgelegten Konto ...
+  const stillgelegt = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "falsches-passwort-hier" },
+  });
+  // ... und auf einem Konto, das es gar nicht gibt.
+  const erfunden = await anonym.post("/api/auth/login", {
+    data: { username: "gibtesnicht", password: "falsches-passwort-hier" },
+  });
+
+  // Beides muss ununterscheidbar sein – sonst laesst sich durchprobieren,
+  // welche Benutzernamen vergeben sind. Frueher kam hier 403 gegen 401.
+  expect(stillgelegt.status()).toBe(erfunden.status());
+  expect(stillgelegt.status()).toBe(401);
+  expect(await stillgelegt.json()).toEqual(await erfunden.json());
+
+  // Mit dem richtigen Passwort darf die Anwendung dann Klartext reden.
+  const mitPasswort = await anonym.post("/api/auth/login", {
+    data: { username: "stillgelegt", password: "ein-ausreichend-langes-passwort" },
+  });
+  expect(mitPasswort.status()).toBe(403);
+  expect((await mitPasswort.json()).error).toMatch(/deaktiviert/);
+
+  await anonym.dispose();
+  await request.delete(`/api/admin/users/${id}`);
+});
+
+test("Abgleich hakt Aufgaben ab, deren Issue geschlossen wurde", async ({ request }) => {
+  await login(request, ADMIN);
+
+  // Ein oeffentliches Repository mit sicher geschlossenen Issues. Der
+  // Abgleich laeuft anonym gegen die GitHub-API – kein Token noetig.
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Rueckweg", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  const angelegt = await request.post(`/api/projects/${projekt.id}/tasks`, {
+    data: { title: "Haengt an einem geschlossenen Issue" },
+  });
+  const taskId = (await angelegt.json()).task.id;
+
+  /**
+   * Die Verknuepfung direkt in der Datenbank setzen.
+   *
+   * Ueber die API gibt es dafuer keinen Weg, und das ist richtig so: "als
+   * Issue anlegen" wuerde ein neues Issue in einem fremden Repository
+   * erzeugen. Ein Endpunkt nur fuer Tests waere eine Hintertuer im
+   * Produktionscode – dafuer greift der Test lieber selbst zur Datenbank.
+   *
+   * Issue 1 von vercel/swr ist seit Jahren geschlossen.
+   */
+  const prisma = new PrismaClient({
+    datasources: { db: { url: DATABASE_URL } },
+  });
+  try {
+    await prisma.task.update({
+      where: { id: taskId },
+      data: { sourceRepositoryId: repoId, sourceIssue: 1 },
+    });
+  } finally {
+    await prisma.$disconnect();
+  }
+
+  const vorher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const alsAngelegt = vorher.project.tasks.find(
+    (t: { id: string }) => t.id === taskId,
+  );
+  expect(alsAngelegt.sourceIssue).toBe(1);
+  expect(alsAngelegt.status).toBe("TODO");
+
+  // Abgleich anstossen – er fragt den Zustand des Issues nach.
+  const sync = await request.post(`/api/repositories/${repoId}/sync`);
+  const syncBody = await sync.json();
+
+  /**
+   * Dieser Test greift als einziger wirklich nach draussen. Ist GitHub nicht
+   * erreichbar oder das anonyme Rate-Limit ausgeschoepft, sagt er das statt
+   * rot zu werden – ein fremder Dienst darf die Testreihe nicht bestimmen.
+   */
+  if (!sync.ok()) {
+    test.skip(true, `GitHub nicht erreichbar: ${syncBody.message ?? sync.status()}`);
+    return;
+  }
+
+  const nachher = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  const abgehakt = nachher.project.tasks.find((t: { id: string }) => t.id === taskId);
+  expect(abgehakt.status).toBe("DONE");
+  expect(abgehakt.doneAt).not.toBeNull();
+
+  // Und ein zweiter Lauf aendert nichts mehr – abgehakt bleibt abgehakt,
+  // ohne dass erneut nachgefragt wird.
+  const nochmal = await request.post(`/api/repositories/${repoId}/sync`);
+  expect((await nochmal.json()).message ?? "").not.toMatch(/abgehakt/);
+});
+
+test("Webhook: Signatur entscheidet, sonst passiert nichts", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (
+      await request.post("/api/projects", {
+        data: { name: "Hakenprojekt", repoUrl: "https://github.com/vercel/swr" },
+      })
+    ).json()
+  ).project;
+  const repoId = projekt.repositories[0].id;
+
+  // Ohne eingerichteten Webhook ist der Endpunkt stumm – und zwar mit 404,
+  // damit die ID nicht bestaetigt wird.
+  const ohne = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json" },
+    data: { action: "closed", issue: { number: 1 } },
+  });
+  expect(ohne.status()).toBe(404);
+
+  // Einrichten liefert das Geheimnis genau einmal zurueck.
+  const eingerichtet = await request.post(`/api/repositories/${repoId}/webhook`);
+  expect(eingerichtet.status()).toBe(200);
+  const { secret, url } = await eingerichtet.json();
+  expect(typeof secret).toBe("string");
+  expect(secret.length).toBeGreaterThanOrEqual(64);
+  expect(url).toContain(`/api/webhooks/${repoId}`);
+
+  // Und danach nirgends mehr: weder im Projekt noch am Repository.
+  const geladen = await (await request.get(`/api/projects/${projekt.id}`)).json();
+  expect(JSON.stringify(geladen)).not.toContain(secret);
+  expect(geladen.project.repositories[0].webhookSecret).toBeUndefined();
+
+  // Eine Aufgabe, die an einem Issue haengt – von Hand gesetzt gibt es
+  // nicht, also ueber die Uebernahme aus dem Snapshot. Stattdessen prueft
+  // dieser Test die Grenze selbst: ohne gueltige Signatur passiert nichts.
+  const rumpf = JSON.stringify({ action: "closed", issue: { number: 4242 } });
+
+  const falsch = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": "sha256=00",
+    },
+    data: rumpf,
+  });
+  expect(falsch.status()).toBe(401);
+
+  const gar_keine = await request.post(`/api/webhooks/${repoId}`, {
+    headers: { "Content-Type": "application/json", "X-GitHub-Event": "issues" },
+    data: rumpf,
+  });
+  expect(gar_keine.status()).toBe(401);
+
+  // Mit richtiger Signatur wird der Aufruf angenommen. Zu Issue 4242 gibt
+  // es keine Aufgabe – erwartet ist also "angenommen, nichts zugeordnet".
+  const { createHmac } = await import("node:crypto");
+  const signatur = createHmac("sha256", secret).update(rumpf, "utf8").digest("hex");
+  const richtig = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(richtig.status()).toBe(200);
+  const antwort = await richtig.json();
+  expect(antwort).toMatchObject({ ok: true, handled: "issue", matched: false });
+
+  // Dieselbe Signatur zu einem anderen Rumpf gilt nicht.
+  const veraendert = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: JSON.stringify({ action: "closed", issue: { number: 9999 } }),
+  });
+  expect(veraendert.status()).toBe(401);
+
+  // Fremde Konten koennen den Haken weder einrichten noch zuruecknehmen.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await fremd.post(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  expect((await fremd.delete(`/api/repositories/${repoId}/webhook`)).status()).toBe(404);
+  await fremd.dispose();
+
+  // Zuruecknehmen schliesst den Endpunkt wieder.
+  expect((await request.delete(`/api/repositories/${repoId}/webhook`)).ok()).toBeTruthy();
+  const danach = await request.post(`/api/webhooks/${repoId}`, {
+    headers: {
+      "Content-Type": "application/json",
+      "X-GitHub-Event": "issues",
+      "X-Hub-Signature-256": `sha256=${signatur}`,
+    },
+    data: rumpf,
+  });
+  expect(danach.status()).toBe(404);
+});
+
 test("Brett: Reihenfolge und Mehrfachauswahl", async ({ request, playwright }) => {
   await login(request, ADMIN);
 

e2e/ui.spec.ts

@@ -163,6 +163,46 @@ test("Schnellerfassung legt Idee und Aufgabe mit einem Feld an", async ({ page }
   await expect(page.getByText("Aus der Bahn notiert")).toBeVisible();
 });
 
+test("Dialoge weichen der Bildschirmtastatur aus", async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+  await page.getByRole("button", { name: "Schnell erfassen" }).click();
+  await expect(page.getByRole("dialog")).toBeVisible();
+
+  const TASTATUR = 336;
+
+  /**
+   * Eine echte Tastatur laesst sich nicht einblenden. Stattdessen meldet
+   * visualViewport eine kleinere Hoehe – genau die Schnittstelle, an der
+   * der Dialog haengt. Ueberschrieben wird am echten Objekt: der Dialog
+   * merkt sich beim Oeffnen eine Referenz darauf.
+   */
+  await page.evaluate((tastatur) => {
+    const fenster = window.visualViewport;
+    if (!fenster) throw new Error("visualViewport fehlt");
+    const hoehe = window.innerHeight - tastatur;
+    Object.defineProperty(fenster, "height", { get: () => hoehe, configurable: true });
+    Object.defineProperty(fenster, "offsetTop", { get: () => 0, configurable: true });
+    fenster.dispatchEvent(new Event("resize"));
+  }, TASTATUR);
+
+  await page.waitForTimeout(300);
+
+  // Eingabefeld und Absendeknopf muessen oberhalb der Tastatur liegen.
+  // Vorher stand der Dialog mittig im vollen Fenster – und damit zur
+  // Haelfte darunter.
+  const frei = 667 - TASTATUR;
+  for (const ziel of [
+    page.locator("#quick-title"),
+    page.getByRole("dialog").getByRole("button", { name: "Anlegen" }),
+  ]) {
+    const kasten = await ziel.boundingBox();
+    expect(kasten).not.toBeNull();
+    expect(kasten!.y + kasten!.height).toBeLessThanOrEqual(frei);
+  }
+
+  await page.keyboard.press("Escape");
+});
+
 test("Aufgabenuebersicht sammelt ueber alle Projekte und hakt ab", async ({ page }) => {
   await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
   await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nebula",
-  "version": "1.6.0",
+  "version": "1.9.0",
   "private": true,
   "description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
   "scripts": {

prisma/migrations/20260815000000_repository_webhook/migration.sql

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

prisma/schema.prisma

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src/app/tasks/page.tsx

@@ -42,6 +42,7 @@ export default async function TasksPage() {
     dueDate: task.dueDate ? task.dueDate.toISOString() : null,
     labels: task.labels,
     recurrence: task.recurrence,
+    sourceIssue: task.sourceIssue,
     sourceUrl: task.sourceUrl,
     bucket: dueBucket(task.dueDate, jetzt),
     project: task.project,

src/components/GitPanel.tsx

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

src/components/WebhookDialog.tsx

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

src/components/tasks/TaskDialog.tsx

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

src/components/tasks/TaskOverview.tsx

@@ -14,6 +14,7 @@ import {
 } from "lucide-react";
 import type { TaskStatus } from "@prisma/client";
 import { QuickCapture } from "@/components/QuickCapture";
+import { TaskDialog } from "@/components/tasks/TaskDialog";
 import {
   DUE_BUCKET_META,
   DUE_BUCKET_ORDER,
@@ -44,6 +45,8 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
   const [zeigeErledigte, setZeigeErledigte] = useState(false);
   const [erfassenOffen, setErfassenOffen] = useState(false);
   const [laufend, setLaufend] = useState<Set<string>>(new Set());
+  /** Welche Aufgabe gerade im Dialog liegt. null heisst: keiner offen. */
+  const [bearbeiten, setBearbeiten] = useState<TaskOverviewItem | null>(null);
 
   const projekte = useMemo(() => {
     const map = new Map<string, string>();
@@ -253,6 +256,7 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
                       task={task}
                       busy={laufend.has(task.id)}
                       onToggle={() => abhaken(task)}
+                      onEdit={() => setBearbeiten(task)}
                     />
                   ))}
                 </ul>
@@ -267,6 +271,18 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
         onClose={() => setErfassenOffen(false)}
         initialMode="aufgabe"
       />
+
+      {/* Derselbe Dialog wie im Projektbrett – er kennt seine Aufgabe ueber
+          die ID und braucht das Projekt nur zum Anlegen. */}
+      {bearbeiten ? (
+        <TaskDialog
+          open
+          projectId={bearbeiten.project.id}
+          task={bearbeiten}
+          initialStatus={bearbeiten.status}
+          onClose={() => setBearbeiten(null)}
+        />
+      ) : null}
     </div>
   );
 }
@@ -275,10 +291,12 @@ function TaskRow({
   task,
   busy,
   onToggle,
+  onEdit,
 }: {
   task: TaskOverviewItem;
   busy: boolean;
   onToggle: () => void;
+  onEdit: () => void;
 }) {
   const meta = TASK_STATUS_META[task.status];
   const erledigt = task.status === "DONE";
@@ -303,14 +321,21 @@ function TaskRow({
 
       <div className="min-w-0 flex-1">
         <div className="flex items-center gap-1.5">
-          <span
+          {/* Der Titel oeffnet den Bearbeiten-Dialog. Frueher fuehrte von
+              hier nur der Weg ins Projekt – wer eine Faelligkeit aendern
+              wollte, musste erst dorthin springen und die Aufgabe im Brett
+              wiederfinden. */}
+          <button
+            type="button"
+            onClick={onEdit}
             className={cn(
-              "truncate text-sm",
+              "truncate text-left text-sm transition-colors hover:text-violet-200",
               erledigt ? "text-slate-500 line-through" : "text-slate-100",
             )}
+            title="Aufgabe bearbeiten"
           >
             {task.title}
-          </span>
+          </button>
           {task.recurrence ? (
             <Repeat
               className="h-3 w-3 shrink-0 text-slate-500"

src/components/ui/Modal.tsx

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

src/lib/auth/mfa.ts

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

src/lib/auth/password.test.ts

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

src/lib/auth/password.ts

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

src/lib/auth/session.ts

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

src/lib/changelog.ts

@@ -41,6 +41,100 @@ export const KIND_META: Record<ChangeKind, { label: string; className: string }>
 };
 
 export const CHANGELOG: Release[] = [
+  {
+    version: "1.9.0",
+    date: "2026-08-17",
+    headline: "Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Der Abgleich prüft jetzt den Zustand verknüpfter Issues: was in Git geschlossen " +
+          "wurde, wird in Nebula abgehakt. Bisher konnte das nur der Webhook — war keiner " +
+          "eingerichtet, blieb der Rückweg ganz aus.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Ein über Git geschlossenes Issue bewirkt jetzt dasselbe wie ein Haken in der " +
+          "Oberfläche: bei wiederkehrenden Aufgaben entsteht die nächste Fassung, und der " +
+          "Vorgang steht im Projektverlauf.",
+      },
+    ],
+  },
+  {
+    version: "1.8.0",
+    date: "2026-08-15",
+    headline: "Durchgang durch Anmeldung und Sitzungen nach OWASP.",
+    changes: [
+      {
+        kind: "besser",
+        text:
+          "Passwörter werden deutlich aufwendiger gehasht (scrypt mit N=2^17 statt 2^15) — " +
+          "das entspricht der Empfehlung des OWASP Password Storage Cheat Sheet. Bestehende " +
+          "Passwörter werden bei der nächsten Anmeldung still auf den neuen Stand gebracht.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Die Anmeldung verriet, welche Benutzernamen existieren: gesperrte, deaktivierte " +
+          "und reine Passkey-Konten antworteten anders als unbekannte — und das schon vor " +
+          "der Passwortprüfung. Jetzt gibt es die Auskunft erst, wenn das Passwort stimmt.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Sitzungen laufen nach acht Stunden ohne Nutzung ab, zusätzlich zur bestehenden " +
+          "Frist von 30 Tagen. Einstellbar über SESSION_IDLE_HOURS; 0 schaltet es ab.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Das Sitzungscookie trägt bei HTTPS den Präfix „__Host-“ und gilt nur noch " +
+          "SameSite=Strict. Beides muss einmalig neu angemeldet werden.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Passwortprüfung erkennt jetzt Wiederholungen, Zeichenfolgen und Passwörter, " +
+          "die den eigenen Benutzernamen enthalten.",
+      },
+    ],
+  },
+  {
+    version: "1.7.0",
+    date: "2026-08-15",
+    headline: "Aufgaben und Git-Issues finden zusammen.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Eine Aufgabe lässt sich als Issue im verknüpften Repository anlegen — per Knopf, " +
+          "nie nebenbei. Danach wandert der Zustand mit: erledigt schließt das Issue, ein " +
+          "Zurückziehen öffnet es wieder.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Webhooks. Ein Push aktualisiert den Stand sofort, statt bis zum nächsten " +
+          "Abgleich zu warten; ein geschlossenes Issue hakt seine Aufgabe ab. Einzurichten " +
+          "am Repository — URL und Geheimnis stehen dort bereit.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Auf dem Telefon verdeckte die Bildschirmtastatur den halben Dialog, weil er mit " +
+          "der vollen Fensterhöhe rechnete. Dialoge richten sich jetzt nach dem sichtbaren " +
+          "Bereich und rücken über die Tastatur.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Aufgaben lassen sich in der Übersicht direkt bearbeiten. Bisher führte von dort " +
+          "nur der Weg ins Projekt.",
+      },
+    ],
+  },
   {
     version: "1.6.0",
     date: "2026-08-14",

src/lib/config.ts

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

src/lib/git/gitea.ts

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

src/lib/git/github.ts

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

src/lib/git/gitlab.ts

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

src/lib/git/http.ts

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

src/lib/git/types.ts

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

src/lib/projects.ts

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

src/lib/sync/index.ts

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

src/lib/tasks/issues.test.ts

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

src/lib/tasks/issues.ts

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

src/lib/webhooks/verify.test.ts

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

src/lib/webhooks/verify.ts

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

src/middleware.ts

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

src/types/index.ts

@@ -40,8 +40,14 @@ export interface ConnectionWithCount extends ConnectionSafe {
   _count?: { repositories: number };
 }
 
-/** Ein Repository samt Verbindung und zuletzt geholtem Stand. */
+/**
-export interface RepositoryWithSnapshot extends Repository {
+ * Ein Repository samt Verbindung und zuletzt geholtem Stand.
+ *
+ * Ohne webhookSecret: das Geheimnis verlaesst den Server nicht – siehe
+ * repositorySafeSelect. Ob einer eingerichtet ist, reicht die Projektseite
+ * getrennt durch.
+ */
+export interface RepositoryWithSnapshot extends Omit<Repository, "webhookSecret"> {
   connection: ConnectionSafe | null;
   snapshot: RepoSnapshot | null;
 }
@@ -87,7 +93,8 @@ export interface TaskOverviewItem {
   dueDate: string | null;
   labels: string[];
   recurrence: Recurrence | null;
-  /** Gesetzt, wenn die Aufgabe aus einem Git-Issue stammt. */
+  /** Gesetzt, wenn die Aufgabe an einem Git-Issue haengt. */
+  sourceIssue: number | null;
   sourceUrl: string | null;
   bucket: DueBucket;
   project: { id: string; name: string; accent: string; status: ProjectStatus };