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>

src/lib/tasks/issues.ts

@@ -1,6 +1,9 @@
 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.
@@ -68,3 +71,122 @@ export async function mirrorStatusToIssue(
     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;
+}