Merge: Release v1.11.0

Vier Aenderungen seit 1.10.1, alle bereits auf main. Minor statt Patch,
weil eine neue Funktion dabei ist und zwei Schemaaenderungen mitkommen.

Der Schwerpunkt liegt beim Abgleich, und die drei Punkte dort gehoeren
zusammen: Ein verschluckter Fehler sah aus wie ein leeres Ergebnis (#19),
ueberschrieb dabei den letzten guten Stand (#20), und weil niemand die
Ursache sehen konnte, blieb sie tagelang unentdeckt. Erst als die Fehler
sichtbar waren, liess sich der Rest ueberhaupt benennen: eine Seiten-
groesse, die angefragt statt gemessen wurde (#22), und Zeitueber-
schreitungen, die einen zweiten Versuch verdienen (#23).

Dazu die Karten je Spalte (#16) und das Issue-Kennzeichen (#12) aus den
Fassungen davor.

Verlauf und Versionsnummer wandern zusammen; changelog.test.ts haelt das
fest.

Beim Ausrollen laufen zwei Migrationen mit: taskColumnLimit an
AppSettings und missing/completeAt an RepoSnapshot.

Refs #16
Refs #19
Refs #20
Refs #22
Refs #23

CLAUDE.md

@@ -64,6 +64,41 @@ SSRF-Schutz (`lib/security/ssrf.ts`).
 - **Datumsangaben** über `lib/utils` formatieren (feste Zeitzone), sonst
   weichen Server-Render und Hydration voneinander ab. Relative Zeiten
   bekommen `suppressHydrationWarning`.
+- **Die feste Zeitzone gilt auch beim *Rechnen*, nicht nur beim Formatieren.**
+  Im Container läuft die Anwendung nach UTC; „welcher Kalendertag" und
+  „welche Woche" kippen dort abends um einen Tag. `lib/tasks` (`dueBucket`)
+  und `lib/review` (`wocheUm`) rechnen deshalb über Berliner Kalendertage.
+  Und eine Woche ist **nicht** „7 × 24 Stunden" — bei einer Zeitumstellung
+  hat sie 167 oder 169.
+- **`min-width: auto` bei Flex- und Grid-Kindern.** Hat hier zweimal
+  zugeschlagen: ein Kind weigert sich, unter die Inhaltsbreite seines
+  breitesten Kindes zu schrumpfen, und drückt stattdessen die Nachbarn aus
+  dem Bild. Einmal war es ein Sortierfeld mit `min-width`, das „Neues
+  Projekt" hinausschob; einmal die Heatmap, die die ganze Projektseite
+  doppelt so breit machte. Heilmittel ist beide Male `min-w-0` am Kind —
+  ohne das greift auch ein `overflow-x-auto` darin nicht.
+- **`body { overflow-x: hidden }` versteckt genau diese Fehler.** Es steht in
+  `globals.css` als Notnagel; was es abschneidet, ist auf dem Telefon
+  schlicht nicht mehr erreichbar. Ursachen gehören in die Komponente.
+- **Dialoge müssen der Bildschirmtastatur ausweichen.** Sie verkleinert nur
+  das *sichtbare* Fenster, nicht das Layoutfenster — `position: fixed` und
+  `100vh` beziehen sich weiter auf das volle. `components/ui/Modal.tsx` hängt
+  dafür an `window.visualViewport`; wer ein eigenes Overlay baut, braucht
+  dasselbe.
+- **Ein verschluckter Fehler ist schlimmer als ein lauter.** `getJsonSafe` machte aus
+  jedem Fehlschlag eine leere Liste. Damit war ein 403 nicht mehr von „das Repository
+  hat keine Branches" zu unterscheiden: Der Abgleich meldete Erfolg, überschrieb den
+  letzten guten Stand mit Nullen, und die Ursache war von außen nicht zu ermitteln —
+  die Auskunft, die sie benannt hätte, war ja gerade weggeworfen worden. Wo ein
+  Fallback nötig ist, gehört der Grund festgehalten (`Teilabrufe` in `lib/git/http.ts`).
+- **`Number()` auf einer Umgebungsvariable prüft nichts.** `Number("")` ist `0`,
+  `Number("abc")` ist `NaN`, und `setTimeout` löst bei beidem sofort aus. Eine
+  verrutschte Zeile in der `.env` konnte so den kompletten Abgleich stilllegen, ohne
+  dass irgendwo etwas stand.
+- **Blättern über Cursor, nicht über `skip`.** Der Aktivitätsverlauf schreibt
+  mehrere Zeilen im selben Augenblick; ein Offset über so eine Grenze hinweg
+  überspringt oder verdoppelt lautlos. Muster in `lib/timeline.ts`:
+  `(createdAt, id)` als Cursor, Sortierung identisch zur Bedingung.
 
 ## Migrationen
 
@@ -83,9 +118,24 @@ vergleicht mit der *laufenden* Datenbank. Ist eine eben erzeugte Migration
 dort noch nicht eingespielt, steht ihr Inhalt in der nächsten gleich noch
 einmal.
 
-**Die erzeugte SQL vor dem Anwenden lesen.** Der Volltextindex
+**Das Zielverzeichnis vorher *nicht* anlegen.** Ein leerer Ordner unter
-`Note_fulltext_idx` ist ein Ausdrucksindex, den Prisma nicht kennt (er wird
+`prisma/migrations/` lässt `--from-migrations` mit `P3015` abbrechen
-bislang in Ruhe gelassen, aber das ist nicht garantiert).
+(„Could not find the migration file"). Erst die SQL woandershin erzeugen,
+dann Ordner anlegen und hineinkopieren.
+
+**Die erzeugte SQL vor dem Anwenden lesen.** Die Volltextindizes
+`Note_fulltext_idx` und `Task_fulltext_idx` sind Ausdrucksindizes, die Prisma
+nicht kennt (sie werden bislang in Ruhe gelassen, aber das ist nicht
+garantiert).
+
+**Ein Ausdrucksindex greift nur bei Zeichengleichheit.** Weicht der Ausdruck
+in der Abfrage auch nur in einem `coalesce` vom Index ab, rechnet Postgres
+`to_tsvector` je Zeile neu — ohne Fehlermeldung. Nachsehen statt annehmen:
+
+```bash
+docker exec nebula-db psql -U nebula -d <db> -c "SET enable_seqscan = off;
+EXPLAIN (COSTS OFF) SELECT …"    # muss einen Bitmap Index Scan zeigen
+```
 
 **Datenmigrationen von Hand schreiben.** `migrate diff` kennt nur den
 Zielzustand: Spalten, die woandershin wandern, würde es ersatzlos löschen.
@@ -103,6 +153,18 @@ Bei Änderungen an der Oberfläche **hinsehen**. Chrome ist installiert, ein
 Skript mit `playwright-core` und `channel: "chrome"` genügt für Screenshots.
 Mehrere Anzeigefehler dieses Projekts sind ausschließlich so aufgefallen.
 
+**Seitlichen Überlauf misst man.** `document.documentElement.scrollWidth`
+gegen `clientWidth` auf 375 px — das findet in Sekunden, was beim Ansehen
+durchrutscht. Ein Skript, das dabei nur die *obersten* Verursacher meldet
+(Eltern, die selbst schon überlaufen, herausfiltern), ist deutlich brauchbarer
+als eine Liste aller betroffenen Knoten.
+
+**Die Testdaten müssen die Bausteine enthalten, um die es geht.** Eine
+Messung gegen ein Projekt ohne Repository, ohne Snapshot und ohne README
+bescheinigte hier einmal „alles in Ordnung", während die echte Projektseite
+doppelt so breit war wie der Bildschirm. Erst mit vollständigen Daten
+nachgestellt trat der Fehler zutage.
+
 **Barrierefreiheit misst man, statt sie zu behaupten.** `axe-core` liegt als
 Entwicklungsabhängigkeit bereit; ein Skript hängt es per `addScriptTag` in
 die laufende Seite und ruft `axe.run` mit den WCAG-Tags auf. Jeder

DEPLOYMENT.md

@@ -283,6 +283,23 @@ Zurückspielen:
 
 ## Updates
 
+Es sind zwei getrennte Orte, und das ist der Punkt, an dem es leicht
+durcheinandergeht:
+
+| | Was dort liegt |
+| --- | --- |
+| **Das Git-Repository** | Der Quellcode. Dorthin wird entwickelt. |
+| **Diese Instanz** | Die laufende Anwendung, die du im Browser benutzt. |
+
+Ein Commit im Git ändert am laufenden Nebula **nichts**. Der Server holt sich
+von allein nichts ab; er betreibt weiter die Fassung, die dort zuletzt gebaut
+wurde. Ein Update ist der Schritt dazwischen: holen, bauen, umschalten.
+
+**Woran du siehst, was gerade läuft:** die Versionsnummer unten in der
+Fußzeile. Ein Klick darauf öffnet den Änderungsverlauf. Steht dort eine
+ältere Nummer als im Git, fehlen dir die neueren Funktionen — sie sind
+geschrieben, aber noch nicht auf diesem Server.
+
 Dafür gibt es `scripts/update.sh`. Es macht alles in der richtigen
 Reihenfolge und bricht ab, sobald ein Schritt scheitert:
 
@@ -308,7 +325,7 @@ nennt den Weg zurück.
 
 ```bash
 ./scripts/update.sh --yes            # ohne Rückfrage, für Cron
-./scripts/update.sh --ref v1.4.0     # auf eine bestimmte Fassung
+./scripts/update.sh --ref v1.9.0     # auf eine bestimmte Fassung
 ./scripts/update.sh --no-pull        # nur neu bauen, ohne git pull
 ```
 
@@ -354,6 +371,23 @@ docker system df
 docker image prune -f          # alte Abbilder nach mehreren Updates
 ```
 
+### Webhooks
+
+Der Abgleich holt den Stand in seinem Takt. Wer ihn **sofort** haben will —
+ein Push ist durch, ein Issue wurde geschlossen —, trägt im Git-System einen
+Webhook ein. Nebula erzeugt URL und Geheimnis am Repository (Funksymbol im
+Git-Bereich der Projektseite), eingetragen wird der Haken von Hand.
+
+Voraussetzung ist, dass **dein Git-System diese Instanz erreicht**. Hinter
+dem Reverse Proxy ist das gegeben; in einem abgeschotteten Netz nicht. Der
+Endpunkt liegt unter `/api/webhooks/<repositoryId>` und ist der einzige ohne
+Anmeldung — ausgewiesen wird sich über eine Signatur, die gegen das
+hinterlegte Geheimnis geprüft wird.
+
+**Ohne Webhook geht nichts verloren.** Der Abgleich prüft den Zustand
+verknüpfter Issues ohnehin mit und hakt erledigte Aufgaben nach. Der Webhook
+macht es nur sofort statt beim nächsten Durchlauf.
+
 ### Automatischer Abgleich
 
 Standardmäßig **aus**. Einzuschalten unter *Admin-Einstellungen →
@@ -383,6 +417,13 @@ Damit du weißt, worum du dich **nicht** kümmern musst:
   Zugriffe; Kontosperre nach acht Fehlversuchen.
 - **Git-Tokens** liegen AES-256-GCM-verschlüsselt in der Datenbank und
   verlassen den Server nie — auch nicht im Export.
+- **Sitzungen** laufen nach 8 Stunden ohne Nutzung ab und spätestens nach
+  30 Tagen (`SESSION_IDLE_HOURS`, `SESSION_TTL_DAYS`). In der Datenbank liegt
+  nur der Hash des Tokens; das Cookie ist `HttpOnly`, `SameSite=Strict` und
+  bei HTTPS zusätzlich mit dem Präfix `__Host-`.
+- **Passwörter** werden mit scrypt nach der Empfehlung des OWASP Password
+  Storage Cheat Sheet gehasht (N = 2^17). Rechnet mit rund einer halben
+  Sekunde je Anmeldung — das ist gewollt.
 - Der **Bildoptimierer** von Next ist abgeschaltet: Nebula benutzt ihn nicht,
   und `/_next/image` wäre sonst eine Angriffsfläche ohne Gegenwert.
 

FEATURES.md

@@ -145,12 +145,17 @@ dort wäre er auf schmalen Anzeigen mit der Auswahlleiste kollidiert.
   Favoriten bleiben stets oben.
 - **Vier Ansichten**: freies Raster, **kompakte Liste**, nach Status gruppierte Abschnitte
   oder **Kanban**.
-- **Volltextsuche über Notizen.** Die Suche im Board arbeitet auf den geladenen Projekten
+- **Volltextsuche über Notizen und Aufgaben.** Die Suche im Board arbeitet auf den
-  (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen liegen dort nicht vor — sie
+  geladenen Projekten (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen und Aufgaben
-  mitzuladen würde die Seite aufblähen. Stattdessen sucht Postgres serverseitig mit
+  liegen dort nicht vor — sie mitzuladen würde die Seite aufblähen. Stattdessen sucht
-  seiner deutschen Textsuche, entprellt ab zwei Zeichen. Treffer erscheinen als eigene
+  Postgres serverseitig mit seiner deutschen Textsuche, entprellt ab zwei Zeichen.
-  Liste mit hervorgehobener Fundstelle, die betroffenen Projekte werden zusätzlich
+  Treffer erscheinen als zwei eigene Listen mit hervorgehobener Fundstelle, die
-  eingeblendet. Deutsche Stammformen greifen: „Webhook" findet auch „Webhooks".
+  betroffenen Projekte werden zusätzlich eingeblendet. Deutsche Stammformen greifen:
+  „Webhook" findet auch „Webhooks", „Rechnung" auch „Rechnungen".
+
+  Beide Seiten haben je einen **Ausdrucksindex** (`Note_fulltext_idx`,
+  `Task_fulltext_idx`). Der Ausdruck darin muss Zeichen für Zeichen dem in der Abfrage
+  entsprechen, sonst greift er nicht und Postgres rechnet `to_tsvector` je Zeile neu.
 - **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
 - **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.
 
@@ -250,6 +255,23 @@ Blockiert · Erledigt**.
   Fälligkeitsdatum und Labels.
 - **Fälligkeiten** färben sich mit: überfällig rot, heute gelb, in den nächsten Tagen
   gedämpft.
+- **Hängt ein Git-Issue daran**, trägt die Karte dessen Nummer — vorn in der Fußzeile,
+  vor Beschreibung, Wiederholung, Frist und Labels, damit sich eine Spalte danach
+  überfliegen lässt. Bewusst kein Link: der Weg zum Issue führt über den Dialog (4.6),
+  weil ein `<a>` innerhalb der anklickbaren Karte ungültiges Markup wäre.
+
+#### Wie viele Karten eine Spalte zeigt
+
+Eine Spalte zeigt höchstens so viele Karten, wie unter *Admin-Einstellungen →
+Aufgabenbrett* eingestellt ist (Voreinstellung 15, `0` schaltet die Begrenzung ab). Was
+darüber hinausgeht, steht hinter einem Knopf „*n* weitere anzeigen"; entfaltet wird je
+Spalte einzeln. Die Zahl neben der Spaltenüberschrift nennt weiterhin den **vollen**
+Bestand — sonst wäre nicht zu erkennen, dass etwas fehlt.
+
+**Begrenzt wird nur die Anzeige.** Das Umsortieren schickt je Spalte die vollständige
+Liste an den Server; würde hier schon gekürzt, fielen die verborgenen Aufgaben beim
+nächsten Ziehen aus dem Brett. Die Einstellung ist deshalb bewusst eine Sache der
+Darstellung und keine der Abfrage — geladen wird ohnehin das ganze Projekt.
 - Erledigtes wird durchgestrichen; der Zeitpunkt wird festgehalten und beim Zurückziehen
   wieder gelöscht.
 
@@ -341,6 +363,54 @@ Die Aufgabe kennt keinen Besitzer — die Trennung läuft über das Projekt
 
 ---
 
+## 2c. Rückblick und Verlauf
+
+Zwei Sichten auf denselben Aktivitätsverlauf, über alle Projekte hinweg. Beide teilen
+sich Zeilendarstellung und Tagesgruppierung (`components/ActivityRow`) — zwei Kopien
+wären beim nächsten Feinschliff auseinandergelaufen.
+
+Der Verlauf kennt keinen Besitzer; die Trennung läuft über das Projekt
+(`project: { ownerId }` als erste Bedingung).
+
+### Wochenrückblick
+
+`/rueckblick` beantwortet „was ist diese Woche passiert". Oben Kennzahlen — Vorgänge,
+berührte Projekte, erledigte und neue Aufgaben —, darunter die Vorgänge nach
+Kalendertagen gebündelt, neuester Tag zuerst. Über `?woche=-n` geht es bis zu 25 Wochen
+zurück; weiter lohnt nicht, weil der Verlauf ohnehin nur 200 Einträge je Projekt hält.
+
+**Gerechnet wird auf Kalendertage in fester Zeitzone** (Europe/Berlin), nicht auf
+„sieben mal 24 Stunden": liegt eine Zeitumstellung in der Woche, hat sie 167 oder 169
+Stunden. Und im Container läuft die Anwendung nach UTC — ein Eintrag von Sonntagabend
+fiele sonst in die falsche Woche. Das Fach bestimmt der **Server**, damit Server-Render
+und Hydration nicht auseinanderlaufen.
+
+**„Aufgaben erledigt" wird am `meta`-Feld abgelesen** (`to: "DONE"`), nicht am
+Anzeigetext. Der Text ist zum Lesen da und ändert sich mit der Formulierung; eine
+Zählung daran würde beim nächsten umformulierten Einzeiler unbemerkt kippen. Einträge
+ohne `meta` zählen nicht mit — lieber untertreiben als raten.
+
+### Globale Zeitleiste
+
+`/verlauf` zeigt denselben Verlauf **fortlaufend**: ohne Wochengrenze, ohne Fazit, mit
+„Ältere laden". Die erste Seite kommt serverseitig mit, alles Weitere über
+`/api/activity`.
+
+**Geblättert wird per Cursor** über `(createdAt, id)`, nicht per `skip`. Der Verlauf
+schreibt mehrere Einträge im selben Augenblick — beim Übernehmen von Issues entstehen
+zehn Zeilen mit identischem Zeitstempel. Ein Offset über eine solche Grenze hinweg
+überspringt Zeilen oder zeigt sie zweimal, und zwar lautlos. Der zweite Zweig der
+Bedingung (gleicher Zeitpunkt, kleinere ID) fängt genau das ab.
+
+Nachgerechnet gegen 144 Einträge mit absichtlichen Blöcken gleicher Zeitstempel: 15
+Seiten, 144 Zeilen, keine Dublette, streng absteigend.
+
+Beide Seiten sind über die Schnellsuche erreichbar, der Rückblick zusätzlich über einen
+Verweis vom Dashboard. Bewusst **kein** weiterer Punkt in der Kopfleiste — die ist auf
+dem Telefon schon eng.
+
+---
+
 ## 3. Notizen
 
 - **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
@@ -432,6 +502,40 @@ Firmen-Gitea nebeneinander.
   Kurzbeschreibung.
 - **Löschen** trennt nur die Verknüpfung; die Projekte selbst bleiben erhalten.
 
+#### Nötige Token-Rechte
+
+Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: `POST …/issues`
+beim Anlegen und `PATCH`/`PUT …/issues/{nr}` beim Schließen oder Wiederöffnen (4.6). Wer
+darauf verzichtet, kommt mit einem rein lesenden Token aus.
+
+| System | Nur Abgleich | Zusätzlich für die Issue-Anbindung |
+| --- | --- | --- |
+| GitHub | *Metadata*, *Contents*, *Issues*, *Pull requests*, *Actions* — je lesend | *Issues: Read and write* |
+| GitLab | `read_api` | `api` |
+| Gitea / Forgejo | `read:repository`, `read:issue`, `read:user` | `write:issue` |
+
+Welcher Aufruf welches Recht verlangt, steht Zeile für Zeile in der
+[README](README.md#welche-rechte-der-token-braucht) — dort ist jeder ausgehende Aufruf
+der drei Clients aufgeführt.
+
+**GitLab kennt keinen schmalen Schreib-Scope.** `api` erlaubt alles, was das Konto darf,
+Code eingeschlossen. Wem das zu weit geht, bleibt bei `read_api`: der Abgleich läuft
+vollständig, geschlossene Issues werden weiterhin erkannt — nur schreibt Nebula dann
+nicht zurück.
+
+**Nicht verlangt** werden Schreibrechte auf Code, Adminrechte und Rechte zum Anlegen von
+Webhooks. Der Haken wird von Hand im Git-System eingetragen (4.7); das erspart dem Token
+genau die Administrationsrechte, die er sonst bräuchte.
+
+**Kommentare schreibt Nebula nie** — weder beim Anlegen noch beim Schließen. In den
+Rumpf des angelegten Issues wandert die Aufgabenbeschreibung plus eine Zeile Rückverweis
+auf das Projekt; danach bleibt der Text unangetastet. Was sonst an Kommentaren und
+Labels an einem Issue hängt, kommt aus der Weboberfläche oder von einem anderen Werkzeug.
+
+Ein fehlendes Recht endet in einem `403` mit „Token hat nicht die noetigen Scopes",
+sichtbar am Repository auf der Projektseite. Klein anfangen und gezielt nachlegen ist
+deshalb ohne Risiko.
+
 ### 4.3 Was beim Sync geholt wird
 
 | Bereich | Details |
@@ -449,6 +553,42 @@ Firmen-Gitea nebeneinander.
 | Releases | bis zu 10, inklusive Pre-Release- und Draft-Kennzeichnung |
 | Sprachen | Verteilung als Balken mit Prozentwerten |
 
+#### Wenn ein Teil nicht ankommt
+
+Diese Listen werden gleichzeitig geholt, und einzelne davon können scheitern, während
+der Rest durchgeht — ein 403 wegen fehlender Scopes, ein Rate-Limit, eine
+Zeitüberschreitung.
+
+**Ein zweiter Versuch, bevor etwas als fehlend gilt.** Zeitüberschreitungen und
+Verbindungen, die gar nicht zustande kamen, werden einmal nachgeschlagen — einzeln
+statt im Schwung, weil genau das der beobachtete Fall war: zwei von acht Aufrufen
+liefen in eine Zeitüberschreitung nach 15 Sekunden, während dieselben Aufrufe einzeln
+in 80 Millisekunden antworteten. Nachgeschlagen wird höchstens zweimal je Abgleich —
+acht Zeitüberschreitungen hintereinander wären zwei Minuten. Bei `403`, `404` und `429`
+gibt es keinen zweiten Versuch: fehlende Rechte werden durch Wiederholen nicht besser,
+ein Rate-Limit wird schlimmer.
+
+**Ein gescheiterter Abruf ist keine leere Liste.** Der Unterschied steht am Snapshot: zu
+jedem Feld, das nicht geholt werden konnte, wird der Grund samt HTTP-Status festgehalten.
+Daraus folgt dreierlei:
+
+- Die vorhandenen Daten **bleiben stehen**. Ein Abgleich, der die Tags nicht holen konnte,
+  ersetzt die gespeicherten nicht durch eine leere Liste. Angezeigt wird dann der letzte
+  vollständige Stand, mit Datum.
+- Die Meldung heißt „Teilweise aktualisiert – nicht geholt: …" statt „Snapshot
+  aktualisiert: 0 Branches, 0 Tags".
+- Auf der Projektseite steht ein Hinweis am Repository, der jedes fehlende Feld mit
+  seinem Grund nennt.
+
+Das gilt ausdrücklich **nicht** als Fehlschlag: `syncError` bleibt leer, der Zähler für
+das Zurückhalten wird nicht erhöht, und der nächste Durchlauf versucht es normal wieder.
+Der Rest des Standes ist ja frisch.
+
+> Vor v1.11.0 wurde jeder Fehlschlag in eine leere Liste verwandelt. Ein Repository mit
+> 65 Commits meldete „Snapshot aktualisiert: 0 Branches, 0 Tags", überschrieb dabei den
+> letzten guten Stand, und aus der Oberfläche war nicht zu erkennen, dass überhaupt etwas
+> schiefgegangen war.
+
 Woher der CI-Status kommt:
 
 | System | Quelle |

README.md

@@ -1,11 +1,11 @@
+![Nebula — Projekt-Kontrollzentrum, self-hosted. Alle deine halbfertigen Projekte, ein Kontrollzentrum: Ideen, Status, Notizen und Live-Daten aus deinen Git-Repos, gebündelt an einem Ort auf deinem eigenen Server. Drei Git-Provider (GitHub, GitLab, Gitea), Aufgaben und Issues in beide Richtungen, Passkeys und Zwei-Faktor, Daten in deiner eigenen PostgreSQL.](docs/banner.png)
+
 <div align="center">
 
 # ✦ Nebula
 
 **Das Kontrollzentrum für deine Vibe-Coding Projekte.**
 
-Ideen festhalten · Status pflegen · Notizen sammeln · Git-Repos live im Blick
-
 <sub>Next.js 15 · TypeScript · Tailwind CSS 4 · Prisma · PostgreSQL · Docker</sub>
 
 </div>
@@ -22,6 +22,12 @@ Jedes Projekt bekommt einen **Status** (von der rohen Idee bis „Fertig"), beli
 Branches, Tags, Commits, Releases und offene Issues/PRs — egal ob **GitHub**, **GitLab**
 oder eine selbst gehostete **Gitea**-Instanz.
 
+Neben dem Projektbrett gibt es **Aufgaben über alle Projekte hinweg** (nach Fälligkeit
+geordnet), einen **Wochenrückblick** und eine **fortlaufende Zeitleiste** aus dem
+Aktivitätsverlauf. Aufgaben lassen sich als **Git-Issue** anlegen; wird das Issue
+geschlossen, hakt Nebula die Aufgabe ab — sofort per **Webhook** oder verzögert beim
+nächsten Abgleich.
+
 Die Anmeldung läuft über **Benutzername und Passwort oder Passkey** (WebAuthn). Nebula
 kennt zwei Betriebsarten: **Einzelbetrieb** für ein Konto oder **Mehrbenutzerbetrieb**, in
 dem jede Person ihren eigenen, streng getrennten Bereich hat. Umschalten geht jederzeit in
@@ -125,7 +131,7 @@ Alle Variablen sind in [`.env.example`](.env.example) dokumentiert.
 | `POSTGRES_USER` / `POSTGRES_PASSWORD` / `POSTGRES_DB` | Zugangsdaten des DB-Containers | `nebula` |
 | `POSTGRES_PORT` | Host-Port der Datenbank — wirkt nur mit `docker-compose.dev.yml`, sonst hat die DB keinen | `127.0.0.1:5432` |
 | `ADMINER_PORT` | Host-Port von Adminer (`--profile tools`) | `127.0.0.1:8080` |
-| `GIT_API_TIMEOUT_MS` | Timeout für Git-API-Aufrufe | `15000` |
+| `GIT_API_TIMEOUT_MS` | Timeout für Git-API-Aufrufe, in Millisekunden. Alles unter 1000 oder Unlesbares wird verworfen (mit Warnung im Log) — sonst bräche jeder Aufruf sofort ab | `15000` |
 | `GIT_ALLOW_LOOPBACK` | Git-Instanz auf demselben Rechner erlauben | `false` |
 | `GIT_BLOCK_PRIVATE` | Zugriff ins private LAN sperren | `false` |
 | `GIT_ALLOWED_HOSTS` | Strengster Modus: nur diese Hosts erlauben | leer |
@@ -167,14 +173,8 @@ Nebula auffindbare Credentials nutzt.
 
 ## Git-Verbindung einrichten
 
-1. Im Git-System einen **Personal Access Token** mit Leserechten erzeugen:
+1. Im Git-System einen **Personal Access Token** erzeugen — mit den Rechten aus dem
-
+   Abschnitt [Welche Rechte der Token braucht](#welche-rechte-der-token-braucht).
-   | System | Scopes |
-   | --- | --- |
-   | GitHub | Fine-grained Token: *Contents: Read*, *Metadata: Read*, *Issues: Read*, *Pull requests: Read* |
-   | GitLab | `read_api` (alternativ `read_repository`) |
-   | Gitea / Forgejo | `repository:read`, `issue:read`, `user:read` |
-
 2. In Nebula unter **Git-Verbindungen → Verbindung hinzufügen** eintragen:
    System wählen, Basis-URL (z. B. `https://git.meine-firma.de`, ohne `/api`) und Token.
 3. Mit **Testen** prüfen — Nebula meldet den erkannten Benutzer zurück.
@@ -186,6 +186,132 @@ Nebula auffindbare Credentials nutzt.
 Der Snapshot bleibt in der Datenbank, das Dashboard funktioniert also auch offline.
 Ohne Token gehen nur öffentliche Repositories, mit strengem Rate-Limit.
 
+### Welche Rechte der Token braucht
+
+Nebula liest fast alles nur. Geschrieben wird an **genau zwei Stellen**: wenn du eine
+Aufgabe als Issue anlegst, und wenn eine Aufgabe auf `DONE` wandert und Nebula das
+verknüpfte Issue schließt. Alles andere sind `GET`-Aufrufe. Deshalb lohnt es, zwei Fälle
+zu unterscheiden:
+
+**Fall A — nur Abgleich.** Branches, Tags, Commits, Releases, CI-Zustand, README,
+Heatmap, offene Issues und PRs anzeigen. Rein lesend.
+
+**Fall B — zusätzlich die Issue-Anbindung.** Eine Aufgabe als Issue anlegen; wird das
+Issue geschlossen, hakt Nebula die Aufgabe ab und schließt sie umgekehrt mit.
+
+| System | Fall A (nur lesen) | Fall B zusätzlich |
+| --- | --- | --- |
+| **GitHub** | Fine-grained Token: *Metadata: Read*, *Contents: Read*, *Issues: Read*, *Pull requests: Read*, *Actions: Read* | *Issues: **Read and write*** |
+| **GitLab** | `read_api` | `api` — **es gibt nichts dazwischen** |
+| **Gitea / Forgejo** | `read:repository`, `read:issue`, `read:user` | `write:issue` |
+
+#### Jeder Aufruf einzeln
+
+Die folgenden Tabellen sind vollständig: mehr als das ruft Nebula nicht nach draußen.
+Sie sind aus `src/lib/git/github.ts`, `gitlab.ts` und `gitea.ts` erhoben — wer prüfen
+will, ob hier etwas fehlt, greppt dort nach `getJson`, `getJsonSafe` und `sendJson`.
+
+**GitHub** — `https://api.github.com`, Header `Authorization: Bearer …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /rate_limit` | Verbindungstest | keins |
+| `GET /user` | Kontoname beim Testen zurückmelden | keins |
+| `GET /user/repos` | Auswahlliste hinter **Repos laden** | Metadata: Read |
+| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | Metadata: Read |
+| `GET …/languages` | Sprachverteilung | Metadata: Read |
+| `GET …/tags` | Tags | Metadata: Read |
+| `GET …/stats/commit_activity` | Commit-Heatmap über ein Jahr | Metadata: Read |
+| `GET …/branches` | Branch-Liste | Contents: Read |
+| `GET …/commits` | die letzten 100 Commits | Contents: Read |
+| `GET …/releases` | Releases | Contents: Read |
+| `GET …/readme` | README-Vorschau | Contents: Read |
+| `GET …/pulls?state=open` | offene Pull Requests | Pull requests: Read |
+| `GET …/issues?state=open` | offene Issues | Issues: Read |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | Issues: Read |
+| `GET …/actions/runs` | CI-Zustand des Default-Branch | Actions: Read |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | Issues: Read and write |
+| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | Issues: Read and write |
+
+Dass `/tags` und `/stats/commit_activity` unter *Metadata* fallen und nicht unter
+*Contents*, ist nicht zu erraten — es steht so in
+[GitHubs Berechtigungsübersicht](https://docs.github.com/en/rest/authentication/permissions-required-for-fine-grained-personal-access-tokens).
+
+**GitLab** — `{Basis-URL}/api/v4`, Header `PRIVATE-TOKEN: …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /projects?per_page=1` | Verbindungstest | `read_api` |
+| `GET /user` | Kontoname beim Testen zurückmelden | `read_user` (in `read_api` enthalten) |
+| `GET /projects?membership=true` | Auswahlliste hinter **Repos laden** | `read_api` |
+| `GET /projects/{id}?statistics=true` | Stammdaten, Default-Branch, Sichtbarkeit | `read_api` |
+| `GET …/repository/branches` · `/tags` · `/commits` | Snapshot und Heatmap | `read_api` |
+| `GET …/repository/tree` · `/repository/files/{datei}` | README (zwei Aufrufe, GitLab hat keinen README-Endpunkt) | `read_api` |
+| `GET …/releases` · `/languages` | Releases, Sprachverteilung | `read_api` |
+| `GET …/merge_requests?state=opened` | offene Merge Requests | `read_api` |
+| `GET …/issues?state=opened` | offene Issues | `read_api` |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read_api` |
+| `GET …/pipelines` | CI-Zustand des Default-Branch | `read_api` |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | `api` |
+| `PUT …/issues/{nr}` (`state_event`) | **Issue schließen oder wieder öffnen** | `api` |
+
+**Gitea / Forgejo** — `{Basis-URL}/api/v1`, Header `Authorization: token …`
+
+| Aufruf | Wofür | Benötigtes Recht |
+| --- | --- | --- |
+| `GET /version` | Verbindungstest | keins — der Aufruf darf fehlschlagen, Nebula wertet ihn nur ergänzend aus |
+| `GET /user` | Kontoname beim Testen zurückmelden | `read:user` |
+| `GET /user/repos` bzw. `GET /repos/search` | Auswahlliste hinter **Repos laden** | `read:repository` |
+| `GET /repos/{o}/{r}` | Stammdaten, Default-Branch, Sichtbarkeit | `read:repository` |
+| `GET …/branches` · `/tags` · `/commits` · `/releases` · `/languages` | Snapshot und Heatmap | `read:repository` |
+| `GET …/contents` · `/contents/{datei}` | README (zwei Aufrufe, wie bei GitLab) | `read:repository` |
+| `GET …/commits/{branch}/status` | CI-Zustand des Default-Branch | `read:repository` |
+| `GET …/pulls?state=open` | offene Pull Requests | `read:repository` — Gitea zählt PRs zum Repository-Scope, nicht zu den Issues |
+| `GET …/issues?state=open&type=issues` | offene Issues | `read:issue` |
+| `GET …/issues/{nr}` | Abgleich: ist das verknüpfte Issue noch offen? | `read:issue` |
+| `POST …/issues` | **Aufgabe als Issue anlegen** | `write:issue` |
+| `PATCH …/issues/{nr}` | **Issue schließen oder wieder öffnen** | `write:issue` |
+
+`write:issue` schließt `read:issue` mit ein — Gitea versteht `write:` als „lesen und
+schreiben". Beide anzuhaken schadet nicht, nötig ist es nicht.
+
+#### Was Nebula nicht tut
+
+- **Keine Kommentare.** Nebula schreibt nie einen Issue-Kommentar, weder beim Anlegen
+  noch beim Schließen. Was im Rumpf des angelegten Issues steht, ist die
+  Aufgabenbeschreibung plus eine Zeile Rückverweis — danach fasst Nebula den Text
+  nicht mehr an.
+- **Kein Code.** Nichts wird committet, gepusht, gemergt oder getaggt. Nebula ist eine
+  Übersicht, keine Entwicklungsumgebung.
+- **Keine Webhooks anlegen.** Den Haken trägst du selbst im Git-System ein — genau
+  deshalb verlangt Nebula dafür keine Administrationsrechte.
+- **Keine Labels, keine Meilensteine, keine Zuweisungen.**
+- **Keine Adminrechte**, keine Organisations- oder Benutzerverwaltung.
+
+Kommentare und Labels, die an einem Issue hängen, stammen also entweder aus der
+Weboberfläche deines Git-Systems oder von einem anderen Werkzeug mit eigenem Token —
+nicht von Nebula.
+
+#### Der GitLab-Sonderfall
+
+GitLab kennt keinen schmalen Schreib-Scope für Issues. Laut
+[Access token scopes](https://docs.gitlab.com/security/tokens/access_token_scopes/)
+gibt es nur `api` — „complete read and write access to the API" — und darunter direkt
+`read_api`. Wer bei GitLab Aufgaben als Issue anlegen will, vergibt damit ein Token, das
+auch Code ändern darf.
+
+Wenn dir das zu weit geht: bleib bei `read_api` und verzichte auf die Issue-Anbindung.
+Der Abgleich läuft vollständig, und geschlossene Issues werden weiterhin erkannt und
+haken ihre Aufgabe ab — nur der Rückweg von Nebula ins Issue fällt weg. Ein eigenes
+Dienstkonto, das nur Zugriff auf die betroffenen Projekte hat, ist der andere Ausweg.
+
+#### Im Zweifel klein anfangen
+
+Ein fehlendes Recht führt zu einem `403` mit dem Hinweis „Token hat nicht die noetigen
+Scopes"; die Meldung steht am Repository auf der Projektseite. Fang mit Fall A an und
+leg gezielt nach, wenn du die Issue-Anbindung wirklich benutzt — statt vorsorglich
+alles zu vergeben.
+
 ### Automatisch statt auf Knopfdruck
 
 Unter **Admin-Einstellungen → Automatischer Abgleich** lässt sich der Sync in den
@@ -264,6 +390,7 @@ Container aus — auf dem Rechner selbst muss nichts installiert sein.
 
 ```
 nebula/
+├── docs/banner.png             Titelbild dieser Datei
 ├── docker/entrypoint.sh        Migrationen + Serverstart im Container
 ├── docker-compose.yml          db (immer) · app (--profile full) · adminer (--profile tools)
 ├── Dockerfile                  Multi-Stage-Build auf Basis des Next-Standalone-Outputs
@@ -275,15 +402,25 @@ nebula/
 └── src/
     ├── app/
     │   ├── page.tsx            Dashboard (Board, Filter, Kennzahlen)
-    │   ├── projects/[id]/      Projektdetail: Beschreibung, Notizen, Git
+    │   ├── projects/[id]/      Projektdetail: Beschreibung, Notizen, Aufgaben, Git
+    │   ├── tasks/              Aufgaben über alle Projekte, nach Fälligkeit
+    │   ├── rueckblick/         Wochenrückblick
+    │   ├── verlauf/            Fortlaufende Zeitleiste
     │   ├── connections/        Verwaltung der Git-Verbindungen
-    │   └── api/                REST-Endpunkte (Projekte, Notizen, Verbindungen, Sync)
+    │   ├── account/ admin/     Eigenes Konto · Adminbereich
+    │   └── api/                REST-Endpunkte (siehe Abschnitt „API")
     ├── components/             UI-Komponenten (Board, Karten, Panels, Dialoge)
     ├── lib/
+    │   ├── auth/               Sitzungen, Passwörter, TOTP, WebAuthn, Zugriffsschutz
     │   ├── crypto.ts           AES-256-GCM für Access Tokens
     │   ├── db.ts               Prisma-Client
     │   ├── git/                Provider-Adapter: github.ts · gitlab.ts · gitea.ts
-    │   ├── sync.ts             Repo-Snapshot holen und speichern
+    │   ├── sync/               Repo-Snapshot holen, speichern, Zeitgeber
+    │   ├── tasks/              Aufgabenlogik, Brücke zu Git-Issues
+    │   ├── webhooks/           Signaturprüfung eingehender Webhooks
+    │   ├── review.ts           Wochengrenzen und Kennzahlen
+    │   ├── timeline.ts         Cursor-Blättern für den Verlauf
+    │   ├── security/           SSRF-Schutz, Ratenbegrenzung, Body-Prüfung
     │   └── validation.ts       Zod-Schemas für alle Eingaben
     └── types/                  gemeinsame Typen für Server und Client
 ```
@@ -347,7 +484,8 @@ ausschließlich Daten des angemeldeten Kontos.
 | `PATCH` `DELETE` | `/api/templates/:id` | Vorlage ändern / löschen |
 | `POST` | `/api/templates/from-project` | Aus einem Projekt eine Vorlage machen |
 | `GET` | `/api/admin/backup` | Vollständige Sicherung als JSON (Admin) |
-| `GET` | `/api/search?q=` | Volltextsuche über die eigenen Notizen |
+| `GET` | `/api/search?q=` | Volltextsuche über eigene Notizen **und Aufgaben** |
+| `GET` | `/api/activity` | Verlauf über alle Projekte, per Cursor (`?vor=&id=&limit=`) |
 | `GET` `POST` | `/api/notifications` | Benachrichtigungsziele |
 | `PATCH` `DELETE` | `/api/notifications/:id` | Ziel ändern / entfernen |
 | `POST` | `/api/notifications/:id/test` | Testnachricht senden |
@@ -359,10 +497,13 @@ ausschließlich Daten des angemeldeten Kontos.
 | `GET` `POST` | `/api/projects/:id/repositories` | Repositories des Projekts |
 | `PATCH` `DELETE` | `/api/repositories/:id` | Repository ändern / vom Projekt lösen |
 | `POST` | `/api/repositories/:id/sync` | Ein einzelnes Repository abgleichen |
+| `POST` `DELETE` | `/api/repositories/:id/webhook` | Webhook einrichten / zurücknehmen |
+| `POST` | `/api/webhooks/:repositoryId` | **Eingehend** von GitHub/GitLab/Gitea, per Signatur geprüft |
 | `GET` `POST` | `/api/projects/:id/tasks` | Aufgaben des Projekts |
 | `PATCH` | `/api/projects/:id/tasks/reorder` | Neue Reihenfolge nach dem Ziehen |
 | `POST` | `/api/projects/:id/tasks/from-issues` | Offene Issues als Aufgaben übernehmen |
 | `PATCH` `DELETE` | `/api/tasks/:id` | Aufgabe ändern / löschen |
+| `POST` | `/api/tasks/:id/issue` | Aufgabe als Issue im verknüpften Repository anlegen |
 | `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
 | `PATCH` `DELETE` | `/api/notes/:id` | Notiz ändern / löschen |
 | `GET` `POST` | `/api/connections` | Git-Verbindungen |
@@ -434,17 +575,21 @@ Grenzen, die du kennen solltest:
 
 ## Getestet mit
 
-Stand 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
+Am 25.07.2026 gegen echte Systeme verifiziert — beide Betriebsarten, alle drei
-Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz).
+Git-Adapter (GitHub, GitLab und Gitea jeweils gegen die öffentliche Instanz). Seitdem
+laufen die Ende-zu-Ende-Tests bei jeder Änderung mit; live nach draußen geht davon nur
+ein Test gegen die GitHub-API.
+
+Werkzeugstand vom 18.08.2026:
 
 | | Version |
 | --- | --- |
-| Node.js | 26.5.0 |
+| Node.js | 24.19.0 |
 | npm | 11.17.0 |
 | Next.js | 15.5.21 |
 | Prisma | 6.19.3 |
-| PostgreSQL | 17 (Alpine) |
+| PostgreSQL | 17.11 (Alpine) |
-| Docker / Compose | 29.6.2 / v5.3.1 |
+| Docker | 29.7.2 |
 
 ---
 

ROADMAP.md

@@ -7,25 +7,21 @@ Stück für Stück abarbeiten. Reihenfolge ist ein Vorschlag, keine Festlegung.
 
 Was bereits steht, listet [FEATURES.md](FEATURES.md).
 
+**Stand:** v1.11.0. Alle Issues aus dem Dashboard sind abgearbeitet.
+
 ---
 
 ## 1 · Als Nächstes empfohlen
 
-### 1.0 Rest aus v1.6.0: persönliche API-Token `M`
+### 1.1 Persönliche API-Token `M`
 
-Schnellerfassung und die projektübergreifende Aufgabenseite sind mit v1.6.0
+Der letzte offene Teil aus v1.6.0 („unterwegs erfassen"). Derzeit geht die
-ausgeliefert. Offen bleibt der dritte Teil — siehe 1.3. Er gehört sachlich
+API nur mit Sitzungscookie. Ein Token je Konto würde `curl`-Aufrufe und
-dazu: erfassen am Telefon, überblicken an einer Stelle, ansprechen per
+Handy-Shortcuts erlauben — eine Idee aus dem Terminal anlegen, ohne den
-Shortcut.
+Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den Sitzungen.
 
-Bewusst nicht mitgeliefert wurde ein **Index für die übergreifende
+Bewusst noch nicht angefasst, weil sicherheitsrelevant: Geltungsbereich,
-Aufgabenabfrage**. `Task` hat kein `ownerId`, die Trennung läuft über
+Widerruf und Ablauf wollen entschieden sein, nicht nebenbei gebaut.
-`project: { ownerId }`, und `[projectId, status, position]` greift dafür
-nicht. Bei einigen hundert Aufgaben fällt das nicht auf; wird die Seite
-träge, ist ein Index auf `dueDate` der erste Griff — und dann eine
-Migration wert.
-
----
 
 ### 1.2 Läuft es noch? `M`
 
@@ -34,24 +30,17 @@ Nebula wüsste dann, ob ein Projekt nicht nur existiert, sondern auch läuft.
 Nutzt Zeitgeber und Benachrichtigungen, die es schon gibt. Der SSRF-Schutz
 greift dabei wie bei den Git-Aufrufen.
 
-### 1.3 Persönliche API-Token `M`
+### 1.3 Aufgaben ↔ Issues: der Rest `S`
 
-Derzeit geht die API nur mit Sitzungscookie. Ein Token je Konto würde
+Beide Richtungen stehen — „als Issue anlegen" seit v1.7.0, der Rückweg über
-`curl`-Aufrufe und Handy-Shortcuts erlauben — Idee aus dem Terminal anlegen,
+Webhook (v1.7.0) und zusätzlich über den Abgleich (v1.9.0). Offen ist
-ohne den Browser zu öffnen. Nur der Hash in der Datenbank, wie bei den
+Kleinkram:
-Sitzungen.
-
----
-
-### 1.4 Aufgaben ↔ Issues: was noch fehlt `S`
-
-Mit v1.7.0 stehen beide Richtungen: „als Issue anlegen“ und der Rückweg über
-Webhooks. Offen geblieben ist Kleinkram:
 
 - **Mehrere Repositories.** Der Knopf nimmt immer das führende. Bei einem
   Projekt aus Frontend und Backend fehlt die Wahl.
-- **Beim Übernehmen aus Issues** wird der Rückweg nicht automatisch
+- **Webhook beim Verknüpfen anbieten.** Er ist getrennt einzurichten, und
-  eingerichtet — der Webhook ist getrennt zu setzen.
+  wer das nicht tut, merkt nur an der Verzögerung, dass etwas fehlt. Ein
+  Hinweis an der richtigen Stelle würde reichen.
 
 Was **nicht** kommt, bleibt wie besprochen: eine echte beidseitige
 Synchronisation mit Konfliktauflösung. Die Zustände passen ohnehin nicht
@@ -75,15 +64,60 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 
 ---
 
-## 3 · Kleinigkeiten
+## 3 · Aufgefallen beim Bauen
+
+Beobachtungen aus der Arbeit an v1.6.0 bis v1.11.0 — festgehalten, damit sie
+nicht verloren gehen. Nichts davon ist dringend.
+
+### 3.1 Anwendungsname bricht in der Kopfleiste ab `S`
+
+Zwischen 320 und 375 px wird aus „Nebula" ein „Neb…". Gemessen über fünf
+Breiten und zwei Seiten: betrifft alle Seiten gleichermaßen. Seit die
+Aufgaben als dritter Punkt danebenstehen, ist es enger geworden.
+
+### 3.2 Indizes für die projektübergreifenden Seiten `S`
+
+Weder `Task` noch `Activity` haben einen Besitzer — die Trennung läuft über
+`project: { ownerId }`. Die vorhandenen Indizes
+(`[projectId, status, position]` bzw. `[projectId, createdAt]`) greifen für
+Abfragen über alle Projekte deshalb nicht.
+
+Betroffen sind inzwischen vier Seiten: Aufgabenübersicht, Wochenrückblick,
+Zeitleiste und die Volltextsuche. Bei einigen hundert Datensätzen fällt das
+nicht auf. Wird eine der Seiten träge, sind Indizes auf `Task.dueDate` und
+`Activity.createdAt` der erste Griff — und dann eine Migration wert.
+
+### 3.3 Projektfilter auf der Zeitleiste `S`
+
+Über alle Projekte wird die Liste schnell lang. Der Wochenrückblick hat
+Wochengrenzen als natürliche Bremse, die Zeitleiste nicht. Bewusst
+weggelassen, weil das Issue nur „derselbe Verlauf, projektübergreifend"
+verlangte.
+
+### 3.4 Abgleich gegen geleakte Passwörter `M`
+
+ASVS 2.1.7 verlangt es; umgesetzt ist bisher nur eine lokale Sperrliste plus
+Mustererkennung (Wiederholungen, Zeichenfolgen, Benutzername im Passwort).
+Have-I-Been-Pwned scheidet aus — Nebula ruft grundsätzlich nichts von außen,
+und ein Passwort-Präfix nach draußen zu geben widerspräche dem erst recht.
+Eine lokale Top-10000-Liste als Datei wäre der Kompromiss.
+
+### 3.5 v0.2.0 und v0.3.0 ohne Release `S`
+
+Beide stehen im Änderungsverlauf, existierten aber nie in der
+`package.json` — dort springt die Historie von 0.1.0 auf 0.4.0. Nachgetragen
+wurden sie in dem Commit, der den Verlauf einführte, und der liegt *nach*
+0.4.0. Es gibt also keinen ehrlichen Commit, an dem ein Tag hängen könnte.
+Die übrigen 20 Fassungen haben seit dem 18.08.2026 ein Release in Gitea.
+
+---
+
+## 4 · Kleinigkeiten
 
 | Idee | Aufwand | Nutzen |
 | --- | --- | --- |
-| Wochenrückblick | `S` | „Was ist diese Woche passiert" über alle Projekte, aus dem Aktivitätsverlauf |
-| Globale Zeitleiste | `S` | Derselbe Verlauf, aber projektübergreifend als eigene Seite |
-| Suche über Aufgaben | `S` | Die Volltextsuche deckt bisher nur Notizen ab |
 | Suchtreffer in Notizen hervorheben | `S` | In der Notiz selbst, nicht nur in der Trefferliste |
-| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt — fällt weitgehend mit 1.4 ab |
+| Aufgabe ↔ Commit verknüpfen | `M` | Enthält ein Commit `#5`, wird die übernommene Aufgabe verlinkt — fällt weitgehend mit 1.3 ab |
 | Tastaturkürzel-Übersicht mit `?` | `S` | Es gibt inzwischen genug davon |
 | Hell/Dunkel umschaltbar | `M` | Aktuell nur dunkel |
 | Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
@@ -91,7 +125,7 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 
 ---
 
-## 4 · Bewusst nicht
+## 5 · Bewusst nicht
 
 Damit klar ist, was **nicht** kommt und warum:
 
@@ -104,7 +138,10 @@ Damit klar ist, was **nicht** kommt und warum:
 - **Anhänge an Notizen.** Bräuchte Dateispeicher und damit eine zweite Sorge
   bei jeder Sicherung. Ein Link ins Git tut es auch.
 - **Eigene Git-Operationen** (klonen, committen, pushen). Nebula ist eine
-  Übersicht, keine Entwicklungsumgebung.
+  Übersicht, keine Entwicklungsumgebung. Issues über die HTTP-API der
+  Provider sind davon nicht berührt — die gibt es seit v1.7.0.
+- **Beidseitige Synchronisation von Aufgaben und Issues** mit
+  Konfliktauflösung — siehe 1.3.
 - **Zeiterfassung, Rechnungen, Kundenverwaltung.** Andere Baustelle.
 - **Cloud-Synchronisation.** Die Daten bleiben in deiner Datenbank; das ist
   der Punkt.
@@ -138,6 +175,11 @@ Damit klar ist, was **nicht** kommt und warum:
 | **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 | ✓ |
+| **v1.8.0** Anmeldung und Sitzungen nach OWASP: scrypt-Aufwand, Aufzählbarkeit, Leerlauffrist, Cookie-Härtung | ✓ |
+| **v1.9.0** Geschlossene Issues haken ihre Aufgabe auch ohne Webhook ab | ✓ |
+| **v1.10.0** Wochenrückblick, globale Zeitleiste, Suche über Aufgaben | ✓ |
+| **v1.10.1** Issue-Kennzeichen auf der Aufgabenkarte, Token-Rechte Aufruf für Aufruf belegt | ✓ |
+| **v1.11.0** Karten je Spalte begrenzen; der Abgleich verschluckt keine Fehler mehr und verliert dabei nichts | ✓ |
 
 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

@@ -763,6 +763,112 @@ test("Projektvorlagen: aus Projekt sichern und anwenden", async ({ request, play
   expect((await request.delete(`/api/templates/${vorlage.id}`)).ok()).toBeTruthy();
 });
 
+test("Verlauf blaettert per Cursor, ohne Zeilen zu verlieren", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  // Die bisherigen Tests haben reichlich Verlauf erzeugt. Erst alles auf
+  // einmal holen, dann in kleinen Seiten – beides muss dieselbe Menge sein.
+  const alles = await (await request.get("/api/activity?limit=100")).json();
+  expect(alles.activities.length).toBeGreaterThan(5);
+
+  const ids: string[] = [];
+  let cursor: { vor: string; id: string } | null = null;
+  for (let seite = 0; seite < 60; seite += 1) {
+    const query = cursor
+      ? `?limit=3&vor=${encodeURIComponent(cursor.vor)}&id=${encodeURIComponent(cursor.id)}`
+      : "?limit=3";
+    const antwort = await request.get(`/api/activity${query}`);
+    expect(antwort.ok()).toBeTruthy();
+    const seiteBody = await antwort.json();
+    ids.push(...seiteBody.activities.map((eintrag: { id: string }) => eintrag.id));
+    if (!seiteBody.weitere) break;
+    cursor = seiteBody.naechster;
+    expect(cursor).not.toBeNull();
+  }
+
+  // Der eigentliche Punkt: keine Dubletten und keine Luecken, auch wenn
+  // mehrere Eintraege denselben Zeitstempel tragen.
+  expect(new Set(ids).size).toBe(ids.length);
+  expect(ids.length).toBe(alles.activities.length);
+
+  // Absteigend sortiert.
+  const zeiten: number[] = alles.activities.map((eintrag: { createdAt: string }) =>
+    Date.parse(eintrag.createdAt),
+  );
+  for (let i = 1; i < zeiten.length; i += 1) {
+    expect(zeiten[i]).toBeLessThanOrEqual(zeiten[i - 1]);
+  }
+
+  // Unbrauchbare Cursor fangen von vorn an, statt zu scheitern.
+  const kaputt = await request.get("/api/activity?vor=keindatum&id=x");
+  expect(kaputt.ok()).toBeTruthy();
+  expect((await kaputt.json()).activities.length).toBeGreaterThan(0);
+
+  // Und ein fremdes Konto sieht ausschliesslich seinen eigenen Verlauf.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  const fremderVerlauf = await (await fremd.get("/api/activity")).json();
+  const eigeneIds = new Set(ids);
+  for (const eintrag of fremderVerlauf.activities) {
+    expect(eigeneIds.has(eintrag.id)).toBe(false);
+  }
+  await fremd.dispose();
+});
+
+test("Volltextsuche findet auch Aufgaben", async ({ request, playwright }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Suchprojekt" } })).json()
+  ).project;
+
+  for (const task of [
+    {
+      title: "Dockerfile aufraeumen",
+      description: "Die Schichten im Container neu ordnen, damit der Bau schneller wird.",
+    },
+    { title: "Rechnungen exportieren", description: "Monatlicher Export als CSV." },
+    { title: "Erledigtes mit Container", description: "Auch das soll gefunden werden.", status: "DONE" },
+    { title: "Ohne Bezug", description: "Voellig anderer Inhalt." },
+  ]) {
+    expect((await request.post(`/api/projects/${projekt.id}/tasks`, { data: task })).status()).toBe(
+      201,
+    );
+  }
+
+  // Titel und Beschreibung werden durchsucht.
+  const container = await (await request.get("/api/search?q=Container")).json();
+  const titel = container.tasks.map((treffer: { title: string }) => treffer.title);
+  expect(titel).toContain("Dockerfile aufraeumen");
+  // Erledigtes bleibt drin – wer sucht, sucht oft gerade das Abgehakte.
+  expect(titel).toContain("Erledigtes mit Container");
+  expect(titel).not.toContain("Ohne Bezug");
+
+  // Deutsche Stammformen: "Rechnung" findet "Rechnungen".
+  const rechnung = await (await request.get("/api/search?q=Rechnung")).json();
+  expect(rechnung.tasks.map((t: { title: string }) => t.title)).toContain(
+    "Rechnungen exportieren",
+  );
+
+  // Das Projekt taucht in projectIds auf, damit das Brett es einblendet.
+  expect(container.projectIds).toContain(projekt.id);
+
+  // Zu kurze Eingaben liefern leere Listen statt Unsinn.
+  const kurz = await (await request.get("/api/search?q=a")).json();
+  expect(kurz.tasks).toEqual([]);
+  expect(kurz.hits).toEqual([]);
+
+  // Und ein fremdes Konto findet nichts davon.
+  const fremd = await playwright.request.newContext({
+    baseURL: test.info().project.use.baseURL,
+  });
+  await login(fremd, ZWEITER);
+  expect((await (await fremd.get("/api/search?q=Container")).json()).tasks).toHaveLength(0);
+  await fremd.dispose();
+});
+
 test("Der Bildoptimierer ist zu", async ({ playwright }) => {
   // /_next/image reicht jedes Bild durch sharp und damit durch libvips, fuer
   // das es regelmaessig Schwachstellen gibt. Nebula benutzt next/image

e2e/ui.spec.ts

@@ -223,6 +223,75 @@ test("Aufgabenuebersicht sammelt ueber alle Projekte und hakt ab", async ({ page
   ).toBeVisible();
 });
 
+test("Wochenrueckblick zeigt, was diese Woche passiert ist", async ({ page }) => {
+  // Erreichbar vom Dashboard aus, ohne vierten Punkt in der Kopfleiste.
+  await page.getByRole("link", { name: /Wochenrückblick/ }).click();
+  await expect(page).toHaveURL(/\/rueckblick$/);
+  await expect(page.getByRole("heading", { name: "Diese Woche", level: 1 })).toBeVisible();
+
+  // Die Vorgaenge der bisherigen Tests liegen in dieser Woche, es muss also
+  // etwas dastehen – und das Projekt gehoert an jede Zeile.
+  await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
+
+  // Blättern: zurück und wieder her.
+  await page.getByRole("link", { name: "Eine Woche zurück" }).click();
+  await expect(page).toHaveURL(/woche=-1/);
+  await expect(page.getByRole("heading", { name: "Vorige Woche", level: 1 })).toBeVisible();
+
+  await page.getByRole("link", { name: "Diese Woche", exact: true }).click();
+  await expect(page).toHaveURL(/\/rueckblick$/);
+
+  // Auch ueber die Schnellsuche erreichbar.
+  await page.goto("/");
+  await page.keyboard.press("Control+k");
+  await page.getByPlaceholder(/^Projekt, /).fill("Rückblick");
+  await page.keyboard.press("Enter");
+  await expect(page).toHaveURL(/\/rueckblick/);
+});
+
+test("Globale Zeitleiste zeigt den Verlauf ueber alle Projekte", async ({ page }) => {
+  // Vom Wochenrueckblick aus verlinkt.
+  await page.goto("/rueckblick");
+  await page.getByRole("link", { name: /Ganzer Verlauf/ }).click();
+  await expect(page).toHaveURL(/\/verlauf$/);
+  await expect(page.getByRole("heading", { name: "Verlauf", level: 1 })).toBeVisible();
+
+  // Eintraege mit Projektbezug – ohne den ist eine uebergreifende Liste
+  // nicht zu lesen.
+  await expect(page.getByRole("link", { name: "Oberflaechentest" }).first()).toBeVisible();
+  await expect(page.getByText(/Vorgänge geladen|Vorgang geladen/)).toBeVisible();
+
+  // Auch ueber die Schnellsuche erreichbar.
+  await page.goto("/");
+  await page.keyboard.press("Control+k");
+  await page.getByPlaceholder(/^Projekt, /).fill("Verlauf");
+  await page.keyboard.press("Enter");
+  await expect(page).toHaveURL(/\/verlauf/);
+});
+
+test("Aufgabendashboard laesst sich durchsuchen", async ({ page }) => {
+  await page.getByRole("link", { name: "Aufgaben", exact: true }).click();
+  await expect(page.getByRole("heading", { name: "Aufgaben", level: 1 })).toBeVisible();
+
+  const suchfeld = page.getByLabel("Aufgaben durchsuchen");
+  await expect(suchfeld).toBeVisible();
+
+  // Aus den frueheren Tests gibt es "Erste Aufgabe" und "Zweite Aufgabe".
+  await suchfeld.fill("Erste");
+  await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
+  await expect(page.getByRole("listitem").filter({ hasText: "Zweite Aufgabe" })).toBeHidden();
+
+  // Ohne Treffer erklaert der Leerzustand, worin gesucht wurde.
+  await suchfeld.fill("gibtesnichtxyz");
+  await expect(page.getByText("Keine Treffer")).toBeVisible();
+  await expect(page.getByText(/Titel, Beschreibung, Labels und Projektname/)).toBeVisible();
+
+  // Zuruecksetzen bringt alles wieder.
+  await page.getByRole("button", { name: "Suche zuruecksetzen" }).click();
+  await expect(suchfeld).toHaveValue("");
+  await expect(page.getByRole("listitem").filter({ hasText: "Erste Aufgabe" })).toBeVisible();
+});
+
 test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   await page.keyboard.press("Control+k");
   await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
@@ -230,7 +299,7 @@ test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
   // Ohne Eingabe stehen Projekte und Bereiche bereit.
   await expect(page.getByRole("dialog").getByText("Oberflaechentest")).toBeVisible();
 
-  await page.getByPlaceholder(/Projekt, Notiz oder Bereich/).fill("Zaunkoenig");
+  await page.getByPlaceholder(/^Projekt, /).fill("Zaunkoenig");
   await expect(page.getByRole("dialog").getByText(/in Oberflaechentest/)).toBeVisible();
 
   // Enter springt zum ersten Treffer.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "nebula",
-  "version": "1.2.0",
+  "version": "1.11.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "nebula",
-      "version": "1.2.0",
+      "version": "1.11.0",
       "hasInstallScript": true,
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",

package.json

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

prisma/migrations/20260818000000_task_fulltext/migration.sql

@@ -0,0 +1,20 @@
+-- Volltextsuche ueber Aufgaben.
+--
+-- Wie Note_fulltext_idx ein Ausdrucksindex: Prisma kann so etwas im Schema
+-- nicht abbilden und kennt ihn deshalb nicht. Nachgeprueft mit
+-- "prisma migrate diff" gegen das Schema - es kommt "empty migration"
+-- heraus, der Index wird also weder angelegt noch geloescht. Trotzdem beim
+-- Erzeugen kuenftiger Migrationen kurz hinsehen.
+--
+-- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
+-- Postgres berechnet to_tsvector dann je Zeile.
+--
+-- Der Ausdruck muss Zeichen fuer Zeichen dem in src/app/api/search/route.ts
+-- entsprechen, sonst greift der Index nicht. Die zweistellige Form von
+-- to_tsvector mit fester Konfiguration ist IMMUTABLE und damit indizierbar.
+--
+-- Anders als bei der Notiz ist auch die Beschreibung optional, deshalb steht
+-- coalesce um beide Spalten.
+
+CREATE INDEX "Task_fulltext_idx" ON "Task"
+  USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || coalesce("description", '')));

prisma/migrations/20260818230000_task_column_limit/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "AppSettings" ADD COLUMN     "taskColumnLimit" INTEGER NOT NULL DEFAULT 15;

prisma/migrations/20260901160000_snapshot_teilabrufe/migration.sql

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

prisma/schema.prisma

@@ -266,6 +266,11 @@ model AppSettings {
   /// Kurzbericht des letzten Durchlaufs: { synced, failed, skipped, ms }
   lastAutoSyncReport Json?
 
+  // ── Aufgabenbrett ──────────────────────────────────────────
+  /// Hoechstzahl Karten je Spalte. Was darueber hinausgeht, kommt hinter
+  /// einen Knopf – verborgen wird nichts. 0 schaltet die Begrenzung ab.
+  taskColumnLimit Int @default(15)
+
   // ── Stillstand ─────────────────────────────────────────────
   /// Ab wie vielen Tagen ohne Commit ein Projekt als stillstehend gilt.
   staleAfterDays   Int       @default(60)
@@ -644,6 +649,19 @@ model RepoSnapshot {
   ciUrl        String?
   ciFinishedAt DateTime?
 
+  /// Teil-Abrufe, die beim letzten Abgleich nicht geklappt haben:
+  /// { "branches": "HTTP 403: Zugriff verweigert …" }. Leeres Objekt heisst,
+  /// dass alle Listen wirklich geholt wurden.
+  ///
+  /// Ohne diese Angabe ist eine leere Liste zweideutig – "nicht geholt" sieht
+  /// aus wie "nichts vorhanden". Genau daran ist eine Fehlersuche einmal
+  /// haengen geblieben.
+  missing Json @default("{}")
+
   pushedAt  DateTime?
   fetchedAt DateTime @default(now())
+  /// Wann zuletzt ein Abgleich lief, bei dem alle Teile ankamen. Steht der
+  /// weiter zurueck als fetchedAt, ist ein Teil der Anzeige aelter als sie
+  /// vorgibt.
+  completeAt DateTime?
 }

src/app/admin/page.tsx

@@ -19,7 +19,7 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AdminPage() {
   const admin = await requireAdminPage();
 
-  const [settings, users, eligible, staleListeners] = await Promise.all([
+  const [settings, users, eligible, staleListeners, laengsteSpalte] = await Promise.all([
     getAppSettings(),
     prisma.user.findMany({
       select: userSafeSelect,
@@ -41,6 +41,18 @@ export default async function AdminPage() {
     prisma.notificationTarget.count({
       where: { isActive: true, events: { has: "PROJECT_STALE" } },
     }),
+    // Laengste Spalte ueber alle Projekte. Ohne diese Zahl steht die
+    // Einstellung im Leeren: eine Grenze von 15 sagt nichts, wenn die
+    // groesste Spalte im Bestand aus drei Karten besteht.
+    //
+    // Wie beim Abgleich bewusst ueber alle Konten – gezaehlt wird nur, es
+    // wird nichts gelesen und nichts zugeordnet.
+    prisma.task.groupBy({
+      by: ["projectId", "status"],
+      _count: { _all: true },
+      orderBy: { _count: { projectId: "desc" } },
+      take: 1,
+    }),
   ]);
 
   const data: AdminData = {
@@ -64,6 +76,10 @@ export default async function AdminPage() {
       lastCheckAt: settings.lastStaleCheckAt,
       listeners: staleListeners,
     },
+    tasks: {
+      columnLimit: settings.taskColumnLimit,
+      laengsteSpalte: laengsteSpalte[0]?._count._all ?? 0,
+    },
   };
 
   return (

src/app/api/activity/route.ts

@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import {
+  SEITEN_ORDNUNG,
+  cursorAus,
+  seitenBedingung,
+  seitenGroesse,
+} from "@/lib/timeline";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * Der Verlauf ueber alle Projekte, neueste Eintraege zuerst.
+ *
+ * Geblaettert wird per Cursor (`vor` = Zeitpunkt, `id` = Eintrag), nicht per
+ * Offset – siehe lib/timeline. Zurueck kommt der Cursor fuer die naechste
+ * Seite gleich mit, damit der Aufrufer ihn nicht selbst zusammensetzen muss.
+ */
+export async function GET(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const params = new URL(request.url).searchParams;
+  const cursor = cursorAus(params.get("vor"), params.get("id"));
+  const take = seitenGroesse(params.get("limit"));
+
+  /**
+   * Einen mehr holen als angefragt: daran laesst sich ablesen, ob es
+   * weitergeht, ohne dafuer zaehlen zu muessen.
+   */
+  const gefunden = await prisma.activity.findMany({
+    where: seitenBedingung(auth.user.id, cursor),
+    orderBy: SEITEN_ORDNUNG,
+    take: take + 1,
+    select: {
+      id: true,
+      kind: true,
+      summary: true,
+      createdAt: true,
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+  });
+
+  const weitere = gefunden.length > take;
+  const activities = weitere ? gefunden.slice(0, take) : gefunden;
+  const letzter = activities[activities.length - 1];
+
+  return NextResponse.json({
+    activities: activities.map((eintrag) => ({
+      ...eintrag,
+      createdAt: eintrag.createdAt.toISOString(),
+    })),
+    weitere,
+    naechster: weitere && letzter ? { vor: letzter.createdAt.toISOString(), id: letzter.id } : null,
+  });
+}

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

@@ -38,6 +38,7 @@ export async function PATCH(request: Request) {
     autoSyncActiveOnly,
     autoSyncBatchSize,
     staleAfterDays,
+    taskColumnLimit,
   } = parsed.data;
 
   // Der Wechsel in den Einzelbetrieb wuerde weitere Konten aussperren –
@@ -63,6 +64,7 @@ export async function PATCH(request: Request) {
     ...(staleAfterDays !== undefined
       ? { staleAfterDays, lastStaleCheckAt: null }
       : {}),
+    ...(taskColumnLimit !== undefined ? { taskColumnLimit } : {}),
   };
 
   const settings = await prisma.appSettings.upsert({

src/app/api/search/route.ts

@@ -12,16 +12,30 @@ interface Hit {
   snippet: string;
 }
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  /** Ausschnitt aus der Beschreibung; leer, wenn nur der Titel passte. */
+  snippet: string;
+}
+
 /**
- * Volltextsuche ueber Notizen.
+ * Volltextsuche ueber Notizen und Aufgaben.
  *
  * Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt
- * Name, Kurzbeschreibung und Tags ab. Notizen liegen dort nicht vor – die
+ * Name, Kurzbeschreibung und Tags ab. Notizen und Aufgaben liegen dort nicht
- * mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser Endpunkt:
+ * vor – die mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser
- * Postgres sucht mit seiner deutschen Textsuche direkt in der Datenbank.
+ * Endpunkt: Postgres sucht mit seiner deutschen Textsuche direkt in der
+ * Datenbank.
  *
  * ts_headline liefert gleich den passenden Ausschnitt mit; die Hervorhebung
  * kommt als [[…]] zurueck, damit die Oberflaeche kein HTML einbetten muss.
+ *
+ * Das Feld heisst weiterhin "hits" und meint die Notizen – umbenennen haette
+ * nur Aufrufer gebrochen, ohne etwas zu verbessern. Aufgaben kommen als
+ * eigenes Feld dazu.
  */
 export async function GET(request: Request) {
   const auth = await requireUserApi();
@@ -29,7 +43,7 @@ export async function GET(request: Request) {
 
   const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
   if (query.length < 2) {
-    return NextResponse.json({ query, hits: [], projectIds: [] });
+    return NextResponse.json({ query, hits: [], tasks: [], projectIds: [] });
   }
 
   // websearch_to_tsquery versteht Eingaben wie "docker -compose" oder
@@ -57,11 +71,48 @@ export async function GET(request: Request) {
     LIMIT 50
   `;
 
+  /**
+   * Dieselbe Rechnung fuer Aufgaben.
+   *
+   * Der Ausdruck in to_tsvector muss Zeichen fuer Zeichen dem in der
+   * Migration entsprechen (Task_fulltext_idx), sonst greift der Index nicht
+   * und Postgres rechnet ihn je Zeile neu.
+   *
+   * Erledigtes bleibt drin: wer sucht, sucht oft gerade das, was er letzte
+   * Woche abgehakt hat.
+   */
+  const tasks = await prisma.$queryRaw<TaskHit[]>`
+    SELECT
+      t."projectId" AS "projectId",
+      t."id"        AS "taskId",
+      t."title"     AS "title",
+      t."status"::text AS "status",
+      ts_headline(
+        'german',
+        coalesce(t."description", ''),
+        websearch_to_tsquery('german', ${query}),
+        'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
+      ) AS "snippet"
+    FROM "Task" t
+    JOIN "Project" p ON p."id" = t."projectId"
+    WHERE p."ownerId" = ${auth.user.id}
+      AND to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", ''))
+          @@ websearch_to_tsquery('german', ${query})
+    ORDER BY ts_rank(
+      to_tsvector('german', coalesce(t."title", '') || ' ' || coalesce(t."description", '')),
+      websearch_to_tsquery('german', ${query})
+    ) DESC
+    LIMIT 50
+  `;
+
   return NextResponse.json({
     query,
     hits,
+    tasks,
     // Die Oberflaeche braucht vor allem die betroffenen Projekte, um sie im
-    // Board einzublenden.
+    // Board einzublenden – jetzt aus beiden Quellen.
-    projectIds: Array.from(new Set(hits.map((hit) => hit.projectId))),
+    projectIds: Array.from(
+      new Set([...hits.map((hit) => hit.projectId), ...tasks.map((hit) => hit.projectId)]),
+    ),
   });
 }

src/app/page.tsx

@@ -1,4 +1,5 @@
-import { CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
+import Link from "next/link";
+import { CalendarRange, CircleDot, GitBranch, Lightbulb, Rocket, Trophy } from "lucide-react";
 import { ProjectBoard } from "@/components/ProjectBoard";
 import { StatCard } from "@/components/StatCard";
 import { requireUserPage } from "@/lib/auth/guard";
@@ -50,6 +51,15 @@ export default async function DashboardPage() {
           Ideen festhalten, Status pflegen, Notizen sammeln – und live sehen, was in den
           verknuepften Repositories bei GitHub, GitLab und Gitea passiert.
         </p>
+        {/* Kein weiterer Punkt in der Kopfleiste – die ist auf dem Telefon
+            schon eng. Der Rueckblick haengt dort, wo man ohnehin hinsieht. */}
+        <Link
+          href="/rueckblick"
+          className="mt-3 inline-flex items-center gap-1.5 text-sm text-violet-300 underline-offset-2 hover:underline"
+        >
+          <CalendarRange className="h-4 w-4" />
+          Wochenrückblick ansehen
+        </Link>
       </header>
 
       {/* Zwei Spalten schon auf dem Telefon: einspaltig fuellten die fuenf

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

@@ -10,6 +10,7 @@ import { ProjectHeader } from "@/components/ProjectHeader";
 import { TaskBoard } from "@/components/tasks/TaskBoard";
 import { requireUserPage } from "@/lib/auth/guard";
 import { getSessionUser } from "@/lib/auth/session";
+import { getAppSettings } from "@/lib/auth/settings";
 import { prisma } from "@/lib/db";
 import { connectionSafeSelect, projectDetailInclude, webhookRepositoryIds } from "@/lib/projects";
 import type { ConnectionSafe, ProjectDetail } from "@/types";
@@ -37,7 +38,7 @@ export default async function ProjectPage({ params }: PageProps) {
   const user = await requireUserPage();
   const { id } = await params;
 
-  const [project, connections] = await Promise.all([
+  const [project, connections, settings] = await Promise.all([
     // findFirst mit Besitzerbedingung: ein fremdes Projekt fuehrt zu 404,
     // nicht zu einer Fehlermeldung, die seine Existenz bestaetigt.
     prisma.project.findFirst({
@@ -49,6 +50,7 @@ export default async function ProjectPage({ params }: PageProps) {
       select: connectionSafeSelect,
       orderBy: { name: "asc" },
     }),
+    getAppSettings(),
   ]);
 
   if (!project) notFound();
@@ -83,6 +85,7 @@ export default async function ProjectPage({ params }: PageProps) {
         projectId={detail.id}
         tasks={detail.tasks}
         progressFromTasks={detail.progressFromTasks}
+        columnLimit={settings.taskColumnLimit}
       />
 
       {/*

src/app/rueckblick/page.tsx

@@ -0,0 +1,139 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { ArrowLeft, ArrowRight, CalendarRange, History } from "lucide-react";
+import { WeeklyReview } from "@/components/WeeklyReview";
+import { requireUserPage } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { tagesschluessel, wocheUm, wochenName, wochenTitel, zaehleWoche } from "@/lib/review";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = { title: "Wochenrückblick" };
+
+/** Wie weit sich zurueckblaettern laesst – der Verlauf haelt ohnehin nur 200 je Projekt. */
+const MAX_RUECKBLICK = 25;
+
+export default async function ReviewPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ woche?: string }>;
+}) {
+  const user = await requireUserPage();
+  const params = await searchParams;
+
+  // Nur nach hinten blaettern: die Zukunft ist im Rueckblick leer.
+  const gewuenscht = Number(params.woche ?? 0);
+  const versatz = Number.isFinite(gewuenscht)
+    ? Math.min(0, Math.max(-MAX_RUECKBLICK, Math.trunc(gewuenscht)))
+    : 0;
+
+  const woche = wocheUm(new Date(), versatz);
+
+  /**
+   * Der Verlauf kennt keinen Besitzer – die Trennung laeuft ueber das
+   * Projekt. Die Bedingung steht deshalb als erste in der where-Klausel.
+   */
+  const activities = await prisma.activity.findMany({
+    where: {
+      project: { ownerId: user.id },
+      createdAt: { gte: woche.von, lt: woche.bis },
+    },
+    include: {
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+    // meta kommt mit, weil die Kennzahlen daran ablesen, was erledigt
+    // wurde – verlaesslicher als der Anzeigetext.
+    orderBy: { createdAt: "desc" },
+    // Deckel gegen eine Woche, in der ein Abgleich Amok gelaufen ist.
+    take: 500,
+  });
+
+  /**
+   * Nach Kalendertagen buendeln – auf dem Server, damit Server-Render und
+   * Hydration nicht auseinanderlaufen. "Welcher Tag" haengt an der Zeitzone.
+   */
+  const nachTag = new Map<string, ReviewEntry[]>();
+  for (const eintrag of activities) {
+    const schluessel = tagesschluessel(eintrag.createdAt);
+    const liste = nachTag.get(schluessel) ?? [];
+    liste.push({
+      id: eintrag.id,
+      kind: eintrag.kind,
+      summary: eintrag.summary,
+      createdAt: eintrag.createdAt.toISOString(),
+      project: eintrag.project,
+      user: eintrag.user,
+    });
+    nachTag.set(schluessel, liste);
+  }
+
+  // Neuester Tag zuerst, und nur Tage, an denen etwas war.
+  const tage: ReviewDay[] = [...woche.tage]
+    .reverse()
+    .map((tag) => ({ tag, eintraege: nachTag.get(tag) ?? [] }))
+    .filter((eintrag) => eintrag.eintraege.length > 0);
+
+  const kennzahlen = zaehleWoche(activities);
+
+  return (
+    <div className="space-y-5">
+      <header className="fade-up pt-4">
+        <p className="text-[11px] font-semibold uppercase tracking-[0.3em] text-violet-300/70">
+          Über alle Projekte
+        </p>
+        <div className="mt-2 flex flex-wrap items-end justify-between gap-3">
+          <div>
+            <h1 className="text-2xl font-semibold tracking-tight text-white sm:text-3xl">
+              {wochenName(woche)}
+            </h1>
+            <p className="mt-1 flex items-center gap-1.5 text-sm text-slate-400">
+              <CalendarRange className="h-3.5 w-3.5" />
+              {wochenTitel(woche)}
+            </p>
+          </div>
+
+          <nav className="flex items-center gap-2" aria-label="Woche wählen">
+            <Link
+              href={`/rueckblick?woche=${versatz - 1}`}
+              className="btn btn-ghost px-2.5 py-1.5 text-xs"
+              aria-label="Eine Woche zurück"
+              // Am Ende des Zeitraums bleibt der Verweis stehen, wird aber
+              // wirkungslos – die Seite klemmt den Wert ohnehin.
+              aria-disabled={versatz <= -MAX_RUECKBLICK}
+            >
+              <ArrowLeft className="h-3.5 w-3.5" />
+              Früher
+            </Link>
+            {versatz < 0 ? (
+              <Link
+                href={`/rueckblick?woche=${versatz + 1}`}
+                className="btn btn-ghost px-2.5 py-1.5 text-xs"
+                aria-label="Eine Woche vor"
+              >
+                Später
+                <ArrowRight className="h-3.5 w-3.5" />
+              </Link>
+            ) : null}
+            {versatz !== 0 ? (
+              <Link href="/rueckblick" className="btn btn-ghost px-2.5 py-1.5 text-xs">
+                Diese Woche
+              </Link>
+            ) : null}
+            <Link href="/verlauf" className="btn btn-ghost px-2.5 py-1.5 text-xs">
+              <History className="h-3.5 w-3.5" />
+              Ganzer Verlauf
+            </Link>
+          </nav>
+        </div>
+      </header>
+
+      <WeeklyReview
+        tage={tage}
+        kennzahlen={kennzahlen}
+        istDieseWoche={versatz === 0}
+      />
+    </div>
+  );
+}

src/app/verlauf/page.tsx

@@ -0,0 +1,77 @@
+import type { Metadata } from "next";
+import Link from "next/link";
+import { CalendarRange, History } from "lucide-react";
+import { Timeline } from "@/components/Timeline";
+import { requireUserPage } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { SEITE, SEITEN_ORDNUNG, seitenBedingung } from "@/lib/timeline";
+import type { ReviewEntry } from "@/types";
+
+export const dynamic = "force-dynamic";
+
+export const metadata: Metadata = { title: "Verlauf" };
+
+/**
+ * Der Verlauf ueber alle Projekte, fortlaufend.
+ *
+ * Die erste Seite kommt serverseitig mit, damit sofort etwas dasteht; alles
+ * Weitere holt der Knopf per Cursor nach. Anders als der Wochenrueckblick
+ * hat diese Seite keine Grenze und kein Fazit – sie laeuft zurueck, solange
+ * es Eintraege gibt.
+ */
+export default async function TimelinePage() {
+  const user = await requireUserPage();
+
+  const gefunden = await prisma.activity.findMany({
+    where: seitenBedingung(user.id, null),
+    orderBy: SEITEN_ORDNUNG,
+    // Einen mehr, um zu wissen, ob es weitergeht.
+    take: SEITE + 1,
+    select: {
+      id: true,
+      kind: true,
+      summary: true,
+      createdAt: true,
+      project: { select: { id: true, name: true, accent: true } },
+      user: { select: { username: true, displayName: true } },
+    },
+  });
+
+  const weitere = gefunden.length > SEITE;
+  const erste: ReviewEntry[] = (weitere ? gefunden.slice(0, SEITE) : gefunden).map((eintrag) => ({
+    id: eintrag.id,
+    kind: eintrag.kind,
+    summary: eintrag.summary,
+    createdAt: eintrag.createdAt.toISOString(),
+    project: eintrag.project,
+    user: eintrag.user,
+  }));
+
+  return (
+    <div className="space-y-5">
+      <header className="fade-up pt-4">
+        <p className="text-[11px] font-semibold uppercase tracking-[0.3em] text-violet-300/70">
+          Über alle Projekte
+        </p>
+        <div className="mt-2 flex flex-wrap items-end justify-between gap-3">
+          <div>
+            <h1 className="flex items-center gap-2 text-2xl font-semibold tracking-tight text-white sm:text-3xl">
+              <History className="h-6 w-6 text-violet-300" />
+              Verlauf
+            </h1>
+            <p className="mt-1 text-sm text-slate-400">
+              Alles, was passiert ist – vom Neuesten rückwärts.
+            </p>
+          </div>
+
+          <Link href="/rueckblick" className="btn btn-ghost px-3 py-1.5 text-xs">
+            <CalendarRange className="h-3.5 w-3.5" />
+            Wochenrückblick
+          </Link>
+        </div>
+      </header>
+
+      <Timeline erste={erste} weitere={weitere} />
+    </div>
+  );
+}

src/components/ActivityFeed.tsx

@@ -1,23 +1,9 @@
 "use client";
 
 import { useState } from "react";
-import {
+import { Bot, History, Loader2 } from "lucide-react";
-  AlertTriangle,
+import { ACTIVITY_KINDS } from "@/components/activityKinds";
-  ArrowRight,
+import type { ActivityEntry } from "@/types";
-  Bot,
-  Download,
-  GitCommitHorizontal,
-  History,
-  Link2,
-  Loader2,
-  NotebookPen,
-  Pencil,
-  Plus,
-  Signpost,
-  Sparkles,
-  Trash2,
-} from "lucide-react";
-import type { ActivityEntry, ActivityKind } from "@/types";
 import { formatDateTime, formatRelative } from "@/lib/utils";
 
 /**
@@ -29,21 +15,6 @@ import { formatDateTime, formatRelative } from "@/lib/utils";
  * obersten fuenf liest.
  */
 
-const KINDS: Record<ActivityKind, { icon: typeof Sparkles; color: string }> = {
-  PROJECT_CREATED: { icon: Sparkles, color: "text-violet-300" },
-  PROJECT_UPDATED: { icon: Pencil, color: "text-slate-400" },
-  STATUS_CHANGED: { icon: Signpost, color: "text-cyan-300" },
-  NOTE_ADDED: { icon: NotebookPen, color: "text-blue-300" },
-  NOTE_UPDATED: { icon: Pencil, color: "text-blue-300" },
-  NOTE_DELETED: { icon: Trash2, color: "text-rose-300" },
-  TASK_ADDED: { icon: Plus, color: "text-emerald-300" },
-  TASK_MOVED: { icon: ArrowRight, color: "text-violet-300" },
-  TASK_DELETED: { icon: Trash2, color: "text-rose-300" },
-  TASKS_IMPORTED: { icon: Download, color: "text-amber-300" },
-  REPO_LINKED: { icon: Link2, color: "text-cyan-300" },
-  REPO_COMMITS: { icon: GitCommitHorizontal, color: "text-emerald-300" },
-  SYNC_FAILED: { icon: AlertTriangle, color: "text-rose-300" },
-};
 
 export function ActivityFeed({
   projectId,
@@ -88,7 +59,7 @@ export function ActivityFeed({
       ) : (
         <ol className="mt-4 space-y-0">
           {entries.map((entry, index) => {
-            const meta = KINDS[entry.kind] ?? KINDS.PROJECT_UPDATED;
+            const meta = ACTIVITY_KINDS[entry.kind] ?? ACTIVITY_KINDS.PROJECT_UPDATED;
             const Icon = meta.icon;
             const letzter = index === entries.length - 1;
 

src/components/ActivityRow.tsx

@@ -0,0 +1,126 @@
+import Link from "next/link";
+import { ACTIVITY_KINDS } from "@/components/activityKinds";
+import { accentOf } from "@/lib/status";
+import { cn } from "@/lib/utils";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+/**
+ * Darstellung von Verlaufseintraegen – eine Zeile und die Gruppierung nach
+ * Kalendertagen.
+ *
+ * Bewusst ohne "use client" und ohne Hooks: so laesst sich beides sowohl aus
+ * einer Server-Komponente (Wochenrueckblick) als auch aus einer
+ * Client-Komponente (Zeitleiste mit Nachladen) heraus benutzen. Zwei Kopien
+ * derselben Zeile waeren beim naechsten Feinschliff auseinandergelaufen.
+ *
+ * Alle Formate mit fester Zeitzone – dieselbe Ueberlegung wie in lib/utils:
+ * sonst weichen Server-Render und Hydration voneinander ab.
+ */
+
+const WOCHENTAG = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  weekday: "long",
+});
+const TAG_MONAT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  day: "numeric",
+  month: "long",
+});
+const TAG_MONAT_JAHR = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  day: "numeric",
+  month: "long",
+  year: "numeric",
+});
+const UHRZEIT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  hour: "2-digit",
+  minute: "2-digit",
+});
+
+/** "2026-08-17" → ein Zeitpunkt mittags, damit die Zeitzone nichts verschiebt. */
+function alsDatum(tag: string): Date {
+  const [j, m, t] = tag.split("-").map(Number);
+  return new Date(Date.UTC(j, m - 1, t, 12));
+}
+
+export function ActivityDayGroups({
+  tage,
+  /** Bei Tagen aus anderen Jahren gehoert die Jahreszahl dazu. */
+  mitJahr = false,
+}: {
+  tage: ReviewDay[];
+  mitJahr?: boolean;
+}) {
+  const format = mitJahr ? TAG_MONAT_JAHR : TAG_MONAT;
+
+  return (
+    <div className="space-y-6">
+      {tage.map((tag) => {
+        const datum = alsDatum(tag.tag);
+        return (
+          <section key={tag.tag}>
+            <div className="mb-2.5 flex flex-wrap items-baseline gap-x-2.5 gap-y-1">
+              <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-300">
+                {WOCHENTAG.format(datum)}
+              </h2>
+              <span className="text-xs text-slate-500">{format.format(datum)}</span>
+              <span className="rounded-full bg-white/6 px-2 py-0.5 text-[11px] tabular-nums text-slate-400">
+                {tag.eintraege.length}
+              </span>
+              <span className="h-px flex-1 bg-gradient-to-r from-white/10 to-transparent" />
+            </div>
+
+            <ul className="glass divide-y divide-white/6 overflow-hidden">
+              {tag.eintraege.map((eintrag) => (
+                <ActivityRow key={eintrag.id} eintrag={eintrag} />
+              ))}
+            </ul>
+          </section>
+        );
+      })}
+    </div>
+  );
+}
+
+export function ActivityRow({ eintrag }: { eintrag: ReviewEntry }) {
+  const art = ACTIVITY_KINDS[eintrag.kind] ?? ACTIVITY_KINDS.PROJECT_UPDATED;
+  const Icon = art.icon;
+  const accent = accentOf(eintrag.project.accent);
+
+  return (
+    <li className="flex items-start gap-2.5 px-3 py-2.5 sm:gap-3 sm:px-4">
+      <span className={cn("mt-0.5 shrink-0", art.color)} title={art.label}>
+        <Icon className="h-4 w-4" />
+      </span>
+
+      <div className="min-w-0 flex-1">
+        <p className="text-sm leading-snug text-slate-200">{eintrag.summary}</p>
+        <div className="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-[11px] text-slate-500">
+          {/* Das Projekt gehoert in jede Zeile – ohne es ist eine
+              projektuebergreifende Liste nicht zu lesen. */}
+          <Link
+            href={`/projects/${eintrag.project.id}`}
+            className="inline-flex max-w-[12rem] items-center gap-1.5 truncate text-slate-400 underline-offset-2 hover:text-violet-300 hover:underline"
+          >
+            <span
+              className="h-1.5 w-1.5 shrink-0 rounded-full"
+              style={{ backgroundColor: accent.from }}
+              aria-hidden="true"
+            />
+            {eintrag.project.name}
+          </Link>
+          <span className="tabular-nums">{UHRZEIT.format(new Date(eintrag.createdAt))} Uhr</span>
+          {eintrag.user ? (
+            <span className="hidden xs:inline">
+              {eintrag.user.displayName?.trim() || eintrag.user.username}
+            </span>
+          ) : (
+            // Ohne Benutzer: das war der Zeitgeber oder ein Webhook.
+            <span className="hidden text-slate-600 xs:inline">automatisch</span>
+          )}
+        </div>
+      </div>
+    </li>
+  );
+}

src/components/CommandPalette.tsx

@@ -5,9 +5,11 @@ import { createPortal } from "react-dom";
 import { useRouter } from "next/navigation";
 import {
   Bell,
+  CalendarRange,
   CheckSquare,
   CornerDownLeft,
   GitBranch,
+  History,
   LayoutDashboard,
   Loader2,
   NotebookPen,
@@ -16,8 +18,9 @@ import {
   Settings,
   UserRound,
 } from "lucide-react";
-import type { ProjectStatus } from "@prisma/client";
+import type { ProjectStatus, TaskStatus } from "@prisma/client";
 import { statusOf } from "@/lib/status";
+import { TASK_STATUS_META } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 
 /**
@@ -38,6 +41,14 @@ interface ProjectHit {
   tags: string[];
 }
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  snippet: string;
+}
+
 interface NoteHit {
   projectId: string;
   noteId: string;
@@ -56,6 +67,20 @@ interface Action {
 
 const ACTIONS: Action[] = [
   { id: "dashboard", label: "Dashboard", hint: "Alle Projekte", icon: LayoutDashboard, href: "/" },
+  {
+    id: "rueckblick",
+    label: "Wochenrückblick",
+    hint: "Was diese Woche passiert ist",
+    icon: CalendarRange,
+    href: "/rueckblick",
+  },
+  {
+    id: "verlauf",
+    label: "Verlauf",
+    hint: "Alles, was passiert ist – über alle Projekte",
+    icon: History,
+    href: "/verlauf",
+  },
   {
     id: "tasks",
     label: "Aufgaben",
@@ -91,7 +116,8 @@ const ACTIONS: Action[] = [
 type Entry =
   | { kind: "action"; key: string; action: Action }
   | { kind: "project"; key: string; project: ProjectHit }
-  | { kind: "note"; key: string; note: NoteHit; projectName: string };
+  | { kind: "note"; key: string; note: NoteHit; projectName: string }
+  | { kind: "task"; key: string; task: TaskHit; projectName: string };
 
 export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
   const router = useRouter();
@@ -100,6 +126,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
   const [query, setQuery] = useState("");
   const [projects, setProjects] = useState<ProjectHit[] | null>(null);
   const [notes, setNotes] = useState<NoteHit[]>([]);
+  const [aufgaben, setAufgaben] = useState<TaskHit[]>([]);
   const [active, setActive] = useState(0);
   const [loading, setLoading] = useState(false);
   const listRef = useRef<HTMLDivElement>(null);
@@ -138,6 +165,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     const needle = query.trim();
     if (needle.length < 2) {
       setNotes([]);
+      setAufgaben([]);
       return;
     }
     const controller = new AbortController();
@@ -147,8 +175,9 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
           signal: controller.signal,
         });
         if (!response.ok) return;
-        const body = (await response.json()) as { hits: NoteHit[] };
+        const body = (await response.json()) as { hits: NoteHit[]; tasks: TaskHit[] };
         setNotes(body.hits ?? []);
+        setAufgaben(body.tasks ?? []);
       } catch {
         // Abbruch beim Weitertippen ist der Normalfall.
       }
@@ -163,6 +192,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     if (!open) {
       setQuery("");
       setNotes([]);
+      setAufgaben([]);
       setActive(0);
     }
   }, [open]);
@@ -202,6 +232,17 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
     for (const project of passendeProjekte.slice(0, 8)) {
       result.push({ kind: "project", key: `p-${project.id}`, project });
     }
+    // Aufgaben vor Notizen: wer tippt, sucht haeufiger etwas zu Tun als
+    // etwas Notiertes.
+    for (const treffer of aufgaben.slice(0, 5)) {
+      result.push({
+        kind: "task",
+        key: `t-${treffer.taskId}`,
+        task: treffer,
+        projectName:
+          (projects ?? []).find((project) => project.id === treffer.projectId)?.name ?? "Projekt",
+      });
+    }
     for (const hit of notes.slice(0, 5)) {
       result.push({
         kind: "note",
@@ -215,7 +256,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
       result.push({ kind: "action", key: `a-${action.id}`, action });
     }
     return result;
-  }, [query, projects, notes, isAdmin]);
+  }, [query, projects, notes, aufgaben, isAdmin]);
 
   useEffect(() => {
     setActive((current) => Math.min(current, Math.max(0, entries.length - 1)));
@@ -226,6 +267,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
       setOpen(false);
       if (entry.kind === "action") router.push(entry.action.href);
       else if (entry.kind === "project") router.push(`/projects/${entry.project.id}`);
+      else if (entry.kind === "task") router.push(`/projects/${entry.task.projectId}`);
       else router.push(`/projects/${entry.note.projectId}`);
     },
     [router],
@@ -276,7 +318,7 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
             value={query}
             onChange={(event) => setQuery(event.target.value)}
             onKeyDown={onInputKey}
-            placeholder="Projekt, Notiz oder Bereich…"
+            placeholder="Projekt, Aufgabe, Notiz oder Bereich…"
             className="w-full bg-transparent text-sm text-slate-100 outline-none placeholder:text-slate-600"
           />
           {loading ? <Loader2 className="h-3.5 w-3.5 animate-spin text-slate-600" /> : null}
@@ -330,6 +372,23 @@ export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
                       {statusOf(entry.project.status).short}
                     </span>
                   </>
+                ) : entry.kind === "task" ? (
+                  <>
+                    <CheckSquare className="mt-0.5 h-4 w-4 shrink-0 text-emerald-300/70" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.task.title}
+                        <span className="ml-1.5 text-[11px] text-slate-500">
+                          in {entry.projectName}
+                        </span>
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.task.snippet.replace(/\[\[|\]\]/g, "").trim() ||
+                          TASK_STATUS_META[entry.task.status as TaskStatus]?.label ||
+                          "Aufgabe"}
+                      </span>
+                    </span>
+                  </>
                 ) : (
                   <>
                     <NotebookPen className="mt-0.5 h-4 w-4 shrink-0 text-violet-300/70" />

src/components/GitPanel.tsx

@@ -30,13 +30,14 @@ 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";
+import { asArray, asCalendar, asRecord, asTextRecord } from "@/types";
 import type {
   BranchInfo,
   CommitInfo,
   ConnectionSafe,
   ProjectDetail,
   ReleaseInfo,
+  RepoSnapshot,
   RepositoryWithSnapshot,
   TagInfo,
   TicketInfo,
@@ -69,17 +70,26 @@ export function GitPanel({
   const [tab, setTab] = useState<TabKey>("pulls");
   const [syncing, setSyncing] = useState(false);
   const [importing, setImporting] = useState(false);
-  const [message, setMessage] = useState<{ ok: boolean; text: string } | null>(null);
+  const [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);
+  const [selectedId, setSelectedId] = useState<string | null>(
+    repositories[0]?.id ?? null,
+  );
 
   // Nach dem Entfernen zeigt die Auswahl ins Leere – dann auf das fuehrende
   // zurueckfallen, statt eine leere Ansicht zu zeigen.
-  const repository = repositories.find((entry) => entry.id === selectedId) ?? repositories[0] ?? null;
+  const repository =
-  const webhookAktiv = repository ? webhookRepoIds.includes(repository.id) : false;
+    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() {
@@ -87,13 +97,17 @@ export function GitPanel({
     setImporting(true);
     setMessage(null);
     try {
-      const response = await fetch(`/api/projects/${project.id}/tasks/from-issues`, {
+      const response = await fetch(
+        `/api/projects/${project.id}/tasks/from-issues`,
+        {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ repositoryId: repository.id }),
-      });
+        },
+      );
       const body = await response.json().catch(() => ({}));
-      if (!response.ok) throw new Error(body.error ?? "Uebernahme fehlgeschlagen.");
+      if (!response.ok)
+        throw new Error(body.error ?? "Uebernahme fehlgeschlagen.");
       setMessage({
         ok: true,
         text:
@@ -103,7 +117,10 @@ export function GitPanel({
       });
       router.refresh();
     } catch (caught) {
-      setMessage({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
+      setMessage({
+        ok: false,
+        text: caught instanceof Error ? caught.message : String(caught),
+      });
     } finally {
       setImporting(false);
     }
@@ -130,7 +147,10 @@ export function GitPanel({
         : `/api/projects/${project.id}/sync`;
       const response = await fetch(url, { method: "POST" });
       const payload = await response.json().catch(() => ({}));
-      setMessage({ ok: response.ok, text: payload.message ?? "Unbekannte Antwort." });
+      setMessage({
+        ok: response.ok,
+        text: payload.message ?? "Unbekannte Antwort.",
+      });
       router.refresh();
     } catch (caught) {
       setMessage({
@@ -150,7 +170,9 @@ export function GitPanel({
     ) {
       return;
     }
-    await fetch(`/api/repositories/${entry.id}`, { method: "DELETE" }).catch(() => undefined);
+    await fetch(`/api/repositories/${entry.id}`, { method: "DELETE" }).catch(
+      () => undefined,
+    );
     setSelectedId(null);
     router.refresh();
   }
@@ -160,12 +182,19 @@ export function GitPanel({
       <>
         <div className="glass px-5 py-10 text-center">
           <GitBranch className="mx-auto h-8 w-8 text-slate-600" />
-          <h3 className="mt-3 text-sm font-semibold text-slate-200">Kein Repository verknuepft</h3>
+          <h3 className="mt-3 text-sm font-semibold text-slate-200">
+            Kein Repository verknuepft
+          </h3>
           <p className="mx-auto mt-1 max-w-sm text-sm text-slate-500">
-            Verknuepfe ein Repository, um Branches, Tags, Commits und Releases hier zu sehen.
+            Verknuepfe ein Repository, um Branches, Tags, Commits und Releases
-            Ein Projekt darf auch mehrere haben – etwa Frontend und Backend.
+            hier zu sehen. Ein Projekt darf auch mehrere haben – etwa Frontend
+            und Backend.
           </p>
-          <button type="button" className="btn btn-primary mt-4" onClick={() => setAddOpen(true)}>
+          <button
+            type="button"
+            className="btn btn-primary mt-4"
+            onClick={() => setAddOpen(true)}
+          >
             <Plus className="h-4 w-4" />
             Repository verknuepfen
           </button>
@@ -180,7 +209,10 @@ export function GitPanel({
     );
   }
 
-  const languageTotal = Object.values(languages).reduce((sum, value) => sum + value, 0);
+  const languageTotal = Object.values(languages).reduce(
+    (sum, value) => sum + value,
+    0,
+  );
   const topLanguages = Object.entries(languages)
     .sort((a, b) => b[1] - a[1])
     .slice(0, 5);
@@ -190,7 +222,10 @@ export function GitPanel({
       {/* Auswahl, sobald es mehr als eines gibt. Bei einem einzigen waere eine
           Leiste mit genau einem Knopf nur Ballast. */}
       {repositories.length > 1 ? (
-        <div className="glass flex flex-wrap items-center gap-1.5 p-2" role="tablist">
+        <div
+          className="glass flex flex-wrap items-center gap-1.5 p-2"
+          role="tablist"
+        >
           {repositories.map((entry) => {
             const aktiv = entry.id === repository.id;
             return (
@@ -256,7 +291,11 @@ export function GitPanel({
                 <ExternalLink className="h-3.5 w-3.5" />
               </a>
             ) : null}
-            <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} url={snapshot?.ciUrl} />
+            <CiBadge
+              state={snapshot?.ciState}
+              name={snapshot?.ciName}
+              url={snapshot?.ciUrl}
+            />
           </div>
           <p className="mt-1 text-xs text-slate-500" suppressHydrationWarning>
             {repository.lastSyncedAt
@@ -368,12 +407,22 @@ export function GitPanel({
         </p>
       ) : null}
 
+      <UnvollstaendigerStand snapshot={snapshot} />
+
       {snapshot ? (
         <>
           {/* Kennzahlen */}
           <div className="grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-6">
-            <Metric icon={Star} label="Stars" value={formatNumber(snapshot.stars)} />
+            <Metric
-            <Metric icon={GitMerge} label="Forks" value={formatNumber(snapshot.forks)} />
+              icon={Star}
+              label="Stars"
+              value={formatNumber(snapshot.stars)}
+            />
+            <Metric
+              icon={GitMerge}
+              label="Forks"
+              value={formatNumber(snapshot.forks)}
+            />
             <Metric
               icon={GitPullRequest}
               label="Offene PRs/MRs"
@@ -384,11 +433,19 @@ export function GitPanel({
               label="Offene Issues"
               value={formatNumber(snapshot.openIssues)}
             />
-            <Metric icon={GitBranch} label="Branches" value={formatNumber(snapshot.branchCount)} />
+            <Metric
+              icon={GitBranch}
+              label="Branches"
+              value={formatNumber(snapshot.branchCount)}
+            />
             <Metric
               icon={HardDrive}
               label="Groesse"
-              value={snapshot.sizeKb > 1024 ? `${Math.round(snapshot.sizeKb / 1024)} MB` : `${snapshot.sizeKb} KB`}
+              value={
+                snapshot.sizeKb > 1024
+                  ? `${Math.round(snapshot.sizeKb / 1024)} MB`
+                  : `${snapshot.sizeKb} KB`
+              }
             />
           </div>
 
@@ -408,11 +465,15 @@ export function GitPanel({
                       {snapshot.lastCommitSha.slice(0, 7)}
                     </span>
                     <span>{snapshot.lastCommitAuthor ?? "unbekannt"}</span>
-                    <span suppressHydrationWarning>{formatRelative(snapshot.lastCommitAt)}</span>
+                    <span suppressHydrationWarning>
+                      {formatRelative(snapshot.lastCommitAt)}
+                    </span>
                   </p>
                 </>
               ) : (
-                <p className="mt-2 text-sm text-slate-500">Keine Commit-Daten.</p>
+                <p className="mt-2 text-sm text-slate-500">
+                  Keine Commit-Daten.
+                </p>
               )}
             </div>
 
@@ -424,8 +485,11 @@ export function GitPanel({
                 <span className="font-mono text-2xl text-white">
                   {snapshot.latestTag ?? snapshot.latestRelease ?? "–"}
                 </span>
-                {snapshot.latestRelease && snapshot.latestRelease !== snapshot.latestTag ? (
+                {snapshot.latestRelease &&
-                  <span className="text-sm text-slate-400">{snapshot.latestRelease}</span>
+                snapshot.latestRelease !== snapshot.latestTag ? (
+                  <span className="text-sm text-slate-400">
+                    {snapshot.latestRelease}
+                  </span>
                 ) : null}
               </div>
               <p className="mt-1 text-xs text-slate-500">
@@ -470,7 +534,8 @@ export function GitPanel({
                     title={`${name} – ${Math.round((bytes / languageTotal) * 100)}%`}
                     style={{
                       width: `${(bytes / languageTotal) * 100}%`,
-                      backgroundColor: LANGUAGE_COLORS[index % LANGUAGE_COLORS.length],
+                      backgroundColor:
+                        LANGUAGE_COLORS[index % LANGUAGE_COLORS.length],
                     }}
                   />
                 ))}
@@ -480,7 +545,10 @@ export function GitPanel({
                   <span key={name} className="inline-flex items-center gap-1.5">
                     <span
                       className="h-2 w-2 rounded-full"
-                      style={{ backgroundColor: LANGUAGE_COLORS[index % LANGUAGE_COLORS.length] }}
+                      style={{
+                        backgroundColor:
+                          LANGUAGE_COLORS[index % LANGUAGE_COLORS.length],
+                      }}
                     />
                     {name}
                     <span className="text-slate-600">
@@ -537,8 +605,8 @@ export function GitPanel({
                   {issues.length > 0 ? (
                     <div className="flex flex-wrap items-center justify-between gap-2 border-b border-white/6 bg-white/2 px-4 py-2">
                       <p className="text-[11px] text-slate-500">
-                        Aus offenen Issues Aufgaben machen. Bereits uebernommene werden
+                        Aus offenen Issues Aufgaben machen. Bereits uebernommene
-                        uebersprungen.
+                        werden uebersprungen.
                       </p>
                       <button
                         type="button"
@@ -555,7 +623,11 @@ export function GitPanel({
                       </button>
                     </div>
                   ) : null}
-                  <TicketList tickets={issues} empty="Keine offenen Issues." icon={CircleDot} />
+                  <TicketList
+                    tickets={issues}
+                    empty="Keine offenen Issues."
+                    icon={CircleDot}
+                  />
                 </>
               ) : null}
               {tab === "branches" ? <BranchList branches={branches} /> : null}
@@ -567,7 +639,8 @@ export function GitPanel({
         </>
       ) : (
         <div className="glass px-5 py-10 text-center text-sm text-slate-500">
-          Noch keine Daten geladen. Mit „Jetzt synchronisieren“ den ersten Snapshot holen.
+          Noch keine Daten geladen. Mit „Jetzt synchronisieren“ den ersten
+          Snapshot holen.
         </div>
       )}
     </div>
@@ -591,7 +664,9 @@ function Metric({
         <Icon className="h-3 w-3" />
         {label}
       </p>
-      <p className="mt-1 text-lg font-semibold tabular-nums text-slate-100">{value}</p>
+      <p className="mt-1 text-lg font-semibold tabular-nums text-slate-100">
+        {value}
+      </p>
     </div>
   );
 }
@@ -639,10 +714,15 @@ function TicketList({
                 ) : null}
               </p>
               <p className="mt-0.5 flex flex-wrap items-center gap-x-2 text-[11px] text-slate-500">
-                <span className="font-mono text-slate-600">#{ticket.number}</span>
+                <span className="font-mono text-slate-600">
+                  #{ticket.number}
+                </span>
                 <span>{ticket.author ?? "unbekannt"}</span>
                 {ticket.labels.slice(0, 3).map((label) => (
-                  <span key={label} className="rounded bg-white/6 px-1 py-0.5 text-[10px]">
+                  <span
+                    key={label}
+                    className="rounded bg-white/6 px-1 py-0.5 text-[10px]"
+                  >
                     {label}
                   </span>
                 ))}
@@ -650,7 +730,9 @@ function TicketList({
             </div>
           </div>
           <div className="flex shrink-0 items-center gap-2 text-[11px] text-slate-500">
-            <span suppressHydrationWarning>{formatRelative(ticket.createdAt)}</span>
+            <span suppressHydrationWarning>
+              {formatRelative(ticket.createdAt)}
+            </span>
             {ticket.url ? (
               <a
                 href={ticket.url}
@@ -677,7 +759,9 @@ function BranchList({ branches }: { branches: BranchInfo[] }) {
         <Row key={branch.name}>
           <div className="flex min-w-0 items-center gap-2">
             <GitBranch className="h-3.5 w-3.5 shrink-0 text-slate-600" />
-            <span className="truncate font-mono text-xs text-slate-200">{branch.name}</span>
+            <span className="truncate font-mono text-xs text-slate-200">
+              {branch.name}
+            </span>
             {branch.isDefault ? (
               <span className="shrink-0 rounded bg-violet-500/15 px-1.5 py-0.5 text-[10px] text-violet-200">
                 default
@@ -689,10 +773,14 @@ function BranchList({ branches }: { branches: BranchInfo[] }) {
           </div>
           <div className="flex shrink-0 items-center gap-3 text-[11px] text-slate-500">
             {branch.lastCommitAt ? (
-              <span suppressHydrationWarning>{formatRelative(branch.lastCommitAt)}</span>
+              <span suppressHydrationWarning>
+                {formatRelative(branch.lastCommitAt)}
+              </span>
             ) : null}
             {branch.sha ? (
-              <span className="font-mono text-slate-600">{branch.sha.slice(0, 7)}</span>
+              <span className="font-mono text-slate-600">
+                {branch.sha.slice(0, 7)}
+              </span>
             ) : null}
           </div>
         </Row>
@@ -709,15 +797,23 @@ function TagList({ tags }: { tags: TagInfo[] }) {
         <Row key={tag.name}>
           <div className="flex min-w-0 items-center gap-2">
             <Tag className="h-3.5 w-3.5 shrink-0 text-slate-600" />
-            <span className="truncate font-mono text-xs text-slate-200">{tag.name}</span>
+            <span className="truncate font-mono text-xs text-slate-200">
+              {tag.name}
+            </span>
             {tag.message ? (
-              <span className="truncate text-[11px] text-slate-500">{tag.message}</span>
+              <span className="truncate text-[11px] text-slate-500">
+                {tag.message}
+              </span>
             ) : null}
           </div>
           <div className="flex shrink-0 items-center gap-3 text-[11px] text-slate-500">
-            {tag.date ? <span suppressHydrationWarning>{formatRelative(tag.date)}</span> : null}
+            {tag.date ? (
+              <span suppressHydrationWarning>{formatRelative(tag.date)}</span>
+            ) : null}
             {tag.sha ? (
-              <span className="font-mono text-slate-600">{tag.sha.slice(0, 7)}</span>
+              <span className="font-mono text-slate-600">
+                {tag.sha.slice(0, 7)}
+              </span>
             ) : null}
           </div>
         </Row>
@@ -735,7 +831,9 @@ function CommitList({ commits }: { commits: CommitInfo[] }) {
           <div className="min-w-0">
             <p className="truncate text-xs text-slate-200">{commit.message}</p>
             <p className="mt-0.5 flex items-center gap-2 text-[11px] text-slate-500">
-              <span className="font-mono text-violet-300/80">{commit.shortSha}</span>
+              <span className="font-mono text-violet-300/80">
+                {commit.shortSha}
+              </span>
               <span>{commit.author ?? "unbekannt"}</span>
             </p>
           </div>
@@ -760,14 +858,17 @@ function CommitList({ commits }: { commits: CommitInfo[] }) {
 }
 
 function ReleaseList({ releases }: { releases: ReleaseInfo[] }) {
-  if (releases.length === 0) return <Empty text="Keine Releases veroeffentlicht." />;
+  if (releases.length === 0)
+    return <Empty text="Keine Releases veroeffentlicht." />;
   return (
     <div>
       {releases.map((release) => (
         <Row key={`${release.tag}-${release.name}`}>
           <div className="flex min-w-0 items-center gap-2">
             <Package className="h-3.5 w-3.5 shrink-0 text-slate-600" />
-            <span className="truncate text-xs text-slate-200">{release.name}</span>
+            <span className="truncate text-xs text-slate-200">
+              {release.name}
+            </span>
             <span className="shrink-0 rounded bg-white/6 px-1.5 py-0.5 font-mono text-[10px] text-slate-400">
               {release.tag}
             </span>
@@ -783,7 +884,9 @@ function ReleaseList({ releases }: { releases: ReleaseInfo[] }) {
             ) : null}
           </div>
           <div className="flex shrink-0 items-center gap-2 text-[11px] text-slate-500">
-            <span suppressHydrationWarning>{formatRelative(release.publishedAt)}</span>
+            <span suppressHydrationWarning>
+              {formatRelative(release.publishedAt)}
+            </span>
             {release.url ? (
               <a
                 href={release.url}
@@ -801,3 +904,58 @@ function ReleaseList({ releases }: { releases: ReleaseInfo[] }) {
     </div>
   );
 }
+
+/**
+ * Teile, die beim letzten Abgleich nicht ankamen.
+ *
+ * Bernstein statt Rot: der Abgleich ist nicht gescheitert, es fehlt nur
+ * etwas – und was danebensteht, ist der letzte gute Stand, keine Null.
+ *
+ * Bis v1.10.1 sah eine nicht geholte Liste genauso aus wie eine leere. Ein
+ * Repository mit 65 Commits meldete "Snapshot aktualisiert: 0 Branches,
+ * 0 Tags", und aus der Oberflaeche war nicht zu erkennen, dass ueberhaupt
+ * etwas schiefgegangen war.
+ */
+function UnvollstaendigerStand({
+  snapshot,
+}: {
+  snapshot: RepoSnapshot | null;
+}) {
+  if (!snapshot) return null;
+
+  const fehlend = asTextRecord(snapshot.missing);
+  // Sortiert: die Reihenfolge im Objekt haengt daran, welcher Aufruf zuerst
+  // gescheitert ist, und das waere bei jedem Abgleich eine andere.
+  const felder = Object.keys(fehlend).sort();
+  if (felder.length === 0) return null;
+
+  return (
+    <div className="rounded-xl border border-amber-500/30 bg-amber-500/10 px-3 py-2.5 text-sm text-amber-100">
+      <p className="flex items-start gap-2">
+        <AlertTriangle className="mt-0.5 h-4 w-4 shrink-0" />
+        <span>
+          Beim letzten Abgleich nicht geholt:{" "}
+          <strong>{felder.join(", ")}</strong>. Dafuer steht hier weiterhin der
+          vorherige Stand
+          {snapshot.completeAt ? (
+            <>
+              {" "}
+              von{" "}
+              <span suppressHydrationWarning>
+                {formatDateTime(snapshot.completeAt)}
+              </span>
+            </>
+          ) : null}
+          .
+        </span>
+      </p>
+      <ul className="mt-2 space-y-0.5 pl-6 text-[11px] text-amber-200/90">
+        {felder.map((feld) => (
+          <li key={feld}>
+            <span className="font-mono">{feld}</span> — {fehlend[feld]}
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+}

src/components/ProjectBoard.tsx

@@ -3,6 +3,7 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
 import {
+  CheckSquare,
   Columns3,
   Database,
   Download,
@@ -16,7 +17,7 @@ import {
   Upload,
   X,
 } from "lucide-react";
-import type { ProjectStatus } from "@prisma/client";
+import type { ProjectStatus, TaskStatus } from "@prisma/client";
 import { BulkBar } from "@/components/BulkBar";
 import { ImportDialog } from "@/components/ImportDialog";
 import { KanbanBoard } from "@/components/KanbanBoard";
@@ -25,9 +26,18 @@ import { ProjectDialog } from "@/components/ProjectDialog";
 import { ProjectList } from "@/components/ProjectList";
 import { Popover } from "@/components/ui/Popover";
 import { STATUS_META, STATUS_ORDER } from "@/lib/status";
+import { TASK_STATUS_META } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 import type { ConnectionSafe, ProjectListItem } from "@/types";
 
+interface TaskHit {
+  projectId: string;
+  taskId: string;
+  title: string;
+  status: string;
+  snippet: string;
+}
+
 interface NoteHit {
   projectId: string;
   noteId: string;
@@ -135,6 +145,7 @@ export function ProjectBoard({
   const [dataMenuOpen, setDataMenuOpen] = useState(false);
   const dataButtonRef = useRef<HTMLButtonElement>(null);
   const [noteHits, setNoteHits] = useState<NoteHit[]>([]);
+  const [taskHits, setTaskHits] = useState<TaskHit[]>([]);
   const [selection, setSelection] = useState<Set<string>>(new Set());
 
   /**
@@ -147,6 +158,7 @@ export function ProjectBoard({
     const needle = query.trim();
     if (needle.length < 2) {
       setNoteHits([]);
+      setTaskHits([]);
       return;
     }
 
@@ -157,8 +169,9 @@ export function ProjectBoard({
           signal: controller.signal,
         });
         if (!response.ok) return;
-        const body = (await response.json()) as { hits: NoteHit[] };
+        const body = (await response.json()) as { hits: NoteHit[]; tasks: TaskHit[] };
         setNoteHits(body.hits ?? []);
+        setTaskHits(body.tasks ?? []);
       } catch {
         // Abgebrochene Anfragen sind der Normalfall beim Tippen.
       }
@@ -171,8 +184,12 @@ export function ProjectBoard({
   }, [query]);
 
   const noteHitProjectIds = useMemo(
-    () => new Set(noteHits.map((hit) => hit.projectId)),
+    () =>
-    [noteHits],
+      new Set([
+        ...noteHits.map((hit) => hit.projectId),
+        ...taskHits.map((hit) => hit.projectId),
+      ]),
+    [noteHits, taskHits],
   );
 
   const counts = useMemo(() => {
@@ -200,7 +217,7 @@ export function ProjectBoard({
         project.repositories.some((repo) =>
           (repo.snapshot?.fullName ?? "").toLowerCase().includes(needle),
         ) ||
-        // Treffer in Notizen kommen vom Server dazu.
+        // Treffer in Notizen und Aufgaben kommen vom Server dazu.
         noteHitProjectIds.has(project.id)
       );
     });
@@ -434,6 +451,60 @@ export function ProjectBoard({
         </div>
       </div>
 
+      {/* Treffer in Aufgaben */}
+      {taskHits.length > 0 ? (
+        <div className="glass fade-up p-4">
+          <h2 className="mb-2.5 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-wider text-slate-400">
+            <CheckSquare className="h-3.5 w-3.5 text-emerald-300" />
+            Treffer in Aufgaben
+            <span className="rounded-full bg-white/6 px-2 py-0.5 tabular-nums text-slate-400">
+              {taskHits.length}
+            </span>
+          </h2>
+          <ul className="space-y-1">
+            {taskHits.slice(0, 8).map((hit) => {
+              const project = projects.find((entry) => entry.id === hit.projectId);
+              const status = TASK_STATUS_META[hit.status as TaskStatus];
+              return (
+                <li key={hit.taskId}>
+                  <Link
+                    href={`/projects/${hit.projectId}`}
+                    className="block rounded-lg px-2.5 py-2 transition-colors hover:bg-white/5"
+                  >
+                    <span className="flex flex-wrap items-baseline gap-x-2">
+                      <span className="text-sm text-slate-200">{hit.title}</span>
+                      <span className="text-[11px] text-slate-500">
+                        · {project?.name ?? "Projekt"}
+                      </span>
+                      {status ? (
+                        <span
+                          className="inline-flex items-center gap-1 text-[11px]"
+                          style={{ color: status.color }}
+                        >
+                          {status.label}
+                        </span>
+                      ) : null}
+                    </span>
+                    {/* Nur wenn die Beschreibung etwas beitraegt – passte
+                        allein der Titel, ist der Ausschnitt leer. */}
+                    {hit.snippet.trim() ? (
+                      <span className="mt-0.5 block text-xs leading-snug text-slate-400">
+                        {highlight(hit.snippet)}
+                      </span>
+                    ) : null}
+                  </Link>
+                </li>
+              );
+            })}
+          </ul>
+          {taskHits.length > 8 ? (
+            <p className="mt-2 px-2.5 text-[11px] text-slate-600">
+              … und {taskHits.length - 8} weitere
+            </p>
+          ) : null}
+        </div>
+      ) : null}
+
       {/* Treffer in Notizen */}
       {noteHits.length > 0 ? (
         <div className="glass fade-up p-4">

src/components/Timeline.tsx

@@ -0,0 +1,126 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { ChevronDown, History, Loader2 } from "lucide-react";
+import { ActivityDayGroups } from "@/components/ActivityRow";
+import { tagesschluessel } from "@/lib/review";
+import type { ReviewDay, ReviewEntry } from "@/types";
+
+/**
+ * Die fortlaufende Zeitleiste.
+ *
+ * Client-Komponente, weil hier nachgeladen wird – das ist der Unterschied
+ * zum Wochenrueckblick, der komplett auf dem Server entsteht.
+ *
+ * Die Buendelung nach Tagen passiert hier im Browser. Das ist unbedenklich,
+ * weil tagesschluessel eine feste Zeitzone benutzt: Server und Browser kommen
+ * damit auf denselben Kalendertag, und die erste Seite hydriert ohne
+ * Abweichung.
+ */
+export function Timeline({
+  erste,
+  weitere: gabWeitere,
+}: {
+  erste: ReviewEntry[];
+  weitere: boolean;
+}) {
+  const [eintraege, setEintraege] = useState(erste);
+  const [weitere, setWeitere] = useState(gabWeitere);
+  const [laedt, setLaedt] = useState(false);
+  const [fehler, setFehler] = useState<string | null>(null);
+
+  const tage: ReviewDay[] = useMemo(() => {
+    // Map behaelt die Einfuegereihenfolge – die Eintraege kommen schon
+    // absteigend, also stimmt die Reihenfolge der Tage von selbst.
+    const nachTag = new Map<string, ReviewEntry[]>();
+    for (const eintrag of eintraege) {
+      const schluessel = tagesschluessel(new Date(eintrag.createdAt));
+      const liste = nachTag.get(schluessel) ?? [];
+      liste.push(eintrag);
+      nachTag.set(schluessel, liste);
+    }
+    return [...nachTag.entries()].map(([tag, liste]) => ({ tag, eintraege: liste }));
+  }, [eintraege]);
+
+  async function mehr() {
+    const letzter = eintraege[eintraege.length - 1];
+    if (!letzter) return;
+
+    setLaedt(true);
+    setFehler(null);
+    try {
+      const antwort = await fetch(
+        `/api/activity?vor=${encodeURIComponent(letzter.createdAt)}&id=${encodeURIComponent(letzter.id)}`,
+      );
+      if (!antwort.ok) throw new Error("Verlauf konnte nicht geladen werden.");
+      const nutzlast = (await antwort.json()) as {
+        activities: ReviewEntry[];
+        weitere: boolean;
+      };
+
+      /**
+       * Gegen Dubletten absichern, auch wenn der Cursor sie ausschliesst:
+       * ein zweimal gedrueckter Knopf oder ein wiederholter Aufruf soll
+       * keine Zeile verdoppeln, und React braucht eindeutige Schluessel.
+       */
+      setEintraege((bisher) => {
+        const bekannt = new Set(bisher.map((eintrag) => eintrag.id));
+        return [...bisher, ...nutzlast.activities.filter((eintrag) => !bekannt.has(eintrag.id))];
+      });
+      setWeitere(nutzlast.weitere);
+    } catch (gefangen) {
+      setFehler(gefangen instanceof Error ? gefangen.message : String(gefangen));
+    } finally {
+      setLaedt(false);
+    }
+  }
+
+  if (eintraege.length === 0) {
+    return (
+      <div className="glass fade-up flex flex-col items-center justify-center gap-4 px-6 py-16 text-center">
+        <span className="grid h-14 w-14 place-items-center rounded-2xl bg-gradient-to-br from-violet-500/25 to-cyan-400/20 text-violet-200">
+          <History className="h-6 w-6" />
+        </span>
+        <div>
+          <h2 className="text-lg font-semibold text-white">Noch kein Verlauf</h2>
+          <p className="mt-1 max-w-md text-sm text-slate-400">
+            Sobald du ein Projekt anlegst, Aufgaben verschiebst oder Notizen schreibst, steht es
+            hier.
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-5">
+      {/* Die Jahreszahl gehoert dazu: eine Zeitleiste reicht weit zurueck,
+          und "3. Januar" allein sagt dann nicht genug. */}
+      <ActivityDayGroups tage={tage} mitJahr />
+
+      {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-col items-center gap-2 pt-1">
+        {weitere ? (
+          <button type="button" className="btn btn-ghost" onClick={mehr} disabled={laedt}>
+            {laedt ? (
+              <Loader2 className="h-4 w-4 animate-spin" />
+            ) : (
+              <ChevronDown className="h-4 w-4" />
+            )}
+            Ältere laden
+          </button>
+        ) : (
+          <p className="text-xs text-slate-600">Das war alles.</p>
+        )}
+        <p className="text-[11px] text-slate-600 tabular-nums">
+          {eintraege.length} {eintraege.length === 1 ? "Vorgang" : "Vorgänge"} geladen
+        </p>
+      </div>
+    </div>
+  );
+}

src/components/WeeklyReview.tsx

@@ -0,0 +1,108 @@
+import { CalendarRange, CheckSquare, FolderGit2, NotebookPen, Plus } from "lucide-react";
+import { ActivityDayGroups } from "@/components/ActivityRow";
+import type { Kennzahlen } from "@/lib/review";
+import type { ReviewDay } from "@/types";
+
+/**
+ * Der Wochenrueckblick.
+ *
+ * Bewusst eine Server-Komponente: es gibt nichts zu bedienen, alles steht
+ * beim Rendern fest. Das spart dem Browser den ganzen Verlauf als JavaScript.
+ *
+ * Die Tage kommen fertig gebuendelt und in der richtigen Reihenfolge – die
+ * Zuordnung "welcher Kalendertag" haengt an der Zeitzone und gehoert
+ * deshalb auf den Server.
+ */
+
+export function WeeklyReview({
+  tage,
+  kennzahlen,
+  istDieseWoche,
+}: {
+  tage: ReviewDay[];
+  /** Fertig gezaehlt vom Server – die Anzeige rechnet nichts nach. */
+  kennzahlen: Kennzahlen;
+  istDieseWoche: boolean;
+}) {
+  const { gesamt, projekte, erledigt, neueAufgaben, notizen } = kennzahlen;
+
+  if (gesamt === 0) {
+    return (
+      <div className="glass fade-up flex flex-col items-center justify-center gap-4 px-6 py-16 text-center">
+        <span className="grid h-14 w-14 place-items-center rounded-2xl bg-gradient-to-br from-violet-500/25 to-cyan-400/20 text-violet-200">
+          <CalendarRange className="h-6 w-6" />
+        </span>
+        <div>
+          <h2 className="text-lg font-semibold text-white">
+            {istDieseWoche ? "Diese Woche war es still" : "In dieser Woche ist nichts passiert"}
+          </h2>
+          <p className="mt-1 max-w-md text-sm text-slate-400">
+            {istDieseWoche
+              ? "Sobald du Aufgaben abhakst, Notizen schreibst oder etwas gepusht wird, steht es hier."
+              : "Vielleicht lohnt ein Blick auf eine frühere Woche."}
+          </p>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-5">
+      {/* Kennzahlen */}
+      <div className="grid grid-cols-2 gap-3 sm:gap-4 lg:grid-cols-4">
+        <Kennzahl label="Vorgänge" wert={gesamt} icon={CalendarRange} color="#a78bfa" />
+        <Kennzahl label="Projekte berührt" wert={projekte} icon={FolderGit2} color="#38bdf8" />
+        <Kennzahl label="Aufgaben erledigt" wert={erledigt} icon={CheckSquare} color="#34d399" />
+        <Kennzahl label="Neue Aufgaben" wert={neueAufgaben} icon={Plus} color="#fbbf24" />
+      </div>
+
+      {notizen > 0 ? (
+        <p className="flex items-center gap-1.5 px-1 text-xs text-slate-500">
+          <NotebookPen className="h-3.5 w-3.5" />
+          Dazu {notizen} {notizen === 1 ? "neue Notiz" : "neue Notizen"}.
+        </p>
+      ) : null}
+
+      {/* Verlauf nach Tagen – dieselbe Darstellung wie in der Zeitleiste. */}
+      <ActivityDayGroups tage={tage} />
+    </div>
+  );
+}
+
+function Kennzahl({
+  label,
+  wert,
+  icon: Icon,
+  color,
+}: {
+  label: string;
+  wert: number;
+  icon: typeof CalendarRange;
+  color: string;
+}) {
+  return (
+    <div className="glass relative overflow-hidden p-3 sm:p-4">
+      <div
+        className="pointer-events-none absolute -right-6 -top-8 h-24 w-24 rounded-full opacity-25 blur-2xl"
+        style={{ backgroundColor: color }}
+        aria-hidden="true"
+      />
+      <div className="flex items-start justify-between gap-2">
+        <div className="min-w-0">
+          <p className="text-[11px] font-semibold uppercase leading-tight tracking-[0.14em] text-slate-500">
+            {label}
+          </p>
+          <p className="mt-1.5 text-2xl font-semibold tabular-nums text-white sm:text-3xl">
+            {wert}
+          </p>
+        </div>
+        <span
+          className="grid h-8 w-8 shrink-0 place-items-center rounded-xl sm:h-9 sm:w-9"
+          style={{ backgroundColor: `${color}1f`, color }}
+        >
+          <Icon className="h-4 w-4" />
+        </span>
+      </div>
+    </div>
+  );
+}

src/components/activityKinds.ts

@@ -0,0 +1,43 @@
+import {
+  AlertTriangle,
+  ArrowRight,
+  Download,
+  GitCommitHorizontal,
+  Link2,
+  NotebookPen,
+  Pencil,
+  Plus,
+  Signpost,
+  Sparkles,
+  Trash2,
+} from "lucide-react";
+import type { ActivityKind } from "@prisma/client";
+
+/**
+ * Symbol und Farbe je Art eines Verlaufseintrags.
+ *
+ * Ausgelagert, weil sie inzwischen an zwei Stellen gebraucht werden: im
+ * Verlauf eines Projekts und im Wochenrueckblick ueber alle Projekte. Zwei
+ * Kopien liefen beim naechsten neuen Eintragstyp auseinander.
+ *
+ * Bewusst ohne "use client" und ohne Prisma-Zugriff – nur Typen und
+ * Symbole, damit beide Seiten es importieren koennen.
+ */
+export const ACTIVITY_KINDS: Record<
+  ActivityKind,
+  { icon: typeof Sparkles; color: string; label: string }
+> = {
+  PROJECT_CREATED: { icon: Sparkles, color: "text-violet-300", label: "Projekt angelegt" },
+  PROJECT_UPDATED: { icon: Pencil, color: "text-slate-400", label: "Projekt bearbeitet" },
+  STATUS_CHANGED: { icon: Signpost, color: "text-cyan-300", label: "Status geändert" },
+  NOTE_ADDED: { icon: NotebookPen, color: "text-blue-300", label: "Notiz" },
+  NOTE_UPDATED: { icon: Pencil, color: "text-blue-300", label: "Notiz bearbeitet" },
+  NOTE_DELETED: { icon: Trash2, color: "text-rose-300", label: "Notiz gelöscht" },
+  TASK_ADDED: { icon: Plus, color: "text-emerald-300", label: "Aufgabe angelegt" },
+  TASK_MOVED: { icon: ArrowRight, color: "text-violet-300", label: "Aufgabe verschoben" },
+  TASK_DELETED: { icon: Trash2, color: "text-rose-300", label: "Aufgabe gelöscht" },
+  TASKS_IMPORTED: { icon: Download, color: "text-amber-300", label: "Aufgaben übernommen" },
+  REPO_LINKED: { icon: Link2, color: "text-cyan-300", label: "Repository verknüpft" },
+  REPO_COMMITS: { icon: GitCommitHorizontal, color: "text-emerald-300", label: "Commits" },
+  SYNC_FAILED: { icon: AlertTriangle, color: "text-rose-300", label: "Abgleich fehlgeschlagen" },
+};

src/components/admin/AdminManager.tsx

@@ -5,6 +5,7 @@ import { useRouter } from "next/navigation";
 import {
   Ban,
   CheckCircle2,
+  Columns3,
   Database,
   Download,
   Fingerprint,
@@ -74,6 +75,12 @@ export interface AdminData {
     /** Wie viele Konten ueberhaupt auf Stillstand hoeren. */
     listeners: number;
   };
+  tasks: {
+    /** Karten je Spalte im Aufgabenbrett; 0 = ohne Begrenzung. */
+    columnLimit: number;
+    /** Laengste Spalte ueber alle Projekte – ohne die ist die Zahl blind. */
+    laengsteSpalte: number;
+  };
 }
 
 type Notice = { ok: boolean; text: string } | null;
@@ -195,6 +202,7 @@ export function AdminManager({ data }: { data: AdminData }) {
 
       <AutoSyncSection data={data.autoSync} />
       <StaleSection data={data.stale} />
+      <TaskLimitSection data={data.tasks} />
 
       {/* ── Instanz ─────────────────────────────────────── */}
       <section className="glass p-5">
@@ -1099,3 +1107,128 @@ function UserDialog({
     </Modal>
   );
 }
+
+const SPALTEN_OPTIONEN = [0, 5, 10, 15, 20, 30, 50];
+
+/**
+ * Wie viele Karten eine Spalte des Aufgabenbretts hoechstens zeigt.
+ *
+ * Begrenzt wird nur die Anzeige: der Rest steht hinter einem Knopf, und die
+ * Reihenfolge wird weiterhin ueber die vollstaendige Spalte gespeichert.
+ * Eine Aufgabe verschwindet hier also nirgends – sie ist nur einen Klick
+ * weiter weg.
+ */
+function TaskLimitSection({ data }: { data: AdminData["tasks"] }) {
+  const router = useRouter();
+  const [limit, setLimit] = useState(data.columnLimit);
+  const [busy, setBusy] = useState(false);
+  const [notice, setNotice] = useState<Notice>(null);
+
+  async function save(value: number) {
+    setBusy(true);
+    setNotice(null);
+    try {
+      const response = await fetch("/api/admin/settings", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ taskColumnLimit: value }),
+      });
+      const body = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(body.error ?? "Speichern fehlgeschlagen.");
+      setNotice({ ok: true, text: "Gespeichert." });
+      router.refresh();
+    } catch (caught) {
+      setLimit(data.columnLimit);
+      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const greift = limit > 0 && data.laengsteSpalte > limit;
+
+  return (
+    <section className="glass p-5">
+      <div className="mb-4 flex items-start gap-3">
+        <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-violet-500/12 text-violet-300">
+          <Columns3 className="h-4 w-4" />
+        </span>
+        <div>
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
+            Aufgabenbrett
+          </h2>
+          <p className="mt-1 max-w-xl text-sm text-slate-400">
+            Wie viele Karten eine Spalte hoechstens zeigt. Was darueber hinausgeht, kommt
+            hinter einen Knopf – verborgen wird nichts, und die Reihenfolge bleibt
+            vollstaendig gespeichert. Gilt fuer alle Projekte.
+          </p>
+        </div>
+      </div>
+
+      <div className="grid gap-4 sm:grid-cols-2">
+        <div>
+          <label className="field-label" htmlFor="task-column-limit">
+            Karten je Spalte
+          </label>
+          <select
+            id="task-column-limit"
+            className="field"
+            value={limit}
+            disabled={busy}
+            onChange={(event) => {
+              const value = Number(event.target.value);
+              setLimit(value);
+              void save(value);
+            }}
+          >
+            {SPALTEN_OPTIONEN.map((value) => (
+              <option key={value} value={value}>
+                {value === 0 ? "ohne Begrenzung" : `hoechstens ${value}`}
+              </option>
+            ))}
+          </select>
+        </div>
+
+        <dl className="grid grid-cols-2 gap-3">
+          <div className="glass-soft px-3 py-2.5">
+            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
+              Laengste Spalte
+            </dt>
+            <dd className="mt-1 text-sm tabular-nums text-slate-200">
+              {data.laengsteSpalte}
+            </dd>
+          </div>
+          <div className="glass-soft px-3 py-2.5">
+            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
+              Wirkung
+            </dt>
+            <dd className="mt-1 text-sm text-slate-200">
+              {limit === 0 ? "aus" : greift ? "greift" : "noch nicht"}
+            </dd>
+          </div>
+        </dl>
+      </div>
+
+      <p className="mt-3 text-[11px] text-slate-600">
+        {limit === 0
+          ? "Jede Spalte zeigt alles. Bei langen Listen wird das Brett unuebersichtlich."
+          : greift
+            ? "Mindestens eine Spalte ist laenger als die Grenze – dort erscheint der Knopf."
+            : "Derzeit reicht keine Spalte an die Grenze heran; sichtbar wird die Einstellung erst danach."}
+      </p>
+
+      {notice ? (
+        <p
+          className={cn(
+            "mt-3 rounded-lg border px-3 py-2 text-sm",
+            notice.ok
+              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
+              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
+          )}
+        >
+          {notice.text}
+        </p>
+      ) : null}
+    </section>
+  );
+}

src/components/tasks/TaskBoard.tsx

@@ -18,11 +18,11 @@ import {
 import { restrictToWindowEdges } from "@dnd-kit/modifiers";
 import { SortableContext, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
-import { CheckSquare, Loader2, Plus } from "lucide-react";
+import { CheckSquare, ChevronDown, ChevronUp, Loader2, Plus } from "lucide-react";
 import type { Task, TaskStatus } from "@prisma/client";
 import { TaskCard } from "@/components/tasks/TaskCard";
 import { TaskDialog } from "@/components/tasks/TaskDialog";
-import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
+import { TASK_STATUS_META, TASK_STATUS_ORDER, spaltenAnzeige } from "@/lib/tasks";
 import { cn } from "@/lib/utils";
 
 type Columns = Record<TaskStatus, Task[]>;
@@ -48,10 +48,13 @@ export function TaskBoard({
   projectId,
   tasks,
   progressFromTasks,
+  columnLimit = 0,
 }: {
   projectId: string;
   tasks: Task[];
   progressFromTasks: boolean;
+  /** Karten je Spalte; 0 = ohne Begrenzung. Kommt aus den Admin-Einstellungen. */
+  columnLimit?: number;
 }) {
   const router = useRouter();
   const [columns, setColumns] = useState<Columns>(() => group(tasks));
@@ -224,6 +227,7 @@ export function TaskBoard({
               key={status}
               status={status}
               tasks={columns[status]}
+              limit={columnLimit}
               onAdd={() => setCreatingIn(status)}
               onEdit={setEditing}
             />
@@ -252,16 +256,24 @@ export function TaskBoard({
 function TaskColumn({
   status,
   tasks,
+  limit,
   onAdd,
   onEdit,
 }: {
   status: TaskStatus;
   tasks: Task[];
+  limit: number;
   onAdd: () => void;
   onEdit: (task: Task) => void;
 }) {
   const meta = TASK_STATUS_META[status];
   const { setNodeRef, isOver } = useDroppable({ id: status });
+  const [entfaltet, setEntfaltet] = useState(false);
+
+  // Nur die Anzeige wird gekuerzt – `tasks` bleibt oben vollstaendig, sonst
+  // wuerde das Umsortieren die verborgenen Aufgaben aus dem Brett loeschen.
+  const { sichtbar, verborgen } = spaltenAnzeige(tasks.length, limit, entfaltet);
+  const gezeigt = tasks.slice(0, sichtbar);
 
   return (
     <div
@@ -284,12 +296,14 @@ function TaskColumn({
         <span className="ml-auto text-[10px] tabular-nums text-slate-600">{tasks.length}</span>
       </div>
 
+      {/* Nur die gezeigten Karten stehen im SortableContext – was nicht im
+          DOM ist, kann dnd-kit ohnehin nicht treffen. */}
       <SortableContext
-        items={tasks.map((task) => task.id)}
+        items={gezeigt.map((task) => task.id)}
         strategy={verticalListSortingStrategy}
       >
         <div className="flex flex-1 flex-col gap-1.5">
-          {tasks.map((task) => (
+          {gezeigt.map((task) => (
             <SortableTask key={task.id} task={task} onEdit={onEdit} />
           ))}
           {tasks.length === 0 ? (
@@ -300,6 +314,27 @@ function TaskColumn({
         </div>
       </SortableContext>
 
+      {verborgen > 0 || entfaltet ? (
+        <button
+          type="button"
+          onClick={() => setEntfaltet((vorher) => !vorher)}
+          aria-expanded={entfaltet}
+          className="mt-1.5 flex items-center justify-center gap-1 rounded-lg border border-dashed border-white/10 px-2 py-1.5 text-[11px] text-slate-500 transition-colors hover:border-white/20 hover:text-slate-300"
+        >
+          {entfaltet ? (
+            <>
+              <ChevronUp className="h-3 w-3" />
+              weniger anzeigen
+            </>
+          ) : (
+            <>
+              <ChevronDown className="h-3 w-3" />
+              {verborgen} weitere anzeigen
+            </>
+          )}
+        </button>
+      ) : null}
+
       <button
         type="button"
         onClick={onAdd}

src/components/tasks/TaskCard.test.tsx

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { Task } from "@prisma/client";
+import { TaskCard } from "./TaskCard";
+
+/**
+ * Die Karte ist die einzige Stelle im Projekt, an der eine Aufgabe im
+ * Vorbeigehen zu sehen ist – der Bearbeiten-Dialog verlangt einen Klick.
+ * Steht die Verknuepfung nur dort, weiss niemand vorher, welche Aufgabe
+ * ein Issue hat.
+ *
+ * Serverseitig gerendert wie bei Markdown.test.tsx: es geht um das
+ * erzeugte Markup, nicht um Verhalten im Browser.
+ */
+function aufgabe(felder: Partial<Task> = {}): Task {
+  return {
+    id: "t1",
+    projectId: "p1",
+    title: "Etwas tun",
+    description: null,
+    status: "TODO",
+    position: 0,
+    dueDate: null,
+    labels: [],
+    recurrence: null,
+    sourceIssue: null,
+    sourceUrl: null,
+    sourceRepositoryId: null,
+    createdAt: new Date("2026-08-18T10:00:00Z"),
+    updatedAt: new Date("2026-08-18T10:00:00Z"),
+    ...felder,
+  } as Task;
+}
+
+const markup = (task: Task) => renderToStaticMarkup(<TaskCard task={task} />);
+
+describe("Kennzeichen fuer ein verknuepftes Issue", () => {
+  it("zeigt die Nummer, sobald eine Aufgabe an einem Issue haengt", () => {
+    const html = markup(aufgabe({ sourceIssue: 42 }));
+    expect(html).toContain("#42");
+    expect(html).toContain("Verkn");
+  });
+
+  it("erscheint auch ohne Beschreibung, Datum und Labels", () => {
+    // Der eigentliche Fallstrick: die Fusszeile der Karte wird nur
+    // gerendert, wenn es etwas zu zeigen gibt. Faellt die Verknuepfung aus
+    // dieser Bedingung heraus, bleibt genau die nackte Aufgabe unbeschriftet
+    // – und das ist der haeufige Fall bei einer aus einem Issue erzeugten.
+    const html = markup(
+      aufgabe({ sourceIssue: 7, description: null, dueDate: null, labels: [], recurrence: null }),
+    );
+    expect(html).toContain("#7");
+  });
+
+  it("bleibt weg, wenn keine Verknuepfung besteht", () => {
+    const html = markup(aufgabe({ description: "Text" }));
+    expect(html).not.toContain("Verkn");
+  });
+
+  it("bleibt auf einer erledigten Aufgabe sichtbar", () => {
+    // Die erledigte Karte streicht ihren Titel durch; das Kennzeichen bleibt
+    // in voller Helligkeit. Abzudunkeln war versucht und wieder verworfen –
+    // axe-core rechnete es als Kontrastverstoss ab (10px Text, 3,2:1).
+    // Dass hier ein Issue mitgeschlossen wurde, ist ohnehin gerade dann die
+    // interessante Auskunft.
+    const html = markup(aufgabe({ sourceIssue: 5, status: "DONE" }));
+    expect(html).toContain("#5");
+  });
+
+  it("baut keinen Link in die Karte", () => {
+    // Die Karte steckt in einem <button>; ein <a> darin waere ungueltiges
+    // Markup und im Browser nicht verlaesslich anklickbar.
+    const html = markup(aufgabe({ sourceIssue: 42, sourceUrl: "https://example.com/issues/42" }));
+    expect(html).not.toContain("<a ");
+  });
+
+  it("nennt die Verknuepfung auch fuer Vorlesesoftware", () => {
+    // "#42" allein ergibt vorgelesen keinen Sinn.
+    const html = markup(aufgabe({ sourceIssue: 42 }));
+    expect(html).toMatch(/sr-only[^>]*>Verkn/);
+  });
+});

src/components/tasks/TaskCard.tsx

@@ -1,6 +1,12 @@
 "use client";
 
-import { AlignLeft, CalendarClock, GripVertical, Repeat } from "lucide-react";
+import {
+  AlignLeft,
+  CalendarClock,
+  GitPullRequestArrow,
+  GripVertical,
+  Repeat,
+} from "lucide-react";
 import type { Task } from "@prisma/client";
 import { RECURRENCE_META } from "@/lib/tasks";
 import { cn, formatDate } from "@/lib/utils";
@@ -70,8 +76,26 @@ export function TaskCard({
             {task.title}
           </p>
 
-          {(task.description || task.dueDate || task.recurrence || task.labels.length > 0) && (
+          {(task.description ||
+            task.dueDate ||
+            task.recurrence ||
+            task.sourceIssue ||
+            task.labels.length > 0) && (
             <div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-[10px]">
+              {/* Steht vorn, damit sich eine Spalte danach ueberfliegen laesst.
+                  Bewusst kein Link: die Karte steckt in einem <button>, und ein
+                  <a> darin waere ungueltig. Der Weg zum Issue fuehrt ueber den
+                  Bearbeiten-Dialog, der ihn ohnehin anbietet. */}
+              {task.sourceIssue ? (
+                <span
+                  className="inline-flex items-center gap-1 text-violet-300"
+                  title={`Verknüpft mit Issue #${task.sourceIssue}`}
+                >
+                  <GitPullRequestArrow className="h-2.5 w-2.5" aria-hidden />
+                  <span className="sr-only">Verknüpft mit </span>#{task.sourceIssue}
+                </span>
+              ) : null}
+
               {task.description ? (
                 <AlignLeft className="h-2.5 w-2.5 text-slate-600" aria-label="hat Beschreibung" />
               ) : null}

src/components/tasks/TaskOverview.tsx

@@ -10,7 +10,9 @@ import {
   Loader2,
   Plus,
   Repeat,
+  Search,
   Square,
+  X,
 } from "lucide-react";
 import type { TaskStatus } from "@prisma/client";
 import { QuickCapture } from "@/components/QuickCapture";
@@ -42,6 +44,7 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
   const router = useRouter();
   const [statusFilter, setStatusFilter] = useState<TaskStatus[]>([]);
   const [projektFilter, setProjektFilter] = useState("");
+  const [suche, setSuche] = useState("");
   const [zeigeErledigte, setZeigeErledigte] = useState(false);
   const [erfassenOffen, setErfassenOffen] = useState(false);
   const [laufend, setLaufend] = useState<Set<string>>(new Set());
@@ -63,16 +66,34 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
   }, [tasks]);
 
   const sichtbar = useMemo(() => {
+    const nadel = suche.toLowerCase().trim();
+
     return tasks.filter((task) => {
       // Erledigtes fuellt die Liste sonst mit dem, was gerade nicht ansteht.
-      if (!zeigeErledigte && task.status === "DONE" && !statusFilter.includes("DONE")) {
+      // Wer allerdings sucht, sucht auch in Erledigtem – sonst findet man
+      // die Aufgabe von letzter Woche nicht wieder.
+      if (
+        !zeigeErledigte &&
+        !nadel &&
+        task.status === "DONE" &&
+        !statusFilter.includes("DONE")
+      ) {
         return false;
       }
       if (statusFilter.length > 0 && !statusFilter.includes(task.status)) return false;
       if (projektFilter && task.project.id !== projektFilter) return false;
-      return true;
+      if (!nadel) return true;
+
+      // Die Aufgaben liegen hier ohnehin alle vor – das filtert ohne
+      // zusaetzliche Abfrage und ohne Verzoegerung beim Tippen.
+      return (
+        task.title.toLowerCase().includes(nadel) ||
+        (task.description ?? "").toLowerCase().includes(nadel) ||
+        task.labels.some((label) => label.toLowerCase().includes(nadel)) ||
+        task.project.name.toLowerCase().includes(nadel)
+      );
     });
-  }, [tasks, statusFilter, projektFilter, zeigeErledigte]);
+  }, [tasks, statusFilter, projektFilter, zeigeErledigte, suche]);
 
   const faecher = useMemo(() => {
     return DUE_BUCKET_ORDER.map((bucket) => ({
@@ -155,6 +176,27 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
 
       {/* Steuerleiste */}
       <div className="glass flex flex-col gap-3 p-3 sm:p-4">
+        <div className="relative">
+          <Search className="pointer-events-none absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-slate-500" />
+          <input
+            className="field pl-9"
+            placeholder="Aufgaben durchsuchen – Titel, Beschreibung, Labels…"
+            value={suche}
+            onChange={(event) => setSuche(event.target.value)}
+            aria-label="Aufgaben durchsuchen"
+          />
+          {suche ? (
+            <button
+              type="button"
+              onClick={() => setSuche("")}
+              className="absolute right-2 top-1/2 -translate-y-1/2 rounded p-1 text-slate-500 hover:text-white"
+              aria-label="Suche zuruecksetzen"
+            >
+              <X className="h-3.5 w-3.5" />
+            </button>
+          ) : null}
+        </div>
+
         <div className="flex flex-wrap items-center gap-2">
           {TASK_STATUS_ORDER.map((status) => {
             const meta = TASK_STATUS_META[status];
@@ -220,11 +262,17 @@ export function TaskOverview({ tasks }: { tasks: TaskOverviewItem[] }) {
           </span>
           <div>
             <h2 className="text-lg font-semibold text-white">
-              {tasks.length === 0 ? "Noch keine Aufgaben" : "Nichts offen"}
+              {tasks.length === 0
+                ? "Noch keine Aufgaben"
+                : suche.trim()
+                  ? "Keine Treffer"
+                  : "Nichts offen"}
             </h2>
             <p className="mt-1 max-w-md text-sm text-slate-400">
               {tasks.length === 0
                 ? "Aufgaben entstehen im Projekt oder hier über „Neue Aufgabe“."
+                : suche.trim()
+                  ? `Keine Aufgabe passt zu „${suche.trim()}“ – gesucht wird in Titel, Beschreibung, Labels und Projektname.`
                   : "Alles abgehakt, was zu den Filtern passt."}
             </p>
           </div>

src/lib/changelog.ts

@@ -41,6 +41,130 @@ export const KIND_META: Record<ChangeKind, { label: string; className: string }>
 };
 
 export const CHANGELOG: Release[] = [
+  {
+    version: "1.11.0",
+    date: "2026-09-10",
+    headline: "Der Abgleich sagt, was er nicht holen konnte — und verliert dabei nichts mehr.",
+    changes: [
+      {
+        kind: "behoben",
+        text:
+          "Ein fehlgeschlagener Teil-Abruf sah aus wie ein leeres Ergebnis. Ein Repository " +
+          "mit 65 Commits meldete „Snapshot aktualisiert: 0 Branches, 0 Tags“ und überschrieb " +
+          "dabei den letzten guten Stand. Jetzt steht am Repository, welcher Teil nicht kam " +
+          "und woran es lag — und die vorhandenen Daten bleiben stehen.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Die Commit-Heatmap kannte bei Gitea nur die jüngsten 50 Commits und gab deren " +
+          "ältesten als Anfang des Zeitraums aus. Grund war eine Seitengröße, die angefragt " +
+          "statt gemessen wurde: Gitea deckelt jede Antwort auf 50, egal was dasteht. Bei " +
+          "einem Repository mit 76 Commits fehlte damit ein Drittel.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Ein Abruf, der in eine Zeitüberschreitung läuft, wird einmal nachgeschlagen — " +
+          "einzeln statt zusammen mit den sieben anderen. Bei fehlenden Rechten oder einem " +
+          "Rate-Limit passiert das bewusst nicht; das wird durch Wiederholen nicht besser.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Das Aufgabenbrett zeigt je Spalte höchstens so viele Karten, wie unter " +
+          "Admin-Einstellungen eingestellt ist. Der Rest steht hinter „n weitere anzeigen“; " +
+          "die Zahl an der Spalte nennt weiterhin alle.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Eine Aufgabenkarte trägt die Nummer ihres verknüpften Git-Issues. Bisher stand " +
+          "die Verknüpfung nur im Bearbeiten-Dialog.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Rechte, die eine Git-Verbindung braucht, stehen Aufruf für Aufruf in der " +
+          "README — getrennt nach reinem Abgleich und zusätzlicher Issue-Anbindung. Der " +
+          "Hinweis unter dem Token-Feld nannte die Rechte für Actions nicht, ohne die bei " +
+          "GitHub kein CI-Zustand ankommt.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Ein unbrauchbarer Wert in GIT_API_TIMEOUT_MS legte den ganzen Abgleich still: " +
+          "eine leere oder unlesbare Angabe wurde zu 0 ms, und damit brach jeder Aufruf ab, " +
+          "bevor er begann. Jetzt gilt die Vorgabe, mit Warnung im Log.",
+      },
+    ],
+  },
+  {
+    version: "1.10.1",
+    date: "2026-08-18",
+    headline: "Sichtbar, welche Aufgabe ein Issue hat — und nachlesbar, was ein Token dafür braucht.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Auf dem Aufgabenbrett eines Projekts trägt eine Karte die Nummer ihres " +
+          "verknüpften Git-Issues. Bisher stand die Verknüpfung nur im Bearbeiten-Dialog " +
+          "und in der projektübergreifenden Übersicht — welche Aufgabe schon ein Issue " +
+          "hat, war im Vorbeigehen nicht zu sehen.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Rechte einer Git-Verbindung stehen jetzt Aufruf für Aufruf in der README: " +
+          "je System eine Tabelle aus Endpunkt, Zweck und benötigtem Recht. Getrennt nach " +
+          "reinem Abgleich und zusätzlicher Issue-Anbindung, damit erkennbar ist, was sich " +
+          "weglassen lässt. Bei GitLab ist belegt, dass es unterhalb von „api“ keinen " +
+          "Schreibzugriff auf Issues gibt.",
+      },
+      {
+        kind: "behoben",
+        text:
+          "Der Hinweis unter dem Token-Feld nannte die Rechte für Actions nicht, obwohl " +
+          "der CI-Zustand bei GitHub genau daran hängt. Wer sich daran hielt, sah keinen " +
+          "Build-Status.",
+      },
+    ],
+  },
+  {
+    version: "1.10.0",
+    date: "2026-08-18",
+    headline: "Rückblick, Zeitleiste und eine Suche, die auch Aufgaben findet.",
+    changes: [
+      {
+        kind: "neu",
+        text:
+          "Wochenrückblick über alle Projekte: Kennzahlen der Woche und darunter die " +
+          "Vorgänge nach Tagen gebündelt. Blättern in frühere Wochen inbegriffen. " +
+          "Erreichbar über die Schnellsuche und einen Verweis vom Dashboard.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Globale Zeitleiste: derselbe Verlauf, aber fortlaufend und ohne Wochengrenze, " +
+          "mit Nachladen älterer Einträge. Geblättert wird per Cursor — bei mehreren " +
+          "Einträgen im selben Augenblick verliert oder verdoppelt das keine Zeilen.",
+      },
+      {
+        kind: "neu",
+        text:
+          "Das Aufgabendashboard hat ein Suchfeld über Titel, Beschreibung, Labels und " +
+          "Projektname. Wer sucht, sucht dabei auch in Erledigtem — sonst findet man die " +
+          "Aufgabe von letzter Woche nicht wieder.",
+      },
+      {
+        kind: "besser",
+        text:
+          "Die Volltextsuche kannte bisher nur Notizen und findet jetzt auch Aufgaben — " +
+          "mit denselben deutschen Stammformen: „Rechnung“ findet „Rechnungen“. Treffer " +
+          "erscheinen im Projektbrett und in der Schnellsuche.",
+      },
+    ],
+  },
   {
     version: "1.9.0",
     date: "2026-08-17",

src/lib/git/calendar.test.ts

@@ -18,6 +18,19 @@ import {
 const JETZT = new Date("2026-07-26T12:00:00.000Z");
 const TAG = 86_400_000;
 
+/**
+ * Eine Quelle, die es nur eine Seite lang gibt.
+ *
+ * Diese Tests pruefen das Zaehlen und Filtern, nicht das Blaettern. Ihr
+ * Fixture lieferte urspruenglich fuer *jede* Seite dieselben Daten und hielt
+ * nur deshalb an, weil die alte Regel eine kurze Seite fuer die letzte hielt
+ * – genau der Fehler, um den es hier geht. Kein Server verhaelt sich so;
+ * nach der letzten Seite kommt nichts mehr.
+ */
+function eineSeite(daten: Array<string | null>) {
+  return async (seite: number) => (seite === 1 ? daten : []);
+}
+
 /** Erzeugt n Commit-Zeitpunkte, beginnend vor `abTagen` Tagen, einer je Tag. */
 function commits(anzahl: number, abTagen: number): string[] {
   return Array.from({ length: anzahl }, (_, index) =>
@@ -45,14 +58,14 @@ describe("calendarByPaging", () => {
 
   it("zaehlt mehrere Commits desselben Tages zusammen", async () => {
     const heute = JETZT.toISOString();
-    const kalender = await calendarByPaging(async () => [heute, heute, heute], JETZT);
+    const kalender = await calendarByPaging(eineSeite([heute, heute, heute]), JETZT);
     expect(kalender?.days["2026-07-26"]).toBe(3);
     expect(calendarTotal(kalender!)).toBe(3);
   });
 
   it("beginnt beim aeltesten bekannten Commit, nicht vor einem Jahr", async () => {
     // Nur eine halbe Seite, zehn Tage zurueck: alles davor ist unbekannt.
-    const kalender = await calendarByPaging(async () => commits(10, 0), JETZT);
+    const kalender = await calendarByPaging(eineSeite(commits(10, 0)), JETZT);
     expect(kalender?.from).toBe("2026-07-17");
     expect(kalender?.to).toBe("2026-07-26");
     expect(kalender?.truncated).toBe(false);
@@ -93,10 +106,10 @@ describe("calendarByPaging", () => {
   it("uebergeht Commits mit Datum in der Zukunft", async () => {
     // Falsch gestellte Uhren gibt es; sie duerfen den Zeitraum nicht verlaengern.
     const kalender = await calendarByPaging(
-      async () => [
+      eineSeite([
         new Date(JETZT.getTime() + 5 * TAG).toISOString(),
         JETZT.toISOString(),
-      ],
+      ]),
       JETZT,
     );
     expect(kalender?.to).toBe("2026-07-26");
@@ -105,7 +118,7 @@ describe("calendarByPaging", () => {
 
   it("uebergeht Unbrauchbares, statt daran zu scheitern", async () => {
     const kalender = await calendarByPaging(
-      async () => [null, "gestern", "", JETZT.toISOString()],
+      eineSeite([null, "gestern", "", JETZT.toISOString()]),
       JETZT,
     );
     expect(calendarTotal(kalender!)).toBe(1);
@@ -114,9 +127,66 @@ describe("calendarByPaging", () => {
   it("laesst Tage ohne Commits weg", async () => {
     // Ein Jahr als Liste waeren 365 Eintraege, die meisten davon Nullen.
     const kalender = await calendarByPaging(
-      async () => [JETZT.toISOString(), new Date(JETZT.getTime() - 30 * TAG).toISOString()],
+      eineSeite([JETZT.toISOString(), new Date(JETZT.getTime() - 30 * TAG).toISOString()]),
       JETZT,
     );
     expect(Object.keys(kalender!.days)).toHaveLength(2);
   });
 });
+
+/**
+ * Gitea deckelt jede Antwort auf MAX_RESPONSE_ITEMS (Voreinstellung 50),
+ * egal was angefragt wurde. Wer gegen die angefragten 100 vergleicht, haelt
+ * dort jede erste Seite fuer die letzte: die Heatmap kannte nur die
+ * juengsten 50 Commits und gab deren aeltesten als Anfang des Zeitraums aus.
+ */
+describe("calendarByPaging gegen eine deckelnde Gegenseite", () => {
+  /** Antwortet nie mit mehr als `deckel` Eintraegen – wie Gitea. */
+  function gedeckelteQuelle(gesamt: number, deckel: number) {
+    const alle = commits(gesamt, 0);
+    return vi.fn(async (seite: number) =>
+      alle.slice((seite - 1) * deckel, seite * deckel),
+    );
+  }
+
+  it("blaettert weiter, obwohl die Seite kleiner ist als angefragt", async () => {
+    // 76 Commits bei einem Deckel von 50 – der Fall aus florian.wilde/flimmer.
+    const ladeSeite = gedeckelteQuelle(76, 50);
+    const kalender = await calendarByPaging(ladeSeite, JETZT);
+
+    // Vorher: eine Seite, 50 Commits, "seit" beim 50. – und truncated false.
+    expect(ladeSeite).toHaveBeenCalledTimes(2);
+    expect(calendarTotal(kalender!)).toBe(76);
+    expect(kalender?.truncated).toBe(false);
+  });
+
+  it("nimmt die erste Antwort als Maßstab, nicht die angefragte Groesse", async () => {
+    // Selbst ein sehr kleiner Deckel darf nicht dazu fuehren, dass nach der
+    // ersten Seite Schluss ist.
+    const ladeSeite = gedeckelteQuelle(25, 10);
+    const kalender = await calendarByPaging(ladeSeite, JETZT);
+
+    expect(ladeSeite).toHaveBeenCalledTimes(3);
+    expect(calendarTotal(kalender!)).toBe(25);
+  });
+
+  it("haelt den Deckel weiterhin ein", async () => {
+    // Mehr Commits als CALENDAR_MAX_PAGES Seiten fassen: abbrechen, aber
+    // ehrlich sein.
+    const ladeSeite = gedeckelteQuelle(50 * CALENDAR_MAX_PAGES + 20, 50);
+    const kalender = await calendarByPaging(ladeSeite, JETZT);
+
+    expect(ladeSeite).toHaveBeenCalledTimes(CALENDAR_MAX_PAGES);
+    expect(kalender?.truncated).toBe(true);
+    expect(calendarTotal(kalender!)).toBe(50 * CALENDAR_MAX_PAGES);
+  });
+
+  it("meldet keine Kuerzung, wenn die Daten einfach zu Ende sind", async () => {
+    // Genau eine volle Seite und dann nichts mehr: das ist kein Deckel.
+    const ladeSeite = gedeckelteQuelle(50, 50);
+    const kalender = await calendarByPaging(ladeSeite, JETZT);
+
+    expect(ladeSeite).toHaveBeenCalledTimes(2);
+    expect(kalender?.truncated).toBe(false);
+  });
+});

src/lib/git/calendar.ts

@@ -16,11 +16,20 @@
 export const CALENDAR_DAYS = 365;
 
 /**
- * Hoechstzahl Seiten, wo seitenweise geholt werden muss. Fuenf Seiten sind
+ * Hoechstzahl Seiten, wo seitenweise geholt werden muss. Genug fuer die
- * 500 Commits – genug fuer die allermeisten Repositories und wenig genug,
+ * allermeisten Repositories und wenig genug, um kein fremdes Kontingent zu
- * um kein fremdes Kontingent zu sprengen.
+ * sprengen.
  */
 export const CALENDAR_MAX_PAGES = 5;
+
+/**
+ * Angefragte Seitengroesse – eine Bitte, keine Zusage.
+ *
+ * Gitea antwortet hoechstens mit MAX_RESPONSE_ITEMS Eintraegen
+ * (Voreinstellung 50), egal was hier steht; GitHub und GitLab erlauben 100.
+ * Wie viele wirklich kommen, entscheidet deshalb erst die erste Antwort –
+ * siehe calendarByPaging.
+ */
 export const CALENDAR_PAGE_SIZE = 100;
 
 export interface CommitCalendar {
@@ -55,6 +64,15 @@ export function calendarSince(now: Date = new Date()): Date {
  * Abgebrochen wird, sobald eine Seite nicht mehr voll ist (dann gibt es
  * nichts weiter), sobald die Seite vollstaendig aus der Zeit vor dem
  * Zeitraum stammt, oder wenn der Deckel greift.
+ *
+ * "Voll" bemisst sich an der **ersten geliefertern Seite**, nicht an dem, was
+ * angefragt wurde. Gitea deckelt jede Antwort auf MAX_RESPONSE_ITEMS
+ * (Voreinstellung 50), unabhaengig vom angefragten limit. Wer gegen die
+ * angefragten 100 vergleicht, haelt bei Gitea jede erste Seite fuer die
+ * letzte – die Heatmap kannte deshalb nur die juengsten 50 Commits und gab
+ * deren aeltesten als Anfang des Zeitraums aus. Bei einem Repository mit 76
+ * Commits stand dort "50 an 2 Tagen seit dem 01.09.", und das las sich wie
+ * eine Aussage ueber das Repository statt ueber die Seitengroesse.
  */
 export async function calendarByPaging(
   ladeSeite: (seite: number) => Promise<Array<string | null>>,
@@ -64,11 +82,18 @@ export async function calendarByPaging(
   const days: Record<string, number> = {};
   let aeltester: number | null = null;
   let gedeckelt = false;
+  /** Was die Gegenseite tatsaechlich als volle Seite ansieht. */
+  let seitengroesse: number | null = null;
 
   for (let seite = 1; seite <= CALENDAR_MAX_PAGES; seite += 1) {
     const daten = await ladeSeite(seite);
     if (daten.length === 0) break;
 
+    // Die erste Antwort setzt den Maßstab. Sie kann kleiner ausfallen als
+    // angefragt; entscheidend ist nur, dass die folgenden Seiten daran
+    // gemessen werden.
+    if (seitengroesse === null) seitengroesse = daten.length;
+
     let innerhalb = 0;
     for (const value of daten) {
       if (!value) continue;
@@ -85,10 +110,12 @@ export async function calendarByPaging(
     }
 
     // Nicht mehr voll: das war die letzte Seite.
-    if (daten.length < CALENDAR_PAGE_SIZE) break;
+    if (daten.length < seitengroesse) break;
     // Die ganze Seite lag schon vor dem Zeitraum – weiter zurueck lohnt nicht.
     if (innerhalb === 0) break;
 
+    // Letzte erlaubte Seite war voll und lag im Zeitraum: es gibt Aelteres,
+    // das wir nicht geholt haben. Das gehoert an die Anzeige.
     if (seite === CALENDAR_MAX_PAGES) gedeckelt = true;
   }
 

src/lib/git/gitea.ts

@@ -1,4 +1,12 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
+import {
+  Teilabrufe,
+  getJson,
+  getJsonSafe,
+  normalizeBaseUrl,
+  sendJson,
+  shortSha,
+  toIso,
+} from "./http";
 import {
   CALENDAR_PAGE_SIZE,
   calendarByPaging,
@@ -62,7 +70,11 @@ export class GiteaClient implements GitClient {
     return { number: angelegt.number, url: angelegt.html_url ?? null };
   }
 
-  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+  async setIssueState(
+    ref: RepoRef,
+    number: number,
+    open: boolean,
+  ): Promise<void> {
     await sendJson(
       `${this.repoBase(ref)}/issues/${number}`,
       "PATCH",
@@ -71,7 +83,10 @@ export class GiteaClient implements GitClient {
     );
   }
 
-  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+  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 },
@@ -97,9 +112,12 @@ export class GiteaClient implements GitClient {
         };
       }
 
-      const user = await getJson<{ login: string; full_name?: string }>(`${this.apiBase}/user`, {
+      const user = await getJson<{ login: string; full_name?: string }>(
+        `${this.apiBase}/user`,
+        {
           headers: this.headers(),
-      });
+        },
+      );
       return {
         ok: true,
         message: `Verbunden als ${user.login}${version.version ? ` (Gitea ${version.version})` : ""}`,
@@ -107,7 +125,10 @@ export class GiteaClient implements GitClient {
         version: version.version ?? null,
       };
     } catch (error) {
-      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      };
     }
   }
 
@@ -123,7 +144,9 @@ export class GiteaClient implements GitClient {
     const needle = query?.toLowerCase().trim();
 
     return repos
-      .filter((repo) => !needle || repo.full_name.toLowerCase().includes(needle))
+      .filter(
+        (repo) => !needle || repo.full_name.toLowerCase().includes(needle),
+      )
       .map((repo) => ({
         fullPath: repo.full_name,
         owner: repo.owner?.login ?? repo.full_name.split("/")[0] ?? "",
@@ -144,25 +167,70 @@ export class GiteaClient implements GitClient {
 
     const defaultBranch = repo.default_branch ?? "";
 
-    const [branches, tags, commits, releases, languages, pulls, issues, status] =
+    // Sammelt, welche Liste nicht geholt werden konnte und warum. Frueher
-      await Promise.all([
+    // stand hier getJsonSafe, das jeden Fehler in eine leere Liste verwandelt
-        getJsonSafe<GiteaBranch[]>(`${base}/branches?limit=50`, [], { headers }),
+    // hat – siehe Teilabrufe.
-        getJsonSafe<GiteaTag[]>(`${base}/tags?limit=25`, [], { headers }),
+    const teil = new Teilabrufe();
-        // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+
-        getJsonSafe<GiteaCommit[]>(`${base}/commits?limit=100&stat=false`, [], { headers }),
+    const [
-        getJsonSafe<GiteaRelease[]>(`${base}/releases?limit=10`, [], { headers }),
+      branches,
-        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
+      tags,
-        getJsonSafe<GiteaPull[]>(`${base}/pulls?state=open&limit=50`, [], { headers }),
+      commits,
-        // type=issues, sonst kommen bei Gitea die Pull Requests mit.
+      releases,
-        getJsonSafe<GiteaIssue[]>(`${base}/issues?state=open&type=issues&limit=50`, [], {
+      languages,
+      pulls,
+      issues,
+      status,
+    ] = await Promise.all([
+      teil.hol<GiteaBranch[]>("branches", `${base}/branches?limit=50`, [], {
         headers,
       }),
+      teil.hol<GiteaTag[]>("tags", `${base}/tags?limit=25`, [], { headers }),
+      // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+      // Gitea liefert davon hoechstens MAX_RESPONSE_ITEMS (Voreinstellung 50).
+      // Das ist hier hinnehmbar - die Kurve kuerzt sich ehrlich auf den
+      // tatsaechlich belegten Zeitraum (siehe bucketCommitActivity), und
+      // blaettern wuerde jeden Abgleich teurer machen. Beim Kalender, der
+      // hoechstens einmal am Tag laeuft, wird dagegen geblaettert.
+      teil.hol<GiteaCommit[]>(
+        "commits",
+        `${base}/commits?limit=100&stat=false`,
+        [],
+        {
+          headers,
+        },
+      ),
+      teil.hol<GiteaRelease[]>("releases", `${base}/releases?limit=10`, [], {
+        headers,
+      }),
+      teil.hol<Record<string, number>>(
+        "languages",
+        `${base}/languages`,
+        {},
+        { headers },
+      ),
+      teil.hol<GiteaPull[]>(
+        "pullRequests",
+        `${base}/pulls?state=open&limit=50`,
+        [],
+        {
+          headers,
+        },
+      ),
+      // type=issues, sonst kommen bei Gitea die Pull Requests mit.
+      teil.hol<GiteaIssue[]>(
+        "issues",
+        `${base}/issues?state=open&type=issues&limit=50`,
+        [],
+        { headers },
+      ),
       // Gitea meldet CI-Ergebnisse als Commit-Status. Das deckt Gitea
       // Actions und externe Systeme wie Woodpecker gleichermassen ab –
       // anders als ein reiner Actions-Endpunkt, den aeltere Instanzen
       // ohnehin nicht kennen.
       defaultBranch
-          ? getJsonSafe<GiteaCombinedStatus>(
+        ? teil.hol<GiteaCombinedStatus>(
+            "ci",
             `${base}/commits/${encodeURIComponent(defaultBranch)}/status`,
             {} as GiteaCombinedStatus,
             { headers },
@@ -186,7 +254,9 @@ export class GiteaClient implements GitClient {
       sha: tag.commit?.sha ?? tag.id ?? null,
       message: tag.message ?? null,
       date: toIso(tag.commit?.created),
-      url: tag.zipball_url ? `${repo.html_url}/releases/tag/${encodeURIComponent(tag.name)}` : null,
+      url: tag.zipball_url
+        ? `${repo.html_url}/releases/tag/${encodeURIComponent(tag.name)}`
+        : null,
     }));
 
     const mappedCommits: CommitInfo[] = commits.map((commit) => ({
@@ -259,7 +329,10 @@ export class GiteaClient implements GitClient {
       pullRequests: mappedPulls,
       issues: mappedIssues,
       ci,
-      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
+      commitActivity: bucketCommitActivity(
+        mappedCommits.map((commit) => commit.date),
+      ),
+      missing: teil.fehler,
     };
   }
 
@@ -298,7 +371,9 @@ export class GiteaClient implements GitClient {
       { headers },
     );
     const name = pickReadme(
-      eintraege.filter((eintrag) => eintrag.type === "file").map((eintrag) => eintrag.name),
+      eintraege
+        .filter((eintrag) => eintrag.type === "file")
+        .map((eintrag) => eintrag.name),
     );
     if (!name) return null;
 

src/lib/git/github.ts

@@ -1,4 +1,12 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
+import {
+  Teilabrufe,
+  getJson,
+  getJsonSafe,
+  normalizeBaseUrl,
+  sendJson,
+  shortSha,
+  toIso,
+} from "./http";
 import type {
   BranchInfo,
   CiInfo,
@@ -31,7 +39,9 @@ export class GitHubClient implements GitClient {
 
   constructor(config: ProviderConfig) {
     const base = normalizeBaseUrl(config.baseUrl || "https://github.com");
-    this.apiBase = /github\.com$/i.test(base) ? "https://api.github.com" : `${base}/api/v3`;
+    this.apiBase = /github\.com$/i.test(base)
+      ? "https://api.github.com"
+      : `${base}/api/v3`;
     this.token = config.token;
   }
 
@@ -61,7 +71,11 @@ export class GitHubClient implements GitClient {
     return { number: angelegt.number, url: angelegt.html_url ?? null };
   }
 
-  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+  async setIssueState(
+    ref: RepoRef,
+    number: number,
+    open: boolean,
+  ): Promise<void> {
     await sendJson(
       `${this.repoBase(ref)}/issues/${number}`,
       "PATCH",
@@ -70,7 +84,10 @@ export class GitHubClient implements GitClient {
     );
   }
 
-  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+  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 },
@@ -82,25 +99,42 @@ export class GitHubClient implements GitClient {
   async check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {
-        await getJson(`${this.apiBase}/rate_limit`, { headers: this.headers() });
+        await getJson(`${this.apiBase}/rate_limit`, {
+          headers: this.headers(),
+        });
         return {
           ok: true,
-          message: "Erreichbar (ohne Token – nur oeffentliche Repos, striktes Rate-Limit).",
+          message:
+            "Erreichbar (ohne Token – nur oeffentliche Repos, striktes Rate-Limit).",
           user: null,
         };
       }
-      const user = await getJson<{ login: string; name?: string }>(`${this.apiBase}/user`, {
+      const user = await getJson<{ login: string; name?: string }>(
+        `${this.apiBase}/user`,
+        {
           headers: this.headers(),
-      });
+        },
-      return { ok: true, message: `Verbunden als ${user.login}`, user: user.login };
+      );
+      return {
+        ok: true,
+        message: `Verbunden als ${user.login}`,
+        user: user.login,
+      };
     } catch (error) {
-      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      };
     }
   }
 
   async listRepos(query?: string): Promise<RepoListItem[]> {
     if (!this.token) {
-      throw new GitApiError("Fuer das Auflisten von Repos wird ein Token benoetigt.", 401, this.apiBase);
+      throw new GitApiError(
+        "Fuer das Auflisten von Repos wird ein Token benoetigt.",
+        401,
+        this.apiBase,
+      );
     }
     const repos = await getJson<GitHubRepo[]>(
       `${this.apiBase}/user/repos?per_page=100&sort=pushed&affiliation=owner,collaborator,organization_member`,
@@ -108,7 +142,9 @@ export class GitHubClient implements GitClient {
     );
     const needle = query?.toLowerCase().trim();
     return (repos ?? [])
-      .filter((repo) => !needle || repo.full_name.toLowerCase().includes(needle))
+      .filter(
+        (repo) => !needle || repo.full_name.toLowerCase().includes(needle),
+      )
       .map((repo) => ({
         fullPath: repo.full_name,
         owner: repo.owner?.login ?? repo.full_name.split("/")[0] ?? "",
@@ -129,18 +165,58 @@ export class GitHubClient implements GitClient {
 
     const defaultBranch = repo.default_branch;
 
-    const [branches, tags, commits, releases, languages, pulls, issues, ciRuns] =
+    // Sammelt, welche Liste nicht geholt werden konnte und warum.
-      await Promise.all([
+    const teil = new Teilabrufe();
-        getJsonSafe<GitHubBranch[]>(`${base}/branches?per_page=50`, [], { headers }),
+
-        getJsonSafe<GitHubTag[]>(`${base}/tags?per_page=25`, [], { headers }),
+    const [
+      branches,
+      tags,
+      commits,
+      releases,
+      languages,
+      pulls,
+      issues,
+      ciRuns,
+    ] = await Promise.all([
+      teil.hol<GitHubBranch[]>("branches", `${base}/branches?per_page=50`, [], {
+        headers,
+      }),
+      teil.hol<GitHubTag[]>("tags", `${base}/tags?per_page=25`, [], {
+        headers,
+      }),
       // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
-        getJsonSafe<GitHubCommit[]>(`${base}/commits?per_page=100`, [], { headers }),
+      // Kommen weniger an, kuerzt sich die Kurve ehrlich auf den tatsaechlich
-        getJsonSafe<GitHubRelease[]>(`${base}/releases?per_page=10`, [], { headers }),
+      // belegten Zeitraum (siehe bucketCommitActivity).
-        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
+      teil.hol<GitHubCommit[]>("commits", `${base}/commits?per_page=100`, [], {
-        getJsonSafe<GitHubPull[]>(`${base}/pulls?state=open&per_page=50`, [], { headers }),
+        headers,
+      }),
+      teil.hol<GitHubRelease[]>(
+        "releases",
+        `${base}/releases?per_page=10`,
+        [],
+        { headers },
+      ),
+      teil.hol<Record<string, number>>(
+        "languages",
+        `${base}/languages`,
+        {},
+        { headers },
+      ),
+      teil.hol<GitHubPull[]>(
+        "pullRequests",
+        `${base}/pulls?state=open&per_page=50`,
+        [],
+        { headers },
+      ),
       // /issues liefert bei GitHub auch Pull Requests – die filtern wir raus.
-        getJsonSafe<GitHubIssue[]>(`${base}/issues?state=open&per_page=50`, [], { headers }),
+      teil.hol<GitHubIssue[]>(
-        getJsonSafe<{ workflow_runs?: GitHubRun[] }>(
+        "issues",
+        `${base}/issues?state=open&per_page=50`,
+        [],
+        { headers },
+      ),
+      teil.hol<{ workflow_runs?: GitHubRun[] }>(
+        "ci",
         `${base}/actions/runs?per_page=1&branch=${encodeURIComponent(defaultBranch)}`,
         {},
         { headers },
@@ -208,7 +284,10 @@ export class GitHubClient implements GitClient {
 
     // open_issues_count zaehlt bei GitHub PRs mit – hier wieder herausrechnen.
     const openPullRequests = pulls.length;
-    const openIssues = Math.max(0, (repo.open_issues_count ?? 0) - openPullRequests);
+    const openIssues = Math.max(
+      0,
+      (repo.open_issues_count ?? 0) - openPullRequests,
+    );
 
     const run = ciRuns?.workflow_runs?.[0];
     const ci: CiInfo | null = run
@@ -242,7 +321,10 @@ export class GitHubClient implements GitClient {
       pullRequests: mappedPulls,
       issues: mappedIssues,
       ci,
-      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
+      commitActivity: bucketCommitActivity(
+        mappedCommits.map((commit) => commit.date),
+      ),
+      missing: teil.fehler,
     };
   }
 
@@ -260,9 +342,12 @@ export class GitHubClient implements GitClient {
    */
   async fetchCommitCalendar(ref: RepoRef): Promise<CommitCalendar | null> {
     const base = `${this.apiBase}/repos/${encodeURIComponent(ref.owner)}/${encodeURIComponent(ref.name)}`;
-    const wochen = await getJson<GitHubWeek[]>(`${base}/stats/commit_activity`, {
+    const wochen = await getJson<GitHubWeek[]>(
+      `${base}/stats/commit_activity`,
+      {
         headers: this.headers(),
-    });
+      },
+    );
 
     if (!Array.isArray(wochen) || wochen.length === 0) {
       // Entweder rechnet GitHub noch, oder das Repository hat keine Commits.
@@ -300,7 +385,9 @@ export class GitHubClient implements GitClient {
 
     let datei: GitHubContent;
     try {
-      datei = await getJson<GitHubContent>(`${base}/readme`, { headers: this.headers() });
+      datei = await getJson<GitHubContent>(`${base}/readme`, {
+        headers: this.headers(),
+      });
     } catch (error) {
       if (error instanceof GitApiError && error.status === 404) return null;
       throw error;
@@ -337,8 +424,12 @@ interface GitHubWeek {
 }
 
 /** GitHub trennt Lauf-Status und Ergebnis; hier auf einen Wert zusammenfuehren. */
-function mapRunState(status: string | null, conclusion: string | null): CiState {
+function mapRunState(
-  if (status === "queued" || status === "waiting" || status === "pending") return "pending";
+  status: string | null,
+  conclusion: string | null,
+): CiState {
+  if (status === "queued" || status === "waiting" || status === "pending")
+    return "pending";
   if (status === "in_progress") return "running";
   switch (conclusion) {
     case "success":

src/lib/git/gitlab.ts

@@ -1,4 +1,12 @@
-import { getJson, getJsonSafe, normalizeBaseUrl, sendJson, shortSha, toIso } from "./http";
+import {
+  Teilabrufe,
+  getJson,
+  getJsonSafe,
+  normalizeBaseUrl,
+  sendJson,
+  shortSha,
+  toIso,
+} from "./http";
 import {
   CALENDAR_PAGE_SIZE,
   calendarByPaging,
@@ -61,7 +69,11 @@ export class GitLabClient implements GitClient {
     return { number: angelegt.iid, url: angelegt.web_url ?? null };
   }
 
-  async setIssueState(ref: RepoRef, number: number, open: boolean): Promise<void> {
+  async setIssueState(
+    ref: RepoRef,
+    number: number,
+    open: boolean,
+  ): Promise<void> {
     await sendJson(
       `${this.apiBase}/projects/${this.projectPath(ref)}/issues/${number}`,
       "PUT",
@@ -70,7 +82,10 @@ export class GitLabClient implements GitClient {
     );
   }
 
-  async getIssueState(ref: RepoRef, number: number): Promise<"open" | "closed" | null> {
+  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 },
@@ -83,15 +98,31 @@ export class GitLabClient implements GitClient {
   async check(): Promise<ConnectionCheck> {
     try {
       if (!this.token) {
-        await getJson(`${this.apiBase}/projects?per_page=1`, { headers: this.headers() });
+        await getJson(`${this.apiBase}/projects?per_page=1`, {
-        return { ok: true, message: "Erreichbar (ohne Token – nur oeffentliche Projekte).", user: null };
-      }
-      const user = await getJson<{ username: string; name?: string }>(`${this.apiBase}/user`, {
           headers: this.headers(),
         });
-      return { ok: true, message: `Verbunden als ${user.username}`, user: user.username };
+        return {
+          ok: true,
+          message: "Erreichbar (ohne Token – nur oeffentliche Projekte).",
+          user: null,
+        };
+      }
+      const user = await getJson<{ username: string; name?: string }>(
+        `${this.apiBase}/user`,
+        {
+          headers: this.headers(),
+        },
+      );
+      return {
+        ok: true,
+        message: `Verbunden als ${user.username}`,
+        user: user.username,
+      };
     } catch (error) {
-      return { ok: false, message: error instanceof Error ? error.message : String(error) };
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error),
+      };
     }
   }
 
@@ -101,7 +132,9 @@ export class GitLabClient implements GitClient {
       ? `${this.apiBase}/projects?membership=true&per_page=100&order_by=last_activity_at${search}`
       : `${this.apiBase}/projects?per_page=50&order_by=last_activity_at${search}`;
 
-    const projects = await getJson<GitLabProject[]>(url, { headers: this.headers() });
+    const projects = await getJson<GitLabProject[]>(url, {
+      headers: this.headers(),
+    });
     return (projects ?? []).map((project) => {
       const path = project.path_with_namespace;
       const segments = path.split("/");
@@ -127,23 +160,71 @@ export class GitLabClient implements GitClient {
     const base = `${this.apiBase}/projects/${this.projectPath(ref)}`;
     const headers = this.headers();
 
-    const project = await getJson<GitLabProject>(`${base}?statistics=true`, { headers });
+    const project = await getJson<GitLabProject>(`${base}?statistics=true`, {
+      headers,
+    });
 
     const defaultBranch = project.default_branch ?? "";
 
-    const [branches, tags, commits, releases, languages, mergeRequests, issues, pipelines] =
+    // Sammelt, welche Liste nicht geholt werden konnte und warum.
-      await Promise.all([
+    const teil = new Teilabrufe();
-        getJsonSafe<GitLabBranch[]>(`${base}/repository/branches?per_page=50`, [], { headers }),
+
-        getJsonSafe<GitLabTag[]>(`${base}/repository/tags?per_page=25`, [], { headers }),
+    const [
-        // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+      branches,
-        getJsonSafe<GitLabCommit[]>(`${base}/repository/commits?per_page=100`, [], { headers }),
+      tags,
-        getJsonSafe<GitLabRelease[]>(`${base}/releases?per_page=10`, [], { headers }),
+      commits,
-        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
+      releases,
-        getJsonSafe<GitLabMergeRequest[]>(`${base}/merge_requests?state=opened&per_page=50`, [], {
+      languages,
+      mergeRequests,
+      issues,
+      pipelines,
+    ] = await Promise.all([
+      teil.hol<GitLabBranch[]>(
+        "branches",
+        `${base}/repository/branches?per_page=50`,
+        [],
+        { headers },
+      ),
+      teil.hol<GitLabTag[]>("tags", `${base}/repository/tags?per_page=25`, [], {
         headers,
       }),
-        getJsonSafe<GitLabIssue[]>(`${base}/issues?state=opened&per_page=50`, [], { headers }),
+      // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
-        getJsonSafe<GitLabPipeline[]>(
+      // Kommen weniger an, kuerzt sich die Kurve ehrlich auf den tatsaechlich
+      // belegten Zeitraum (siehe bucketCommitActivity).
+      teil.hol<GitLabCommit[]>(
+        "commits",
+        `${base}/repository/commits?per_page=100`,
+        [],
+        { headers },
+      ),
+      teil.hol<GitLabRelease[]>(
+        "releases",
+        `${base}/releases?per_page=10`,
+        [],
+        { headers },
+      ),
+      teil.hol<Record<string, number>>(
+        "languages",
+        `${base}/languages`,
+        {},
+        { headers },
+      ),
+      teil.hol<GitLabMergeRequest[]>(
+        "pullRequests",
+        `${base}/merge_requests?state=opened&per_page=50`,
+        [],
+        {
+          headers,
+        },
+      ),
+      teil.hol<GitLabIssue[]>(
+        "issues",
+        `${base}/issues?state=opened&per_page=50`,
+        [],
+        { headers },
+      ),
+      teil.hol<GitLabPipeline[]>(
+        "ci",
         `${base}/pipelines?per_page=1${defaultBranch ? `&ref=${encodeURIComponent(defaultBranch)}` : ""}`,
         [],
         { headers },
@@ -155,7 +236,9 @@ export class GitLabClient implements GitClient {
       sha: branch.commit?.id ?? null,
       isDefault: Boolean(branch.default),
       protected: Boolean(branch.protected),
-      lastCommitAt: toIso(branch.commit?.committed_date ?? branch.commit?.created_at),
+      lastCommitAt: toIso(
+        branch.commit?.committed_date ?? branch.commit?.created_at,
+      ),
       lastCommitMessage: branch.commit?.title ?? null,
       lastCommitAuthor: branch.commit?.author_name ?? null,
       url: branch.web_url ?? null,
@@ -240,7 +323,10 @@ export class GitLabClient implements GitClient {
       pullRequests: mappedMergeRequests,
       issues: mappedIssues,
       ci,
-      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
+      commitActivity: bucketCommitActivity(
+        mappedCommits.map((commit) => commit.date),
+      ),
+      missing: teil.fehler,
     };
   }
 
@@ -260,7 +346,9 @@ export class GitLabClient implements GitClient {
           `&since=${encodeURIComponent(seit)}`,
         { headers: this.headers() },
       );
-      return commits.map((commit) => toIso(commit.committed_date ?? commit.created_at));
+      return commits.map((commit) =>
+        toIso(commit.committed_date ?? commit.created_at),
+      );
     });
   }
 
@@ -278,18 +366,27 @@ export class GitLabClient implements GitClient {
       { headers },
     );
     const name = pickReadme(
-      eintraege.filter((eintrag) => eintrag.type === "blob").map((eintrag) => eintrag.name),
+      eintraege
+        .filter((eintrag) => eintrag.type === "blob")
+        .map((eintrag) => eintrag.name),
     );
     if (!name) return null;
 
-    const datei = await getJson<{ content?: string; encoding?: string; file_path?: string }>(
+    const datei = await getJson<{
-      `${base}/repository/files/${encodeURIComponent(name)}?ref=HEAD`,
+      content?: string;
-      { headers },
+      encoding?: string;
-    );
+      file_path?: string;
+    }>(`${base}/repository/files/${encodeURIComponent(name)}?ref=HEAD`, {
+      headers,
+    });
     if (!datei?.content || datei.encoding !== "base64") return null;
 
     const { content, truncated } = capReadme(decodeBase64(datei.content));
-    const projekt = await getJsonSafe<GitLabProject>(base, {} as GitLabProject, { headers });
+    const projekt = await getJsonSafe<GitLabProject>(
+      base,
+      {} as GitLabProject,
+      { headers },
+    );
 
     return {
       content,

src/lib/git/http.test.ts

@@ -0,0 +1,265 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { Teilabrufe, zeitlimit } from "./http";
+
+/**
+ * Diese beiden Stellen haben zusammen einen Ausfall verursacht, den niemand
+ * sehen konnte: Der Abgleich holte die Listen eines Repositories, verlor sie
+ * unterwegs, verwandelte jeden Fehler in eine leere Liste und meldete
+ * "Snapshot aktualisiert: 0 Branches, 0 Tags". Aus der Oberflaeche war nicht
+ * zu erkennen, dass ueberhaupt etwas schiefgegangen war.
+ */
+
+describe("zeitlimit", () => {
+  it("nimmt einen brauchbaren Wert", () => {
+    expect(zeitlimit("30000")).toBe(30000);
+    expect(zeitlimit(" 20000 ")).toBe(20000);
+  });
+
+  it("faellt ohne Angabe auf die Vorgabe zurueck", () => {
+    expect(zeitlimit(undefined)).toBe(15000);
+    expect(zeitlimit("")).toBe(15000);
+    expect(zeitlimit("   ")).toBe(15000);
+  });
+
+  it("faengt genau die Werte ab, die alles stillgelegt haetten", () => {
+    // Number("") ist 0, Number("abc") ist NaN. setTimeout loest bei beidem
+    // sofort aus – jeder ausgehende Aufruf braeche ab, bevor er beginnt,
+    // und der Abgleich meldete ueberall leere Listen.
+    const warnungen: string[] = [];
+    const merken = (text: string) => warnungen.push(text);
+
+    expect(zeitlimit("0", merken)).toBe(15000);
+    expect(zeitlimit("abc", merken)).toBe(15000);
+    expect(zeitlimit("-5000", merken)).toBe(15000);
+    expect(zeitlimit("500", merken)).toBe(15000);
+
+    // Und zwar nicht stillschweigend.
+    expect(warnungen).toHaveLength(4);
+    for (const warnung of warnungen) {
+      expect(warnung).toContain("GIT_API_TIMEOUT_MS");
+    }
+  });
+});
+
+describe("Teilabrufe", () => {
+  // Vor jedem Aufruf prueft der SSRF-Schutz das Ziel und loest dafuer den
+  // Hostnamen auf. Eine ausdrueckliche Freigabe ueberspringt das – sonst
+  // haengt der Test an einem DNS-Server und misst nicht, was er messen will.
+  beforeEach(() => {
+    vi.stubEnv("GIT_ALLOWED_HOSTS", "git.example.com");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    // Ohne das zaehlen die Spies ueber Tests hinweg weiter – und genau an
+    // Aufrufzahlen haengen die Pruefungen hier.
+    vi.restoreAllMocks();
+  });
+
+  it("meldet nichts, solange alles ankommt", async () => {
+    const teil = new Teilabrufe();
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response(JSON.stringify([{ name: "main" }]), { status: 200 }),
+    );
+
+    const wert = await teil.hol("branches", "https://git.example.com/api/v1/x", []);
+
+    expect(wert).toEqual([{ name: "main" }]);
+    expect(teil.fehler).toEqual({});
+    expect(teil.unvollstaendig).toBe(false);
+  });
+
+  it("gibt den Fallback zurueck, haelt aber den Grund fest", async () => {
+    // Der Kern des Fehlers: vorher war dieser Fall von "das Repository hat
+    // keine Branches" nicht zu unterscheiden.
+    const teil = new Teilabrufe();
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(
+      new Response("no scopes", { status: 403 }),
+    );
+
+    const wert = await teil.hol("branches", "https://git.example.com/api/v1/x", []);
+
+    expect(wert).toEqual([]);
+    expect(teil.unvollstaendig).toBe(true);
+    expect(teil.fehler.branches).toContain("403");
+  });
+
+  it("nennt den Status, weil daran die Ursache haengt", async () => {
+    // 403 heisst Scopes, 429 Rate-Limit, 408 Zeitueberschreitung. Ohne die
+    // Zahl bliebe nur "hat nicht geklappt".
+    const teil = new Teilabrufe();
+    vi.spyOn(globalThis, "fetch").mockResolvedValue(new Response("slow down", { status: 429 }));
+
+    await teil.hol("tags", "https://git.example.com/api/v1/x", []);
+
+    expect(teil.fehler.tags).toMatch(/429/);
+  });
+
+  it("haelt mehrere Fehlschlaege getrennt auseinander", async () => {
+    const teil = new Teilabrufe();
+    let aufruf = 0;
+    vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+      aufruf += 1;
+      // Der zweite geht durch – ein Teilausfall ist der haeufige Fall.
+      return aufruf === 2
+        ? new Response(JSON.stringify([1, 2]), { status: 200 })
+        : new Response("nope", { status: 403 });
+    });
+
+    const [branches, tags, commits] = await Promise.all([
+      teil.hol("branches", "https://git.example.com/a", []),
+      teil.hol("tags", "https://git.example.com/b", []),
+      teil.hol("commits", "https://git.example.com/c", []),
+    ]);
+
+    expect(branches).toEqual([]);
+    expect(tags).toEqual([1, 2]);
+    expect(commits).toEqual([]);
+    expect(Object.keys(teil.fehler).sort()).toEqual(["branches", "commits"]);
+  });
+
+  it("faengt auch einen Abbruch ab, nicht nur eine Fehlerantwort", async () => {
+    const teil = new Teilabrufe();
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("socket hang up"));
+
+    const wert = await teil.hol("commits", "https://git.example.com/api/v1/x", []);
+
+    expect(wert).toEqual([]);
+    expect(teil.fehler.commits).toBeTruthy();
+  });
+});
+
+/**
+ * Der zweite Versuch.
+ *
+ * Beobachtet an einer laufenden Instanz: zwei von acht Teil-Abrufen liefen
+ * in eine Zeitueberschreitung nach 15 s, waehrend dieselben Aufrufe von
+ * aussen einzeln in 80 ms antworteten. Nicht die Endpunkte sind langsam –
+ * die Achterrunde erwuergt sich gelegentlich selbst.
+ */
+describe("Teilabrufe: Nachschlag", () => {
+  beforeEach(() => {
+    vi.stubEnv("GIT_ALLOWED_HOSTS", "git.example.com");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    // Ohne das zaehlen die Spies ueber Tests hinweg weiter – und genau an
+    // Aufrufzahlen haengen die Pruefungen hier.
+    vi.restoreAllMocks();
+  });
+
+  /** Antwortet die ersten `fehlschlaege` Male mit Abbruch, danach mit Daten. */
+  function zaehlend(fehlschlaege: number, status = 408) {
+    let aufruf = 0;
+    return vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+      aufruf += 1;
+      if (aufruf <= fehlschlaege) {
+        if (status === 408) {
+          const abbruch = new Error("aborted");
+          abbruch.name = "AbortError";
+          throw abbruch;
+        }
+        return new Response("nope", { status });
+      }
+      return new Response(JSON.stringify(["da"]), { status: 200 });
+    });
+  }
+
+  it("holt eine Zeitueberschreitung im zweiten Versuch nach", async () => {
+    const fetchSpy = zaehlend(1);
+    const teil = new Teilabrufe();
+
+    const wert = await teil.hol("branches", "https://git.example.com/a", []);
+
+    expect(wert).toEqual(["da"]);
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    // Geglueckt heisst: kein Eintrag. Sonst stuende am Repository ein
+    // Fehler, den es nicht mehr gibt.
+    expect(teil.fehler).toEqual({});
+    expect(teil.unvollstaendig).toBe(false);
+  });
+
+  it("vermerkt es, wenn auch der zweite Versuch scheitert", async () => {
+    const fetchSpy = zaehlend(99);
+    const teil = new Teilabrufe();
+
+    const wert = await teil.hol("commits", "https://git.example.com/a", []);
+
+    expect(wert).toEqual([]);
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+    expect(teil.fehler.commits).toContain("408");
+    expect(teil.fehler.commits).toContain("zweiten Versuch");
+  });
+
+  it("schlaegt bei 403 gar nicht erst nach", async () => {
+    // Fehlende Scopes werden durch Wiederholen nicht besser.
+    const fetchSpy = zaehlend(99, 403);
+    const teil = new Teilabrufe();
+
+    await teil.hol("tags", "https://git.example.com/a", []);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    expect(teil.fehler.tags).not.toContain("zweiten Versuch");
+  });
+
+  it("schlaegt bei 429 nicht nach", async () => {
+    // Sofortiges Wiederholen macht ein Rate-Limit schlimmer, nicht besser.
+    const fetchSpy = zaehlend(99, 429);
+    const teil = new Teilabrufe();
+
+    await teil.hol("issues", "https://git.example.com/a", []);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("gibt hoechstens zwei Nachschlaege je Abgleich", async () => {
+    // Acht Zeitueberschreitungen zu je 15 s waeren zwei Minuten. Wer weg
+    // ist, soll schnell als weg erkannt werden.
+    const fetchSpy = zaehlend(99);
+    const teil = new Teilabrufe();
+
+    await Promise.all([
+      teil.hol("branches", "https://git.example.com/a", []),
+      teil.hol("tags", "https://git.example.com/b", []),
+      teil.hol("commits", "https://git.example.com/c", []),
+      teil.hol("releases", "https://git.example.com/d", []),
+    ]);
+
+    // Vier erste Versuche, aber nur zwei Nachschlaege.
+    expect(fetchSpy).toHaveBeenCalledTimes(6);
+    expect(Object.keys(teil.fehler).sort()).toEqual([
+      "branches",
+      "commits",
+      "releases",
+      "tags",
+    ]);
+  });
+
+  it("reisst die Kette nicht ab, wenn ein Nachschlag scheitert", async () => {
+    // Der erste Nachschlag geht schief, der zweite muss trotzdem laufen.
+    let aufruf = 0;
+    const fetchSpy = vi.spyOn(globalThis, "fetch").mockImplementation(async () => {
+      aufruf += 1;
+      // 1 und 2 sind die ersten Versuche, 3 der erste Nachschlag (scheitert),
+      // 4 der zweite Nachschlag (glueckt).
+      if (aufruf <= 3) {
+        const abbruch = new Error("aborted");
+        abbruch.name = "AbortError";
+        throw abbruch;
+      }
+      return new Response(JSON.stringify(["da"]), { status: 200 });
+    });
+
+    const teil = new Teilabrufe();
+    const [erst, zweit] = await Promise.all([
+      teil.hol("branches", "https://git.example.com/a", []),
+      teil.hol("tags", "https://git.example.com/b", []),
+    ]);
+
+    expect(fetchSpy).toHaveBeenCalledTimes(4);
+    expect(erst).toEqual([]);
+    expect(zweit).toEqual(["da"]);
+    expect(Object.keys(teil.fehler)).toEqual(["branches"]);
+  });
+});

src/lib/git/http.ts

@@ -1,7 +1,37 @@
 import { BlockedHostError, assertAllowedUrl } from "@/lib/security/ssrf";
 import { GitApiError } from "./types";
 
-const DEFAULT_TIMEOUT = Number(process.env.GIT_API_TIMEOUT_MS ?? 15000);
+const TIMEOUT_VORGABE = 15000;
+
+/**
+ * Zeitlimit je Aufruf.
+ *
+ * Bewusst mit Pruefung: Number("") ist 0 und Number("abc") ist NaN – beides
+ * laesst setTimeout sofort ausloesen, und dann bricht jeder ausgehende
+ * Aufruf ab, bevor er begonnen hat. Eine verrutschte Zeile in der .env
+ * legte damit den ganzen Abgleich still, ohne dass irgendwo etwas stand.
+ */
+export function zeitlimit(
+  roh: string | undefined,
+  warnen: (text: string) => void = console.warn,
+): number {
+  const wert = roh?.trim();
+  if (!wert) return TIMEOUT_VORGABE;
+
+  const zahl = Number(wert);
+  // Untergrenze 1000 ms: darunter ist kein Aufruf ueber das Netz zu
+  // schaffen, und wer das eintraegt, hat sich vertan.
+  if (!Number.isFinite(zahl) || zahl < 1000) {
+    warnen(
+      `[nebula] GIT_API_TIMEOUT_MS="${wert}" ist unbrauchbar (Zahl ab 1000 erwartet). ` +
+        `Es gelten ${TIMEOUT_VORGABE} ms.`,
+    );
+    return TIMEOUT_VORGABE;
+  }
+  return zahl;
+}
+
+const DEFAULT_TIMEOUT = zeitlimit(process.env.GIT_API_TIMEOUT_MS);
 
 export interface FetchOptions {
   headers?: Record<string, string>;
@@ -73,7 +103,11 @@ export async function getJson<T>(
 
     if (!response.ok) {
       const body = await response.text().catch(() => "");
-      throw new GitApiError(friendlyMessage(response.status, url, body), response.status, url);
+      throw new GitApiError(
+        friendlyMessage(response.status, url, body),
+        response.status,
+        url,
+      );
     }
 
     const text = await response.text();
@@ -150,7 +184,11 @@ export async function sendJson<T>(
 
     if (!response.ok) {
       const text = await response.text().catch(() => "");
-      throw new GitApiError(friendlyMessage(response.status, url, text), response.status, url);
+      throw new GitApiError(
+        friendlyMessage(response.status, url, text),
+        response.status,
+        url,
+      );
     }
 
     const text = await response.text();
@@ -175,7 +213,14 @@ export async function sendJson<T>(
   }
 }
 
-/** Wie getJson, gibt aber bei jedem Fehler den Fallback zurueck. */
+/**
+ * Wie getJson, gibt aber bei jedem Fehler den Fallback zurueck.
+ *
+ * Nur fuer Abrufe benutzen, bei denen ein Fehlschlag wirklich nichts
+ * bedeutet. Fuer die Listen eines Snapshots ist das falsch – dort ist
+ * "nicht geholt" etwas anderes als "nichts vorhanden". Dafuer gibt es
+ * Teilabrufe.
+ */
 export async function getJsonSafe<T>(
   url: string,
   fallback: T,
@@ -189,6 +234,121 @@ export async function getJsonSafe<T>(
   }
 }
 
+/**
+ * Wie viele zweite Versuche ein Abgleich hoechstens unternimmt.
+ *
+ * Zwei, nicht acht: jede Zeitueberschreitung kostet volle 15 Sekunden, und
+ * acht davon hintereinander waeren zwei Minuten, in denen "Jetzt
+ * synchronisieren" wie ein Absturz aussieht. Wer wirklich weg ist, soll
+ * schnell als weg erkannt werden.
+ */
+const NACHSCHLAG_MAX = 2;
+
+/** Warum ein einzelner Teil-Abruf nicht geklappt hat. */
+export type Teilfehler = Record<string, string>;
+
+/**
+ * Sammelstelle fuer die Listen eines Snapshots.
+ *
+ * Der Vorgaenger dieser Klasse war ein getJsonSafe je Liste. Das hat jeden
+ * Fehler in eine leere Liste verwandelt, und damit war ein 403 nicht mehr
+ * von einem Repository ohne Branches zu unterscheiden: Der Abgleich meldete
+ * "Snapshot aktualisiert: 0 Branches, 0 Tags", schrieb Nullen ueber den
+ * letzten guten Stand und niemand konnte sehen, woran es lag.
+ *
+ * Der Fallback bleibt – ein einzelner Fehlschlag darf den ganzen Abgleich
+ * nicht abbrechen –, aber der Grund wird festgehalten.
+ */
+export class Teilabrufe {
+  readonly fehler: Teilfehler = {};
+
+  /**
+   * Nachschlaege haengen aneinander, damit sie nacheinander laufen.
+   *
+   * Die Runde selbst ist gleichzeitig – acht Aufrufe auf einmal. Genau das
+   * scheint sie gelegentlich zu erwuergen: beobachtet wurden zwei von acht
+   * mit Zeitueberschreitung nach 15 s, waehrend dieselben Aufrufe einzeln in
+   * 80 ms antworteten. Der zweite Versuch soll deshalb nicht wieder in
+   * denselben Schwung geraten.
+   */
+  private kette: Promise<unknown> = Promise.resolve();
+  private nachgeschlagen = 0;
+
+  async hol<T>(
+    feld: string,
+    url: string,
+    fallback: T,
+    options: FetchOptions = {},
+  ): Promise<T> {
+    try {
+      const result = await getJson<T>(url, options);
+      return (result ?? fallback) as T;
+    } catch (error) {
+      if (this.lohntNachschlag(error)) {
+        const zweiter = await this.nachschlag<T>(url, options);
+        if (zweiter.ok) return (zweiter.wert ?? fallback) as T;
+        this.fehler[feld] = `${beschreibe(zweiter.fehler)} (auch im zweiten Versuch)`;
+        return fallback;
+      }
+      this.fehler[feld] = beschreibe(error);
+      return fallback;
+    }
+  }
+
+  /**
+   * Ein zweiter Versuch hilft nur bei Fehlern, die nichts ueber die Sache
+   * aussagen: Zeitueberschreitung (408) und eine Verbindung, die gar nicht
+   * zustande kam (0). Ein 403 wird durch Wiederholen nicht besser, ein 429
+   * durch sofortiges Wiederholen schlimmer, und ein 404 bleibt ein 404.
+   */
+  private lohntNachschlag(error: unknown): boolean {
+    if (this.nachgeschlagen >= NACHSCHLAG_MAX) return false;
+    if (!(error instanceof GitApiError)) return false;
+    return error.status === 408 || error.status === 0;
+  }
+
+  private async nachschlag<T>(
+    url: string,
+    options: FetchOptions,
+  ): Promise<{ ok: boolean; wert?: T; fehler?: unknown }> {
+    this.nachgeschlagen += 1;
+
+    const versuch = this.kette.then(async () => getJson<T>(url, options));
+    // Auch ein Fehlschlag darf die Kette nicht abreissen lassen, sonst
+    // scheitern die folgenden Nachschlaege gleich mit.
+    this.kette = versuch.catch(() => undefined);
+
+    try {
+      return { ok: true, wert: await versuch };
+    } catch (fehler) {
+      return { ok: false, fehler };
+    }
+  }
+
+  /** true, sobald mindestens ein Teil-Abruf gescheitert ist. */
+  get unvollstaendig(): boolean {
+    return Object.keys(this.fehler).length > 0;
+  }
+}
+
+/**
+ * Kurzfassung eines Fehlers, wie sie am Repository angezeigt wird.
+ *
+ * getJson gibt ausschliesslich GitApiError heraus – ein blockiertes Ziel
+ * kommt als 403, eine Zeitueberschreitung als 408, ein nicht erreichter
+ * Host als 0. Der Status ist damit die eigentliche Auskunft, und die
+ * uebrigen Zweige sind nur fuer den Fall da, dass sich das einmal aendert.
+ */
+function beschreibe(error: unknown): string {
+  if (error instanceof GitApiError) {
+    return error.status
+      ? `HTTP ${error.status}: ${error.message}`
+      : error.message;
+  }
+  if (error instanceof Error) return `${error.name}: ${error.message}`;
+  return String(error);
+}
+
 export function toIso(value: unknown): string | null {
   if (!value) return null;
   const date = new Date(String(value));

src/lib/git/meta.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { PROVIDER_META, guessProvider } from "./meta";
+
+const PROVIDER = ["GITHUB", "GITLAB", "GITEA"] as const;
+
+describe("PROVIDER_META", () => {
+  it("kennt jedes unterstuetzte System", () => {
+    for (const provider of PROVIDER) {
+      expect(PROVIDER_META[provider], provider).toBeDefined();
+    }
+    // Und nichts darueber hinaus – ein Eintrag ohne Gegenstueck im Schema
+    // waere ein Ueberbleibsel.
+    expect(Object.keys(PROVIDER_META).sort()).toEqual([...PROVIDER].sort());
+  });
+
+  it("hat zu jedem System Beschriftung, Basis-URL und Dokuverweis", () => {
+    for (const provider of PROVIDER) {
+      const meta = PROVIDER_META[provider];
+      expect(meta.label.length, provider).toBeGreaterThan(0);
+      expect(meta.defaultBaseUrl, provider).toMatch(/^https:\/\//);
+      expect(meta.docsUrl, provider).toMatch(/^https:\/\//);
+    }
+  });
+
+  /**
+   * Der eigentliche Waechter.
+   *
+   * Der Hinweis am Eingabefeld war eine Zeit lang rein lesend formuliert,
+   * obwohl Nebula seit v1.7.0 Issues anlegt und schliesst – wer sich daran
+   * hielt, bekam einen 403. Jeder Provider in GitClient muss createIssue und
+   * setIssueState koennen; folglich muss auch jeder Hinweis sagen, was das
+   * an Rechten kostet.
+   */
+  it("sagt bei jedem System etwas ueber die Rechte fuer Issues", () => {
+    for (const provider of PROVIDER) {
+      expect(PROVIDER_META[provider].tokenHelp, provider).toMatch(/issue/i);
+    }
+  });
+
+  it("nennt einen konkreten Scope statt nur 'Leserechte'", () => {
+    // GitLab nennt Scopes in Anfuehrungszeichen, GitHub und Gitea
+    // Berechtigungsnamen – gemeinsam ist, dass etwas Nachschlagbares dasteht.
+    expect(PROVIDER_META.GITLAB.tokenHelp).toMatch(/read_api/);
+    expect(PROVIDER_META.GITEA.tokenHelp).toMatch(/read:repository/);
+    expect(PROVIDER_META.GITHUB.tokenHelp).toMatch(/Metadata/);
+  });
+});
+
+describe("guessProvider", () => {
+  it("erkennt die oeffentlichen Instanzen am Hostnamen", () => {
+    expect(guessProvider("github.com")).toBe("GITHUB");
+    expect(guessProvider("gitlab.com")).toBe("GITLAB");
+  });
+
+  it("faellt bei allem anderen auf Gitea zurueck", () => {
+    // Selbst gehostet ist hier der haeufigste Fall, und Gitea die
+    // wahrscheinlichste Wahl dafuer.
+    expect(guessProvider("git.wilde-server.de")).toBe("GITEA");
+  });
+});

src/lib/git/meta.ts

@@ -12,19 +12,25 @@ export const PROVIDER_META: Record<
     label: "GitHub",
     defaultBaseUrl: "https://github.com",
     tokenHelp:
-      "Fine-grained Token mit Lesezugriff auf Contents, Metadata, Issues und Pull Requests.",
+      "Fine-grained Token, alle nur lesend: Metadata, Contents, Issues, Pull requests " +
+      "und Actions. Nur wenn Aufgaben als Issue angelegt werden sollen, Issues " +
+      "zusaetzlich schreiben.",
     docsUrl: "https://github.com/settings/tokens",
   },
   GITLAB: {
     label: "GitLab",
     defaultBaseUrl: "https://gitlab.com",
-    tokenHelp: "Personal Access Token mit Scope 'read_api' (bzw. 'read_repository').",
+    tokenHelp:
+      "Scope 'read_api' genuegt fuer den Abgleich. Aufgaben als Issue anzulegen verlangt " +
+      "'api' – GitLab kennt keinen schmaleren Schreibzugriff.",
     docsUrl: "https://gitlab.com/-/user_settings/personal_access_tokens",
   },
   GITEA: {
     label: "Gitea / Forgejo",
     defaultBaseUrl: "https://git.example.com",
-    tokenHelp: "Access Token mit Leserechten auf repository, issue und user.",
+    tokenHelp:
+      "read:repository, read:issue und read:user. Nur wenn Aufgaben als Issue angelegt " +
+      "werden sollen, zusaetzlich write:issue.",
     docsUrl: "https://docs.gitea.com/development/api-usage",
   },
 };

src/lib/git/schreibzugriffe.test.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Waechter ueber eine Zusage in der Dokumentation.
+ *
+ * README und FEATURES sagen zu, dass Nebula an genau zwei Stellen nach
+ * draussen schreibt: ein Issue anlegen und seinen Zustand umsetzen. Auf
+ * dieser Zusage steht die Empfehlung, ein rein lesendes Token zu vergeben,
+ * solange die Issue-Anbindung nicht gebraucht wird.
+ *
+ * Kaeme ein dritter Schreibaufruf dazu, wuerde die Empfehlung still falsch:
+ * niemand bekaeme einen Fehler, nur ein 403 an einer Stelle, die laut
+ * Dokumentation gar nicht schreibt. Deshalb wird hier der Quelltext selbst
+ * abgeklopft – sendJson ist der einzige Weg aus lib/git heraus, der eine
+ * andere Methode als GET benutzt (siehe http.ts).
+ */
+const CLIENTS = ["gitea.ts", "github.ts", "gitlab.ts"] as const;
+
+/** Die Zeile ueber dem Methoden-Argument nennt den Endpunkt. */
+function schreibaufrufe(quelltext: string): string[] {
+  const zeilen = quelltext.split("\n");
+  const gefunden: string[] = [];
+  zeilen.forEach((zeile, i) => {
+    if (!/\bsendJson[<(]/.test(zeile)) return;
+    // sendJson(url, METHODE, …) – Endpunkt und Methode stehen darunter.
+    const block = zeilen.slice(i, i + 4).join(" ");
+    const methode = block.match(/"(POST|PATCH|PUT)"/)?.[1];
+    const pfad = block.match(/\/issues[^`"']*/)?.[0] ?? "?";
+    gefunden.push(`${methode ?? "?"} ${pfad}`);
+  });
+  return gefunden;
+}
+
+describe("Schreibzugriffe nach draussen", () => {
+  it("beschraenken sich auf Issues anlegen und Zustand setzen", () => {
+    for (const datei of CLIENTS) {
+      const quelltext = readFileSync(join(__dirname, datei), "utf8");
+      const aufrufe = schreibaufrufe(quelltext);
+
+      expect(aufrufe.length, `${datei}: Anzahl Schreibaufrufe`).toBe(2);
+      for (const aufruf of aufrufe) {
+        expect(aufruf, `${datei}: ${aufruf}`).toMatch(/^(POST|PATCH|PUT) \/issues/);
+      }
+      // Genau einer legt an, genau einer setzt um.
+      expect(aufrufe.filter((a) => a.startsWith("POST")).length, datei).toBe(1);
+      expect(aufrufe.filter((a) => /^(PATCH|PUT)/.test(a)).length, datei).toBe(1);
+    }
+  });
+
+  it("laufen ueber sendJson, nicht an http.ts vorbei", () => {
+    // Ein direkter fetch in einem Client haette weder SSRF-Schutz noch
+    // Zeitbegrenzung – und wuerde am Waechter oben vorbeilaufen.
+    for (const datei of CLIENTS) {
+      const quelltext = readFileSync(join(__dirname, datei), "utf8");
+      expect(quelltext, datei).not.toMatch(/\bfetch\s*\(/);
+    }
+  });
+});

src/lib/git/types.ts

@@ -99,6 +99,15 @@ export interface RepoSnapshotData extends RepoOverview {
   ci: CiInfo | null;
   /** Commits je Tag der letzten 30 Tage, aeltester zuerst. */
   commitActivity: number[];
+  /**
+   * Teil-Abrufe, die nicht geklappt haben: Feldname -> Grund mit HTTP-Status.
+   * Leer heisst, dass alle Listen wirklich geholt wurden.
+   *
+   * Der Unterschied ist wesentlich: eine leere Liste in `tags` bedeutet mit
+   * einem Eintrag hier "nicht geholt" und ohne ihn "es gibt keine Tags".
+   * Nur im ersten Fall darf der gespeicherte Stand stehen bleiben.
+   */
+  missing: Record<string, string>;
 }
 
 /** Tage, ueber die die Commit-Aktivitaet gebildet wird. */

src/lib/review.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+import {
+  berlinMitternacht,
+  tagesschluessel,
+  wocheUm,
+  wochenName,
+  wochenTitel,
+  zaehleWoche,
+} from "./review";
+
+describe("tagesschluessel", () => {
+  it("rechnet in Berliner Kalendertagen, nicht in UTC", () => {
+    // 22:30 UTC ist in Berlin schon der Folgetag (Sommerzeit, UTC+2).
+    expect(tagesschluessel(new Date("2026-08-17T22:30:00Z"))).toBe("2026-08-18");
+    expect(tagesschluessel(new Date("2026-08-17T21:00:00Z"))).toBe("2026-08-17");
+  });
+});
+
+describe("berlinMitternacht", () => {
+  it("trifft den Sommerzeit-Beginn des Tages", () => {
+    // Sommerzeit: Berlin = UTC+2, Mitternacht dort ist 22:00 UTC am Vortag.
+    expect(berlinMitternacht("2026-08-17").toISOString()).toBe("2026-08-16T22:00:00.000Z");
+  });
+
+  it("trifft den Winterzeit-Beginn des Tages", () => {
+    // Winterzeit: UTC+1.
+    expect(berlinMitternacht("2026-01-12").toISOString()).toBe("2026-01-11T23:00:00.000Z");
+  });
+});
+
+describe("wocheUm", () => {
+  /** Ein Dienstag. */
+  const DIENSTAG = new Date("2026-08-18T09:00:00Z");
+
+  it("beginnt am Montag und endet am folgenden Montag", () => {
+    const woche = wocheUm(DIENSTAG);
+    expect(woche.tage[0]).toBe("2026-08-17");
+    expect(woche.tage[6]).toBe("2026-08-23");
+    expect(woche.tage).toHaveLength(7);
+    expect(woche.von.toISOString()).toBe("2026-08-16T22:00:00.000Z");
+    expect(woche.bis.toISOString()).toBe("2026-08-23T22:00:00.000Z");
+  });
+
+  it("zaehlt den Montag selbst zur laufenden Woche", () => {
+    const montag = new Date("2026-08-17T06:00:00Z");
+    expect(wocheUm(montag).tage[0]).toBe("2026-08-17");
+  });
+
+  it("zaehlt den Sonntagabend noch zur ablaufenden Woche", () => {
+    // 21:00 UTC am Sonntag ist in Berlin 23:00 – noch derselbe Tag.
+    const sonntagAbend = new Date("2026-08-23T21:00:00Z");
+    expect(wocheUm(sonntagAbend).tage[0]).toBe("2026-08-17");
+    // Zwei Stunden spaeter ist Montag und damit die naechste Woche.
+    const montagFrueh = new Date("2026-08-23T22:30:00Z");
+    expect(wocheUm(montagFrueh).tage[0]).toBe("2026-08-24");
+  });
+
+  it("blättert rückwärts", () => {
+    expect(wocheUm(DIENSTAG, -1).tage[0]).toBe("2026-08-10");
+    expect(wocheUm(DIENSTAG, -3).tage[0]).toBe("2026-07-27");
+  });
+
+  it("kommt über den Monats- und Jahreswechsel", () => {
+    const neujahr = new Date("2027-01-01T12:00:00Z"); // ein Freitag
+    const woche = wocheUm(neujahr);
+    expect(woche.tage[0]).toBe("2026-12-28");
+    expect(woche.tage[6]).toBe("2027-01-03");
+  });
+
+  it("bleibt über die Zeitumstellung hinweg sieben Tage lang", () => {
+    // Am 25.10.2026 wird auf Winterzeit zurueckgestellt – die Woche hat
+    // dann 169 Stunden. "von + 7 Tage" waere hier eine Stunde daneben.
+    const inDerWoche = new Date("2026-10-21T12:00:00Z");
+    const woche = wocheUm(inDerWoche);
+    expect(woche.tage[0]).toBe("2026-10-19");
+    expect(woche.tage[6]).toBe("2026-10-25");
+    const stunden = (woche.bis.getTime() - woche.von.getTime()) / 3_600_000;
+    expect(stunden).toBe(169);
+  });
+
+  it("liefert bei der Umstellung im Fruehjahr 167 Stunden", () => {
+    // Vorgestellt wird am letzten Sonntag im Maerz – 2026 ist das der 29.,
+    // er liegt also in der Woche ab Montag, dem 23.
+    const inDerWoche = new Date("2026-03-25T12:00:00Z");
+    const woche = wocheUm(inDerWoche);
+    expect(woche.tage[0]).toBe("2026-03-23");
+    expect(woche.tage[6]).toBe("2026-03-29");
+    const stunden = (woche.bis.getTime() - woche.von.getTime()) / 3_600_000;
+    expect(stunden).toBe(167);
+  });
+
+  it("hat in einer Woche ohne Umstellung genau 168 Stunden", () => {
+    const woche = wocheUm(new Date("2026-03-31T12:00:00Z"));
+    expect(woche.tage[0]).toBe("2026-03-30");
+    expect((woche.bis.getTime() - woche.von.getTime()) / 3_600_000).toBe(168);
+  });
+});
+
+describe("Beschriftung", () => {
+  const DIENSTAG = new Date("2026-08-18T09:00:00Z");
+
+  it("nennt die laufende und die vorige Woche beim Namen", () => {
+    expect(wochenName(wocheUm(DIENSTAG))).toBe("Diese Woche");
+    expect(wochenName(wocheUm(DIENSTAG, -1))).toBe("Vorige Woche");
+  });
+
+  it("nennt weiter zurueckliegende Wochen mit Zeitraum", () => {
+    expect(wochenName(wocheUm(DIENSTAG, -2))).toMatch(/\d/);
+  });
+
+  it("nennt den Monat nur einmal, wenn die Woche nicht darueber hinausgeht", () => {
+    expect(wochenTitel(wocheUm(DIENSTAG))).toBe("17.–23. August 2026");
+  });
+
+  it("nennt beide Monate, wenn die Woche sie ueberspannt", () => {
+    // 31.08. bis 06.09.2026.
+    const woche = wocheUm(new Date("2026-09-02T12:00:00Z"));
+    expect(wochenTitel(woche)).toBe("31. August–6. September 2026");
+  });
+});
+
+describe("zaehleWoche", () => {
+  const eintrag = (
+    kind: Parameters<typeof zaehleWoche>[0][number]["kind"],
+    projectId: string,
+    meta?: unknown,
+  ) => ({ kind, projectId, meta });
+
+  it("zaehlt Erledigtes am meta-Feld, nicht am Text", () => {
+    const zahlen = zaehleWoche([
+      eintrag("TASK_MOVED", "p1", { from: "TODO", to: "DONE" }),
+      // Verschoben, aber nicht erledigt – darf nicht mitzaehlen.
+      eintrag("TASK_MOVED", "p1", { from: "TODO", to: "DOING" }),
+    ]);
+    expect(zahlen.erledigt).toBe(1);
+  });
+
+  it("zaehlt einen Eintrag ohne meta nicht als erledigt", () => {
+    // Aeltere Eintraege koennen kein "to" haben. Lieber untertreiben als
+    // eine Zahl behaupten, die aus dem Anzeigetext geraten waere.
+    expect(zaehleWoche([eintrag("TASK_MOVED", "p1")]).erledigt).toBe(0);
+    expect(zaehleWoche([eintrag("TASK_MOVED", "p1", "unsinn")]).erledigt).toBe(0);
+  });
+
+  it("zaehlt neue Aufgaben aus beiden Quellen", () => {
+    const zahlen = zaehleWoche([
+      eintrag("TASK_ADDED", "p1"),
+      eintrag("TASKS_IMPORTED", "p2"),
+    ]);
+    expect(zahlen.neueAufgaben).toBe(2);
+  });
+
+  it("zaehlt beruehrte Projekte ohne Dubletten", () => {
+    const zahlen = zaehleWoche([
+      eintrag("NOTE_ADDED", "p1"),
+      eintrag("NOTE_ADDED", "p1"),
+      eintrag("REPO_COMMITS", "p2"),
+    ]);
+    expect(zahlen.projekte).toBe(2);
+    expect(zahlen.notizen).toBe(2);
+    expect(zahlen.gesamt).toBe(3);
+  });
+
+  it("kommt mit einer leeren Woche zurecht", () => {
+    expect(zaehleWoche([])).toEqual({
+      gesamt: 0,
+      projekte: 0,
+      erledigt: 0,
+      neueAufgaben: 0,
+      notizen: 0,
+    });
+  });
+});

src/lib/review.ts

@@ -0,0 +1,203 @@
+import type { ActivityKind } from "@prisma/client";
+
+/**
+ * Wochenrueckblick: welche Woche, und was zaehlt darin.
+ *
+ * Die Wochenrechnung steht hier als reine Funktion und nicht in der Seite –
+ * Wochengrenzen sind der Teil, der still falsch wird, und so laesst er sich
+ * pruefen.
+ */
+
+/** Wochenbeginn ist Montag, wie in Deutschland ueblich (ISO 8601). */
+export const WOCHENBEGINN = 1;
+
+/**
+ * Kalendertag in fester Zeitzone.
+ *
+ * Dieselbe Ueberlegung wie bei den Faelligkeiten in lib/tasks: im Container
+ * laeuft die Anwendung nach UTC. Um 23:30 Berliner Zeit waere dort noch der
+ * Vortag, und ein Eintrag von Sonntagabend fiele in die falsche Woche.
+ */
+const TAG_FORMAT = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Europe/Berlin",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+});
+
+/** "2026-08-17" in Berliner Zeit. */
+export function tagesschluessel(wert: Date): string {
+  return TAG_FORMAT.format(wert);
+}
+
+/** Wochentag in Berliner Zeit, 0 = Sonntag. */
+function wochentag(wert: Date): number {
+  const [jahr, monat, tag] = tagesschluessel(wert).split("-").map(Number);
+  return new Date(Date.UTC(jahr, monat - 1, tag)).getUTCDay();
+}
+
+export interface Woche {
+  /** Beginn des Montags, als Zeitpunkt fuer die Abfrage. */
+  von: Date;
+  /** Beginn des folgenden Montags – ausschliesslich. */
+  bis: Date;
+  /** 0 = laufende Woche, -1 = vorige, … */
+  versatz: number;
+  /** Die sieben Kalendertage der Woche, Montag zuerst. */
+  tage: string[];
+}
+
+/**
+ * Grenzen der Woche, in der `jetzt` liegt – um `versatz` Wochen verschoben.
+ *
+ * Gerechnet wird ueber die Kalendertage in Berliner Zeit und dann in UTC
+ * zurueckgerechnet. Der Umweg ist noetig, weil zwischen zwei Montagen eine
+ * Zeitumstellung liegen kann: "sieben mal 24 Stunden" waere dann um eine
+ * Stunde daneben.
+ */
+export function wocheUm(jetzt: Date, versatz = 0): Woche {
+  const [jahr, monat, tag] = tagesschluessel(jetzt).split("-").map(Number);
+  const heuteUtc = Date.UTC(jahr, monat - 1, tag);
+
+  // Rueckwaerts bis zum Montag.
+  const abstandZumMontag = (wochentag(jetzt) - WOCHENBEGINN + 7) % 7;
+  const montag = new Date(heuteUtc - (abstandZumMontag - versatz * 7) * 86_400_000);
+
+  const tage: string[] = [];
+  for (let i = 0; i < 7; i += 1) {
+    tage.push(new Date(montag.getTime() + i * 86_400_000).toISOString().slice(0, 10));
+  }
+
+  const von = berlinMitternacht(tage[0]);
+  return {
+    von,
+    // Ende ist die Mitternacht *nach* dem Sonntag – nicht "von + 7 Tage":
+    // liegt eine Zeitumstellung dazwischen, ist die Woche 167 oder 169
+    // Stunden lang.
+    bis: berlinMitternacht(naechsterTag(tage[6])),
+    versatz,
+    tage,
+  };
+}
+
+/** Ein Kalendertag weiter, rein auf der Zeichenkette gerechnet. */
+function naechsterTag(tag: string): string {
+  const [j, m, t] = tag.split("-").map(Number);
+  return new Date(Date.UTC(j, m - 1, t) + 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * Um wie viel geht die Berliner Uhr zu diesem Zeitpunkt der UTC voraus?
+ *
+ * Ermittelt statt fest verdrahtet, weil zwischen Sommer- und Winterzeit eine
+ * Stunde Unterschied liegt und ein Rueckblick ueber die Umstellung hinweg
+ * sonst um eine Stunde verrutscht.
+ */
+function zonenversatzMs(zeitpunkt: Date): number {
+  // sv-SE liefert "2026-08-17 14:30:00" – nah genug an ISO, um es nach dem
+  // Austausch des Leerzeichens wieder einlesen zu koennen.
+  const berlin = new Intl.DateTimeFormat("sv-SE", {
+    timeZone: "Europe/Berlin",
+    dateStyle: "short",
+    timeStyle: "medium",
+  }).format(zeitpunkt);
+  return Date.parse(`${berlin.replace(" ", "T")}Z`) - zeitpunkt.getTime();
+}
+
+/** Der Zeitpunkt, an dem in Berlin dieser Kalendertag beginnt. */
+export function berlinMitternacht(tag: string): Date {
+  const basis = new Date(`${tag}T00:00:00Z`);
+  // Die Umstellung findet nachts um zwei statt, nie um Mitternacht – der
+  // Versatz an dieser Stelle ist also eindeutig.
+  return new Date(basis.getTime() - zonenversatzMs(basis));
+}
+
+export interface Kennzahlen {
+  gesamt: number;
+  projekte: number;
+  erledigt: number;
+  neueAufgaben: number;
+  notizen: number;
+}
+
+/** Was ein Verlaufseintrag fuer die Zaehlung hergeben muss. */
+export interface ZaehlbarerEintrag {
+  kind: ActivityKind;
+  projectId: string;
+  meta?: unknown;
+}
+
+/**
+ * Kennzahlen einer Woche.
+ *
+ * "Erledigt" kommt aus dem `meta`-Feld (`to: "DONE"`) und nicht aus dem
+ * Anzeigetext. Der Text ist zum Lesen da und aendert sich mit der
+ * Formulierung – eine Zaehlung, die daran haengt, wird beim naechsten
+ * umformulierten Einzeiler still falsch.
+ *
+ * Fuer aeltere Eintraege ohne `to` bleibt ein Rueckfall auf den Text: der
+ * Verlauf haelt bis zu 200 Eintraege je Projekt, darunter also durchaus
+ * welche von vor dieser Aenderung.
+ */
+export function zaehleWoche(eintraege: ZaehlbarerEintrag[]): Kennzahlen {
+  let erledigt = 0;
+  let neueAufgaben = 0;
+  let notizen = 0;
+  const projekte = new Set<string>();
+
+  for (const eintrag of eintraege) {
+    projekte.add(eintrag.projectId);
+
+    if (eintrag.kind === "TASK_ADDED" || eintrag.kind === "TASKS_IMPORTED") {
+      neueAufgaben += 1;
+    } else if (eintrag.kind === "NOTE_ADDED") {
+      notizen += 1;
+    } else if (eintrag.kind === "TASK_MOVED" && istErledigt(eintrag)) {
+      erledigt += 1;
+    }
+  }
+
+  return { gesamt: eintraege.length, projekte: projekte.size, erledigt, neueAufgaben, notizen };
+}
+
+function istErledigt(eintrag: ZaehlbarerEintrag): boolean {
+  const meta = eintrag.meta;
+  if (meta && typeof meta === "object" && "to" in meta) {
+    return (meta as { to?: unknown }).to === "DONE";
+  }
+  return false;
+}
+
+const MONAT_FORMAT = new Intl.DateTimeFormat("de-DE", {
+  timeZone: "Europe/Berlin",
+  month: "long",
+});
+
+/**
+ * Beschriftung einer Woche: "17.–23. August 2026", ueber einen
+ * Monatswechsel hinweg "31. August–6. September 2026".
+ *
+ * Der Punkt hinter der Tageszahl kommt von Hand: Intl liefert bei
+ * `day: "numeric"` nur die Ziffer, und mit `day: "2-digit"` staende dort
+ * "07." statt "7.".
+ */
+export function wochenTitel(woche: Woche): string {
+  const teile = (tag: string) => {
+    const [j, m, t] = tag.split("-").map(Number);
+    return { tag: t, monat: MONAT_FORMAT.format(new Date(Date.UTC(j, m - 1, t, 12))), jahr: j };
+  };
+
+  const von = teile(woche.tage[0]);
+  const bis = teile(woche.tage[6]);
+  const gleicherMonat = von.monat === bis.monat && von.jahr === bis.jahr;
+
+  const links = gleicherMonat ? `${von.tag}.` : `${von.tag}. ${von.monat}`;
+  return `${links}–${bis.tag}. ${bis.monat} ${bis.jahr}`;
+}
+
+/** "Diese Woche", "Vorige Woche", sonst der Zeitraum. */
+export function wochenName(woche: Woche): string {
+  if (woche.versatz === 0) return "Diese Woche";
+  if (woche.versatz === -1) return "Vorige Woche";
+  return wochenTitel(woche);
+}

src/lib/sync/index.ts

@@ -12,6 +12,15 @@ export interface SyncResult {
   ok: boolean;
   message: string;
   fetchedAt?: string;
+  /**
+   * Der Abgleich lief durch, aber einzelne Listen kamen nicht an.
+   *
+   * Getrennt von `ok`, weil beides verschiedene Folgen hat: `ok: false`
+   * setzt syncError, zaehlt Fehlversuche und haelt das Repository beim
+   * naechsten Durchlauf zurueck. Ein unvollstaendiger Abgleich soll nichts
+   * davon ausloesen – der Rest ist ja frisch – aber sichtbar sein.
+   */
+  unvollstaendig?: boolean;
 }
 
 /**
@@ -19,7 +28,9 @@ export interface SyncResult {
  * in die Datenbank. Fehler werden am Repository vermerkt statt geworfen,
  * damit ein kaputtes Repo nicht das ganze Dashboard blockiert.
  */
-export async function syncRepository(repositoryId: string): Promise<SyncResult> {
+export async function syncRepository(
+  repositoryId: string,
+): Promise<SyncResult> {
   const repository = await prisma.repository.findUnique({
     where: { id: repositoryId },
     include: { connection: true },
@@ -33,7 +44,8 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
   if (!ref) {
     return {
       ok: false,
-      message: "Kein Repository hinterlegt – bitte Repo-URL oder Owner/Name setzen.",
+      message:
+        "Kein Repository hinterlegt – bitte Repo-URL oder Owner/Name setzen.",
     };
   }
 
@@ -46,7 +58,8 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
     if (!parsed) {
       return {
         ok: false,
-        message: "Keine Git-Verbindung ausgewaehlt und die Repo-URL ist nicht auswertbar.",
+        message:
+          "Keine Git-Verbindung ausgewaehlt und die Repo-URL ist nicht auswertbar.",
       };
     }
     client = createClient({
@@ -81,10 +94,28 @@ export async function syncRepository(repositoryId: string): Promise<SyncResult>
 
     // Nach dem Speichern, damit die Meldung den neuen Stand sieht.
     await notifyAfterSync(repository.id);
+
+    /**
+     * Fehlgeschlagene Teile gehoeren in die Meldung.
+     *
+     * Vorher stand hier "Snapshot aktualisiert: 0 Branches, 0 Tags" – und das
+     * war die einzige Spur, wenn saemtliche Listen unterwegs verloren gingen.
+     * Wer das liest, denkt an ein leeres Repository, nicht an einen Fehler.
+     */
+    // Sortiert, damit die Meldung bei jedem Durchlauf gleich aussieht –
+    // die Reihenfolge im Objekt haengt sonst daran, welcher Aufruf zuerst
+    // gescheitert ist.
+    const fehlend = Object.keys(data.missing).sort();
+    const zahlen = fehlend.length
+      ? `Teilweise aktualisiert – nicht geholt: ${fehlend.join(", ")}. ` +
+        `Der vorherige Stand bleibt dafuer stehen.`
+      : `Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.`;
+
     return {
       ok: true,
+      unvollstaendig: fehlend.length > 0,
       message:
-        `Snapshot aktualisiert: ${data.branches.length} Branches, ${data.tags.length} Tags.` +
+        zahlen +
         (abgehakt > 0
           ? ` ${abgehakt} Aufgabe(n) abgehakt, weil das Issue geschlossen wurde.`
           : ""),
@@ -127,7 +158,9 @@ export interface ProjectSyncResult extends SyncResult {
  * beim selben Anbieter, und ein Schwung gleichzeitiger Anfragen ist genau
  * das, worauf Rate-Limits reagieren.
  */
-export async function syncProject(projectId: string): Promise<ProjectSyncResult> {
+export async function syncProject(
+  projectId: string,
+): Promise<ProjectSyncResult> {
   const repositories = await prisma.repository.findMany({
     where: { projectId },
     orderBy: [{ position: "asc" }, { createdAt: "asc" }],
@@ -214,7 +247,10 @@ async function maybeRefreshCalendar(
     // Rate-Limit, Zeitueberschreitung, Ausfall: der Kalender ist Beiwerk und
     // soll den Abgleich nicht scheitern lassen. Ohne Zeitstempel versucht es
     // der naechste Durchgang von selbst wieder.
-    console.error("[nebula] Commit-Kalender konnte nicht geholt werden:", error);
+    console.error(
+      "[nebula] Commit-Kalender konnte nicht geholt werden:",
+      error,
+    );
   }
 }
 
@@ -294,7 +330,9 @@ async function noteNewCommits(
   // Zahl als mit einer falschen.
   const index = data.commits.findIndex((commit) => commit.sha === vorher);
   const anzahl = index > 0 ? index : null;
-  const wo = data.defaultBranch ? `${repoTitle(repository)} · ${data.defaultBranch}` : repoTitle(repository);
+  const wo = data.defaultBranch
+    ? `${repoTitle(repository)} · ${data.defaultBranch}`
+    : repoTitle(repository);
   const betreff = shorten(data.commits[0]?.message ?? "", 60);
 
   await recordActivity({
@@ -304,16 +342,38 @@ async function noteNewCommits(
       anzahl === null
         ? `Neue Commits in ${wo}: ${betreff}`
         : `${anzahl} neue${anzahl === 1 ? "r" : ""} Commit${anzahl === 1 ? "" : "s"} in ${wo}: ${betreff}`,
-    meta: { repositoryId: repository.id, from: vorher, to: neuester, count: anzahl },
+    meta: {
+      repositoryId: repository.id,
+      from: vorher,
+      to: neuester,
+      count: anzahl,
+    },
   });
 }
 
 async function persistSnapshot(repository: Repository, data: RepoSnapshotData) {
   const latestCommit = data.commits[0] ?? null;
   const latestRelease =
-    data.releases.find((release) => !release.draft && !release.prerelease) ?? data.releases[0] ?? null;
+    data.releases.find((release) => !release.draft && !release.prerelease) ??
+    data.releases[0] ??
+    null;
   const latestTag = data.tags[0]?.name ?? latestRelease?.tag ?? null;
 
+  /**
+   * Ein Teil, der nicht geholt werden konnte, bleibt so, wie er war.
+   *
+   * Vorher wurde bedingungslos ueberschrieben. Kam eine Liste leer zurueck,
+   * weil der Abruf gescheitert war, ersetzte sie den letzten guten Stand –
+   * ein Klick auf "Jetzt synchronisieren" genuegte, und die Commits eines
+   * Repositories waren weg. Der Snapshot ist ein Zwischenspeicher: ein
+   * alter Stand ist immer brauchbarer als eine leere Liste, die aussieht
+   * wie eine Aussage.
+   */
+  const geholt = <T>(feld: string, wert: T): T | undefined =>
+    feld in data.missing ? undefined : wert;
+
+  const vollstaendig = Object.keys(data.missing).length === 0;
+
   const payload = {
     fullName: data.fullName,
     description: data.description,
@@ -325,30 +385,55 @@ async function persistSnapshot(repository: Repository, data: RepoSnapshotData) {
     openIssues: data.openIssues,
     openPullRequests: data.openPullRequests,
     sizeKb: data.sizeKb,
-    lastCommitSha: latestCommit?.sha ?? null,
+    // Die Commit-Felder haengen alle an derselben Liste – entweder alle
-    lastCommitMessage: latestCommit?.message ?? null,
+    // neu oder alle unveraendert. Halb aktualisiert waeren sie in sich
-    lastCommitAuthor: latestCommit?.author ?? null,
+    // widerspruechlich.
-    lastCommitAt: latestCommit?.date ? new Date(latestCommit.date) : null,
+    lastCommitSha: geholt("commits", latestCommit?.sha ?? null),
-    latestTag,
+    lastCommitMessage: geholt("commits", latestCommit?.message ?? null),
-    latestRelease: latestRelease?.name ?? null,
+    lastCommitAuthor: geholt("commits", latestCommit?.author ?? null),
-    latestReleaseAt: latestRelease?.publishedAt ? new Date(latestRelease.publishedAt) : null,
+    lastCommitAt: geholt(
-    branchCount: data.branches.length,
+      "commits",
-    tagCount: data.tags.length,
+      latestCommit?.date ? new Date(latestCommit.date) : null,
-    branches: data.branches as unknown as object,
+    ),
-    tags: data.tags as unknown as object,
+    // latestTag faellt auf den Release-Tag zurueck; steht einer der beiden
-    commits: data.commits as unknown as object,
+    // Abrufe aus, ist die Ableitung nicht mehr belastbar.
-    releases: data.releases as unknown as object,
+    latestTag:
-    languages: data.languages as unknown as object,
+      "tags" in data.missing || "releases" in data.missing
-    pullRequests: data.pullRequests as unknown as object,
+        ? undefined
-    issues: data.issues as unknown as object,
+        : latestTag,
-    commitActivity: data.commitActivity as unknown as object,
+    latestRelease: geholt("releases", latestRelease?.name ?? null),
-    ciState: data.ci?.state ?? null,
+    latestReleaseAt: geholt(
-    ciName: data.ci?.name ?? null,
+      "releases",
-    ciBranch: data.ci?.branch ?? null,
+      latestRelease?.publishedAt ? new Date(latestRelease.publishedAt) : null,
-    ciUrl: data.ci?.url ?? null,
+    ),
-    ciFinishedAt: data.ci?.finishedAt ? new Date(data.ci.finishedAt) : null,
+    branchCount: geholt("branches", data.branches.length),
+    tagCount: geholt("tags", data.tags.length),
+    branches: geholt("branches", data.branches as unknown as object),
+    tags: geholt("tags", data.tags as unknown as object),
+    commits: geholt("commits", data.commits as unknown as object),
+    releases: geholt("releases", data.releases as unknown as object),
+    languages: geholt("languages", data.languages as unknown as object),
+    pullRequests: geholt(
+      "pullRequests",
+      data.pullRequests as unknown as object,
+    ),
+    issues: geholt("issues", data.issues as unknown as object),
+    // Die Kurve wird aus den Commits gerechnet – ohne sie waere sie leer.
+    commitActivity: geholt("commits", data.commitActivity as unknown as object),
+    ciState: geholt("ci", data.ci?.state ?? null),
+    ciName: geholt("ci", data.ci?.name ?? null),
+    ciBranch: geholt("ci", data.ci?.branch ?? null),
+    ciUrl: geholt("ci", data.ci?.url ?? null),
+    ciFinishedAt: geholt(
+      "ci",
+      data.ci?.finishedAt ? new Date(data.ci.finishedAt) : null,
+    ),
     pushedAt: data.pushedAt ? new Date(data.pushedAt) : null,
+    missing: data.missing as unknown as object,
     fetchedAt: new Date(),
+    // Nur setzen, wenn wirklich alles ankam. Sonst bleibt der Zeitpunkt
+    // stehen, an dem der Stand zuletzt vollstaendig war.
+    ...(vollstaendig ? { completeAt: new Date() } : {}),
   };
 
   // Vor dem Ueberschreiben lesen – danach ist der alte Stand weg.

src/lib/tasks.test.ts

@@ -7,6 +7,7 @@ import {
   dueBucket,
   nextDueDate,
   progressFromTasks,
+  spaltenAnzeige,
 } from "./tasks";
 
 describe("progressFromTasks", () => {
@@ -136,3 +137,48 @@ describe("dueBucket", () => {
     }
   });
 });
+
+describe("spaltenAnzeige", () => {
+  it("zeigt alles, solange die Spalte unter der Grenze bleibt", () => {
+    expect(spaltenAnzeige(3, 15, false)).toEqual({ sichtbar: 3, verborgen: 0 });
+    // Genau auf der Grenze ist noch nichts zu verbergen – sonst stuende
+    // "0 weitere anzeigen" an der Spalte.
+    expect(spaltenAnzeige(15, 15, false)).toEqual({ sichtbar: 15, verborgen: 0 });
+  });
+
+  it("kappt darueber und sagt, wie viele dahinter warten", () => {
+    expect(spaltenAnzeige(40, 15, false)).toEqual({ sichtbar: 15, verborgen: 25 });
+  });
+
+  it("nimmt 0 als 'ohne Begrenzung'", () => {
+    // Dieselbe Lesart wie SESSION_IDLE_HOURS. Waere 0 woertlich gemeint,
+    // zeigte das Brett gar nichts mehr.
+    expect(spaltenAnzeige(200, 0, false)).toEqual({ sichtbar: 200, verborgen: 0 });
+  });
+
+  it("behandelt eine negative Grenze wie keine", () => {
+    // Die API laesst sie nicht durch; ein alter Datenbankstand oder ein
+    // Handgriff in psql koennte sie aber liefern.
+    expect(spaltenAnzeige(9, -5, false)).toEqual({ sichtbar: 9, verborgen: 0 });
+  });
+
+  it("zeigt entfaltet wieder alles", () => {
+    expect(spaltenAnzeige(40, 15, true)).toEqual({ sichtbar: 40, verborgen: 0 });
+  });
+
+  it("meldet nie mehr Sichtbares als vorhanden", () => {
+    // Sonst liefe das slice() in der Spalte ins Leere und die Zahl am Knopf
+    // waere negativ.
+    for (const anzahl of [0, 1, 7, 15, 16, 99]) {
+      for (const limit of [0, 1, 15, 100]) {
+        for (const entfaltet of [true, false]) {
+          const { sichtbar, verborgen } = spaltenAnzeige(anzahl, limit, entfaltet);
+          expect(sichtbar, `${anzahl}/${limit}/${entfaltet}`).toBeLessThanOrEqual(anzahl);
+          expect(verborgen).toBeGreaterThanOrEqual(0);
+          // Zusammen ergeben sie immer die ganze Spalte – nichts faellt weg.
+          expect(sichtbar + verborgen).toBe(anzahl);
+        }
+      }
+    }
+  });
+});

src/lib/tasks.ts

@@ -168,6 +168,29 @@ export async function spawnRecurrence(taskId: string) {
  * nicht die Spalte, sondern der Termin: projektuebergreifend ist "was ist
  * ueberfaellig" die Frage, nicht "was steht in welcher Spalte".
  */
+/**
+ * Wie viele Karten eine Spalte des Aufgabenbretts zeigt – und wie viele
+ * dahinter warten.
+ *
+ * Begrenzt wird ausschliesslich die *Anzeige*. Der Zustand im Brett bleibt
+ * vollstaendig, weil das Umsortieren je Spalte die ganze Liste an den Server
+ * schickt: waere sie hier schon gekuerzt, wuerden die verborgenen Aufgaben
+ * beim naechsten Ziehen aus dem Brett fallen.
+ *
+ * `limit` 0 heisst "ohne Begrenzung" – dieselbe Lesart wie bei
+ * SESSION_IDLE_HOURS.
+ */
+export function spaltenAnzeige(
+  anzahl: number,
+  limit: number,
+  entfaltet: boolean,
+): { sichtbar: number; verborgen: number } {
+  if (limit <= 0 || entfaltet || anzahl <= limit) {
+    return { sichtbar: anzahl, verborgen: 0 };
+  }
+  return { sichtbar: limit, verborgen: anzahl - limit };
+}
+
 export const DUE_BUCKET_ORDER = ["overdue", "today", "week", "later", "someday"] as const;
 
 export type DueBucket = (typeof DUE_BUCKET_ORDER)[number];

src/lib/tasks/issues.ts

@@ -116,7 +116,15 @@ export async function completeTaskFromIssue(
       `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 },
+    // "from"/"to" wie beim Verschieben von Hand – der Wochenrueckblick
+    // zaehlt daran ab, was erledigt wurde, statt den Text zu durchsuchen.
+    meta: {
+      taskId: task.id,
+      issue: task.sourceIssue,
+      source: herkunft,
+      from: task.status,
+      to: "DONE",
+    },
   });
 
   return true;

src/lib/timeline.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { SEITE, SEITE_MAX, cursorAus, seitenBedingung, seitenGroesse } from "./timeline";
+
+const ID = "cmstxnrzs00011cx4nd5tiqbt";
+
+describe("cursorAus", () => {
+  it("liest Zeitpunkt und ID", () => {
+    const cursor = cursorAus("2026-08-17T22:30:00.000Z", ID);
+    expect(cursor?.id).toBe(ID);
+    expect(cursor?.createdAt.toISOString()).toBe("2026-08-17T22:30:00.000Z");
+  });
+
+  it("faengt ohne Cursor von vorn an", () => {
+    expect(cursorAus(null, null)).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", null)).toBeNull();
+    expect(cursorAus(null, ID)).toBeNull();
+  });
+
+  it("weist Unbrauchbares ab, statt es in die Abfrage zu geben", () => {
+    expect(cursorAus("kein datum", ID)).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", "kurz")).toBeNull();
+    expect(cursorAus("2026-08-17T22:30:00.000Z", "'; DROP TABLE x --")).toBeNull();
+  });
+});
+
+describe("seitenBedingung", () => {
+  it("filtert immer auf den Besitzer", () => {
+    expect(seitenBedingung("u1", null)).toEqual({ project: { ownerId: "u1" } });
+  });
+
+  it("behaelt den Besitzer auch mit Cursor", () => {
+    const wo = seitenBedingung("u1", { createdAt: new Date("2026-08-17T22:30:00Z"), id: ID });
+    expect(wo.project).toEqual({ ownerId: "u1" });
+  });
+
+  it("fasst gleichzeitige Eintraege ueber die ID auseinander", () => {
+    // Der eigentliche Zweck: beim Uebernehmen von Issues entstehen mehrere
+    // Zeilen mit identischem createdAt. Ohne den zweiten Zweig wuerde die
+    // naechste Seite sie ueberspringen oder wiederholen.
+    const zeitpunkt = new Date("2026-08-17T22:30:00Z");
+    const wo = seitenBedingung("u1", { createdAt: zeitpunkt, id: ID });
+    expect(wo.OR).toEqual([
+      { createdAt: { lt: zeitpunkt } },
+      { createdAt: zeitpunkt, id: { lt: ID } },
+    ]);
+  });
+});
+
+describe("seitenGroesse", () => {
+  it("nimmt die Vorgabe, wenn nichts angefragt wurde", () => {
+    expect(seitenGroesse(null)).toBe(SEITE);
+    expect(seitenGroesse("unsinn")).toBe(SEITE);
+  });
+
+  it("deckelt nach oben und unten", () => {
+    expect(seitenGroesse("1000")).toBe(SEITE_MAX);
+    expect(seitenGroesse("0")).toBe(1);
+    expect(seitenGroesse("-5")).toBe(1);
+  });
+
+  it("nimmt einen gueltigen Wert an", () => {
+    expect(seitenGroesse("25")).toBe(25);
+  });
+});

src/lib/timeline.ts

@@ -0,0 +1,77 @@
+import type { Prisma } from "@prisma/client";
+
+/**
+ * Fortlaufender Verlauf ueber alle Projekte.
+ *
+ * Geblaettert wird per Cursor, nicht per `skip`. Der Verlauf schreibt
+ * mehrere Eintraege im selben Augenblick – beim Uebernehmen von Issues etwa
+ * entstehen zehn Zeilen mit identischem `createdAt`. Ein Offset ueber eine
+ * solche Grenze hinweg ueberspringt Zeilen oder zeigt sie zweimal, und zwar
+ * lautlos. Der Cursor aus (createdAt, id) ist dagegen eindeutig.
+ */
+
+/** Wie viele Eintraege eine Seite hat. */
+export const SEITE = 40;
+/** Deckel gegen einen Aufrufer, der sich alles auf einmal holen will. */
+export const SEITE_MAX = 100;
+
+export interface Cursor {
+  /** Zeitpunkt des letzten gezeigten Eintrags. */
+  createdAt: Date;
+  /** Seine ID – entscheidet bei gleichem Zeitpunkt. */
+  id: string;
+}
+
+/**
+ * Liest einen Cursor aus Abfrageparametern.
+ *
+ * Gibt null zurueck, wenn nichts oder Unbrauchbares ankommt – dann faengt
+ * die Seite eben von vorn an. Ein Fehler waere hier die schlechtere Antwort:
+ * ein abgeschnittener Verweis soll die Seite nicht sperren.
+ */
+export function cursorAus(vor: string | null, id: string | null): Cursor | null {
+  if (!vor || !id) return null;
+  const zeitpunkt = new Date(vor);
+  if (Number.isNaN(zeitpunkt.getTime())) return null;
+  // Die ID ist eine cuid; alles andere weisen wir ab, statt es in die
+  // Abfrage zu geben.
+  if (!/^[a-z0-9]{20,32}$/i.test(id)) return null;
+  return { createdAt: zeitpunkt, id };
+}
+
+/**
+ * Die where-Bedingung fuer eine Seite.
+ *
+ * Besitzer zuerst – wie ueberall im Projekt, damit fremde Datensaetze gar
+ * nicht erst getroffen werden. Der Verlauf selbst kennt keinen Besitzer, die
+ * Bedingung laeuft deshalb ueber das Projekt.
+ *
+ * Der Cursor bedeutet "aelter als der letzte gezeigte Eintrag": entweder
+ * frueher, oder gleichzeitig und mit kleinerer ID. Genau so sortiert auch
+ * die Abfrage, weshalb beides zusammenpasst.
+ */
+export function seitenBedingung(ownerId: string, cursor: Cursor | null): Prisma.ActivityWhereInput {
+  const basis: Prisma.ActivityWhereInput = { project: { ownerId } };
+  if (!cursor) return basis;
+
+  return {
+    ...basis,
+    OR: [
+      { createdAt: { lt: cursor.createdAt } },
+      { createdAt: cursor.createdAt, id: { lt: cursor.id } },
+    ],
+  };
+}
+
+/** Sortierung, die zur Cursor-Bedingung passt. Beide muessen gleich sein. */
+export const SEITEN_ORDNUNG: Prisma.ActivityOrderByWithRelationInput[] = [
+  { createdAt: "desc" },
+  { id: "desc" },
+];
+
+/** Begrenzt eine gewuenschte Seitengroesse auf das Erlaubte. */
+export function seitenGroesse(roh: string | null): number {
+  const angefragt = roh === null ? Number.NaN : Number(roh);
+  if (!Number.isFinite(angefragt)) return SEITE;
+  return Math.min(Math.max(Math.trunc(angefragt), 1), SEITE_MAX);
+}

src/lib/validation.ts

@@ -264,6 +264,8 @@ export const adminSettingsSchema = z.object({
   autoSyncIntervalMinutes: z.coerce.number().int().min(5).max(10080).optional(),
   autoSyncActiveOnly: z.boolean().optional(),
   autoSyncBatchSize: z.coerce.number().int().min(1).max(200).optional(),
+  /** Karten je Spalte im Aufgabenbrett; 0 schaltet die Begrenzung ab. */
+  taskColumnLimit: z.coerce.number().int().min(0).max(500).optional(),
 });
 
 export const adminUserCreateSchema = z.object({

src/types/index.ts

@@ -47,7 +47,10 @@ export interface ConnectionWithCount extends ConnectionSafe {
  * repositorySafeSelect. Ob einer eingerichtet ist, reicht die Projektseite
  * getrennt durch.
  */
-export interface RepositoryWithSnapshot extends Omit<Repository, "webhookSecret"> {
+export interface RepositoryWithSnapshot extends Omit<
+  Repository,
+  "webhookSecret"
+> {
   connection: ConnectionSafe | null;
   snapshot: RepoSnapshot | null;
 }
@@ -100,6 +103,24 @@ export interface TaskOverviewItem {
   project: { id: string; name: string; accent: string; status: ProjectStatus };
 }
 
+/** Ein Verlaufseintrag im Wochenrueckblick – mit Projekt, ueber Projekte hinweg. */
+export interface ReviewEntry {
+  id: string;
+  kind: ActivityKind;
+  summary: string;
+  /** ISO – ein Date ueberlebt den Weg zum Browser nicht. */
+  createdAt: string;
+  project: { id: string; name: string; accent: string };
+  user: { username: string; displayName: string | null } | null;
+}
+
+/** Ein Kalendertag der Woche samt seiner Eintraege. */
+export interface ReviewDay {
+  /** "2026-08-17", in Berliner Zeit bestimmt. */
+  tag: string;
+  eintraege: ReviewEntry[];
+}
+
 export interface RepoListEntry {
   fullPath: string;
   owner: string;
@@ -141,7 +162,8 @@ export function asArray<T>(value: unknown): T[] {
 export function asCalendar(value: unknown): CommitCalendar | null {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const kandidat = value as Partial<CommitCalendar>;
-  if (typeof kandidat.from !== "string" || typeof kandidat.to !== "string") return null;
+  if (typeof kandidat.from !== "string" || typeof kandidat.to !== "string")
+    return null;
   if (!kandidat.days || typeof kandidat.days !== "object") return null;
   return {
     from: kandidat.from,
@@ -158,3 +180,14 @@ export function asRecord(value: unknown): Record<string, number> {
   }
   return {};
 }
+
+/**
+ * Wie asRecord, aber fuer Text – etwa `missing` am Snapshot, das je Feld
+ * den Grund des Fehlschlags traegt.
+ */
+export function asTextRecord(value: unknown): Record<string, string> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, string>;
+  }
+  return {};
+}