fix: Warnung beim Einlesen der Versionsnummer beseitigen

Der benannte Import aus der package.json loeste in Webpack die Warnung "Should not import the named export 'version'" aus. Jetzt als Standardimport. Version auf 0.5.0 gehoben. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
feat(export): Aufgaben in Export, Import und Sicherung aufnehmen
2026-07-26 09:29:50 +02:00 · 2026-07-26 09:29:50 +02:00 · 2026-07-26 09:29:28 +02:00 · 2026-07-26 09:29:28 +02:00 · 2026-07-26 01:04:42 +02:00 · 2026-07-26 01:04:42 +02:00
46 changed files with 2935 additions and 128 deletions
@@ -107,10 +107,28 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
 - **Statusfilter** als Chips mit Trefferzähler, mehrere gleichzeitig kombinierbar.
 - **Sortierung** nach zuletzt geändert, Anlagedatum, Name, Fortschritt oder Priorität —
  Favoriten bleiben stets oben.
- **Zwei Ansichten**: freies Raster oder nach Status gruppierte Abschnitte.
+- **Drei Ansichten**: freies Raster, nach Status gruppierte Abschnitte oder **Kanban**.
+- **Volltextsuche über Notizen.** Die Suche im Board arbeitet auf den geladenen Projekten
+  (Name, Kurzbeschreibung, Tags, Repo-Pfad). Notizen liegen dort nicht vor — sie
+  mitzuladen würde die Seite aufblähen. Stattdessen sucht Postgres serverseitig mit
+  seiner deutschen Textsuche, entprellt ab zwei Zeichen. Treffer erscheinen als eigene
+  Liste mit hervorgehobener Fundstelle, die betroffenen Projekte werden zusätzlich
+  eingeblendet. Deutsche Stammformen greifen: „Webhook" findet auch „Webhooks".
 - **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
 - **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.

+### Kanban
+
+Spalten je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und
+erst danach gespeichert; scheitert das Speichern, springt die Karte zurück.
+
+- Gezogen wird am Griff links, nicht an der ganzen Karte — so bleibt der Titel ein
+  normaler Link.
+- Das Ziehen startet erst nach ein paar Pixeln Bewegung, damit Klicks weiter funktionieren.
+  Auf Touchgeräten nach kurzem Halten.
+- Die Reihenfolge innerhalb einer Spalte folgt der gewählten Sortierung. Frei sortieren
+  ginge nur mit einer gespeicherten Position — bewusst nicht gebaut.
+
 ### Projektkarte auf einen Blick

 Name und Favoritenstern · Kurzbeschreibung · Fortschrittsbalken · Provider-Badge ·
@@ -122,6 +140,10 @@ Anzahl Notizen · Warnung bei Sync-Fehler · Tags · Statusauswahl · Priorität
 ## 3. Notizen

 - **Beliebig viele Notizen pro Projekt**, mit optionalem Titel und mehrzeiligem Text.
+- **Markdown wird dargestellt** — Überschriften, Listen, Tabellen, Codeblöcke, Zitate und
+  Links. Aus `- [ ] Aufgabe` werden echte Checklisten. Gilt auch für die Projekt-
+  beschreibung. Rohes HTML wird beim Rendern entfernt (`rehype-sanitize`) — der Inhalt
+  stammt vom Benutzer und wäre sonst ein XSS-Loch.
 - **Anpinnen** — angepinnte Notizen stehen oben und sind farblich hervorgehoben.
 - **Bearbeiten und Löschen** direkt in der Liste; Löschen fragt nach.
 - **Zeitstempel**: Anlagedatum immer, „bearbeitet vor …" nur bei echter Änderung.
@@ -164,12 +186,28 @@ Firmen-Gitea nebeneinander.
 | --- | --- |
 | Repository | Voller Pfad, Beschreibung, Default-Branch, Sichtbarkeit, Größe, letzte Aktivität |
 | Kennzahlen | Stars, Forks, offene Issues, offene Pull-/Merge-Requests |
+| **Pull-/Merge-Requests** | bis zu 50 offene, mit Nummer, Titel, Autor, Alter, Labels, Entwurfskennzeichnung und Link |
+| **Issues** | bis zu 50 offene, gleiche Angaben. Bei GitHub und Gitea werden PRs herausgefiltert, die dort in derselben Liste stecken |
+| **CI-Status** | Letzter Lauf auf dem Default-Branch: erfolgreich, fehlgeschlagen, läuft, wartet oder abgebrochen — mit Name und Link |
 | Branches | bis zu 50, mit SHA, Default-Markierung, Schutzstatus und (wo die API es liefert) letztem Commit |
 | Tags | bis zu 25, mit SHA, Nachricht und Datum |
-| Commits | die letzten 15, mit Kurz-SHA, Nachricht, Autor, Datum und Link |
+| Commits | die letzten 15 zur Anzeige; geholt werden 100 für die Aktivitätskurve |
+| **Commit-Aktivität** | Balkenreihe der letzten Tage, auf Karte und Projektseite |
 | Releases | bis zu 10, inklusive Pre-Release- und Draft-Kennzeichnung |
 | Sprachen | Verteilung als Balken mit Prozentwerten |

+Woher der CI-Status kommt:
+
+| System | Quelle |
+| --- | --- |
+| GitHub | `actions/runs` für den Default-Branch; Lauf-Status und Ergebnis werden zusammengeführt |
+| GitLab | `pipelines` für den Default-Branch |
+| Gitea | Kombinierter Commit-Status — deckt Gitea Actions **und** externe Systeme wie Woodpecker ab, anders als ein reiner Actions-Endpunkt, den ältere Instanzen nicht kennen |
+
+Zur Ehrlichkeit der Aktivitätskurve: geholt wird eine Seite mit 100 Commits. Reicht die
+nicht über den ganzen Zeitraum, wird die Kurve auf den tatsächlich belegten Ausschnitt
+gekürzt — eine Null zu zeichnen, wo wir schlicht nichts wissen, wäre falsch.
+
 - **Snapshot-Prinzip**: Alle Daten werden in der Datenbank abgelegt. Das Dashboard bleibt
  ohne Netzverbindung oder bei erreichtem Rate-Limit vollständig nutzbar.

@@ -328,7 +366,22 @@ nicht verloren gehen. Indizes auf Status, Verbindung und Änderungsdatum.
 - **Setup-Skript** erzeugt die `.env` samt zufälligem `APP_SECRET`.
 - **Seed-Daten** auf Wunsch, idempotent — mehrfaches Ausführen legt nichts doppelt an.

-### 6.4 API
+### 6.4 Tests
+
+`npm test` führt die Unit-Tests aus — reine Logik, kein DOM, keine Datenbank, unter einer
+Sekunde:
+
+| Bereich | Was geprüft wird |
+| --- | --- |
+| `utils` | Slug-Erzeugung inklusive Umlauten und Längenbegrenzung, Tag-Aufbereitung, Kürzen, Zahlenformat |
+| `git/parse` | URL-Zerlegung für https, SSH, verschachtelte GitLab-Gruppen und Oberflächenpfade; Provider-Erkennung; Bildung der Aktivitätskurve |
+| `security/ssrf` | Sperrlisten für Loopback, Link-Local, Metadaten-Endpunkt, CGNAT und Multicast; Formprüfung; die drei Umgebungsschalter |
+| `auth/password` | scrypt-Rundlauf, unterschiedliches Salz, Ablageformat, Verhalten bei kaputten Hashes, Passwortregeln |
+
+Bewusst ohne Datenbank- und Browsertests: die brauchen Infrastruktur und gehören in eine
+CI-Pipeline. Das steht in der [ROADMAP](ROADMAP.md).
+
+### 6.5 API

 Zehn REST-Endpunkte für Projekte, Notizen, Verbindungen, Sync, Repo-Listen und Health.
 Alles, was die Oberfläche kann, ist damit auch scriptbar. Übersicht in der
@@ -298,6 +298,8 @@ nebula/
 | `npm run db:seed` | Beispielprojekte anlegen |
 | `npm run db:studio` | Prisma Studio öffnen |
 | `npm run db:reset` | Datenbank zurücksetzen (**löscht alles**) |
+| `npm test` | Unit-Tests (Vitest), unter einer Sekunde |
+| `npm run test:watch` | Tests im Beobachtungsmodus |
 | `npm run typecheck` | TypeScript prüfen |
 | `npm run docker:db` | Nur die Datenbank starten |
 | `npm run docker:up` / `docker:down` | Kompletten Stack starten / stoppen |
@@ -332,6 +334,7 @@ ausschließlich Daten des angemeldeten Kontos.
 | `GET` | `/api/projects/:id/export` | Ein Projekt (`?format=md` für Markdown) |
 | `POST` | `/api/projects/import` | Import, mit `dryRun` für die Vorschau |
 | `GET` | `/api/admin/backup` | Vollständige Sicherung als JSON (Admin) |
+| `GET` | `/api/search?q=` | Volltextsuche über die eigenen Notizen |
 | `GET` `PATCH` `DELETE` | `/api/projects/:id` | Projekt lesen / ändern / löschen |
 | `POST` | `/api/projects/:id/sync` | Repo-Daten vom Git-System holen |
 | `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
@@ -11,101 +11,74 @@ Was bereits steht, listet [FEATURES.md](FEATURES.md).

 ## 1 · Als Nächstes empfohlen

-### 1.1 Markdown in Beschreibung und Notizen `S`
+### 1.1 Tests ausbauen: Datenbank und Browser `L`

-Heute wird alles als reiner Text dargestellt. Mit Markdown werden aus
-`- [ ] Aufgabe` echte Checklisten, Codeblöcke bekommen Hervorhebung, Links
-werden klickbar.
+Das Fundament steht — 51 Unit-Tests der reinen Logik laufen in unter einer
+Sekunde. Was fehlt, ist die Schicht darüber:

-Zu beachten: HTML muss beim Rendern entfernt werden, sonst reißt es ein
-XSS-Loch. Mit `react-markdown` plus `rehype-sanitize` ist das sauber lösbar.
+- **Integrationstests** gegen eine Wegwerf-Datenbank: Datentrennung zwischen
+  Konten, Import-Strategien, Backoff des Abgleichs
+- **Playwright** für die Wege durch die App: Einrichtung, Anmeldung, Kanban
+- **CI-Pipeline** bei GitHub oder Gitea Actions

-### 1.2 Volltextsuche über Notizen `S`
+Ich prüfe bislang alles von Hand, inklusive Screenshots. Das trägt nicht
+dauerhaft und macht jede weitere Änderung teurer als nötig.

-Die Suche im Board deckt Namen, Kurzbeschreibung und Tags ab — Notizen nicht.
-Postgres kann das nativ (`tsvector` mit deutscher Konfiguration), also ohne
-zusätzlichen Dienst.
+### 1.2 Benachrichtigungen `M`

-### 1.3 Kanban-Board mit Drag & Drop `M`
+Bei Sync-Fehlern, roter CI, neuen Releases oder Projekten, die lange
+stillstehen. Kanäle: E-Mail (SMTP), ntfy, generischer Webhook. Zusammen mit
+dem automatischen Abgleich und dem CI-Status ergibt das ein brauchbares
+Frühwarnsystem — die Daten liegen bereits vor.

-Die gruppierte Ansicht gibt es schon, aber Statuswechsel geht nur über das
-Menü. Spalten mit Ziehen und Ablegen wären der natürlichere Weg.
+### 1.3 Aufgaben und Checklisten `M`

-Bibliothek: `@dnd-kit` — leichtgewichtig, tastaturbedienbar. Auf Mobilgeräten
-bleibt die Listenansicht.
+Eigene Entität statt Freitext, mit Häkchen und automatisch berechnetem
+Fortschritt. Ersetzt das manuelle Schieben des Reglers. Die Markdown-
+Checklisten in Notizen sind ein Vorgeschmack, aber nicht auswertbar.

 ---

 ## 2 · Danach

-### 2.1 Offene Pull Requests und Issues als Liste `S`
-
-Aktuell werden sie nur gezählt. Titel, Autor, Alter und Link wären deutlich
-nützlicher — die Daten holen wir ohnehin schon ab.
-
-### 2.2 CI-Status je Branch `M`
-
-Grün oder rot direkt an der Projektkarte, gespeist aus GitHub Actions,
-GitLab Pipelines und Gitea Actions. Erfordert je Provider einen weiteren
-Endpunkt und einen zusätzlichen Token-Scope.
-
-### 2.3 Webhooks statt Polling `M`
+### 2.1 Webhooks statt Polling `M`

 Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
 zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
 Signaturprüfung je Provider — sinnvoll erst, wenn die Instanz von außen
 erreichbar ist. Der Zeitplan bleibt als Rückfalllösung.

-### 2.4 Commit-Aktivität als Verlauf `S`
+### 2.2 Commit-Aktivität als Heatmap `S`

-Kleine Sparkline auf der Karte, Heatmap auf der Projektseite. Datenbasis ist
-da, es fehlt nur die Darstellung.
+Die Sparkline gibt es auf Karte und Projektseite. Eine Heatmap über ein Jahr
+wäre die nächste Ausbaustufe — dafür braucht es allerdings mehr als eine
+Seite Commits, also Paginierung oder die Statistik-Endpunkte.

-### 2.5 Aufgaben und Checklisten `M`
+### 2.3 Kanban mit freier Reihenfolge `M`

-Eigene Entität statt Freitext-Notiz, mit Häkchen und automatisch
-berechnetem Fortschritt. Ersetzt das manuelle Schieben des Reglers.
-
-### 2.6 Benachrichtigungen `M`
-
-Bei Sync-Fehlern, neuen Releases oder Projekten, die lange stillstehen.
-Kanäle: E-Mail (SMTP), ntfy, generischer Webhook. Zusammen mit dem
-automatischen Abgleich ergibt das ein brauchbares Frühwarnsystem.
+Heute folgt die Reihenfolge innerhalb einer Spalte der gewählten Sortierung.
+Frei sortieren hieße, eine Position je Projekt zu speichern.

 ---

 ## 3 · Größere Brocken

-### 3.1 Automatisierte Tests und CI `L`
-
-Aktuell prüfe ich jede Änderung von Hand — Typecheck, Build, API-Durchläufe,
-Browser-Screenshots. Das gehört in eine Pipeline:
-
- **Vitest** für die Logik: URL-Parsing, SSRF-Regeln, Passwort-Hashing,
-  Backoff-Berechnung
- **Playwright** für die Wege durch die App: Einrichtung, Anmeldung,
-  Datentrennung
- **GitHub Actions** oder Gitea Actions, je nachdem wohin du das Repo legst
-
-Aus meiner Sicht der wertvollste Punkt der ganzen Liste, sobald das Projekt
-länger lebt: er macht alles Weitere billiger und sicherer.
-
-### 3.2 Mehrere Repositories je Projekt `M`
+### 3.1 Mehrere Repositories je Projekt `M`

 Frontend und Backend getrennt, aber ein Projekt. Erfordert eine Zwischentabelle
 und Anpassungen in der Anzeige.

-### 3.3 Zwei-Faktor per TOTP `M`
+### 3.2 Zwei-Faktor per TOTP `M`

 Als Alternative zum Passkey — nützlich, wenn die Instanz aus dem Internet
 erreichbar ist und nicht jedes Gerät Passkeys kann.

-### 3.4 Passwort-Zurücksetzen per E-Mail `M`
+### 3.3 Passwort-Zurücksetzen per E-Mail `M`

 Heute setzt ein Administrator das Passwort neu. Selbstbedienung braucht SMTP
 und damit eine weitere Konfiguration — lohnt erst im Mehrbenutzerbetrieb.

-### 3.5 Mehrsprachigkeit `L`
+### 3.4 Mehrsprachigkeit `L`

 Die Oberfläche ist durchgängig deutsch verdrahtet. Englisch dazu wäre eine
 Voraussetzung, falls du das Projekt veröffentlichen willst.
@@ -117,6 +90,7 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 | Idee | Aufwand | Nutzen |
 | --- | --- | --- |
 | Schnellsuche per `Strg+K` | `S` | Springt direkt zu Projekt oder Aktion |
+| Suchtreffer in Notizen hervorheben | `S` | In der Notiz selbst, nicht nur in der Trefferliste |
 | Mehrfachauswahl im Board | `S` | Status oder Tags für mehrere auf einmal |
 | Aktivitätsverlauf je Projekt | `S` | Wer hat wann was geändert |
 | Projektvorlagen | `S` | Neues Projekt mit vorgefüllten Tags und Notizen |
@@ -124,7 +98,7 @@ Voraussetzung, falls du das Projekt veröffentlichen willst.
 | Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
 | PWA-Manifest | `S` | Auf dem Handy als App installierbar |
 | Barrierefreiheits-Durchsicht | `M` | Fokusreihenfolge, Screenreader, Kontraste |
-| `prisma.config.ts` | `S` | Beseitigt die Deprecation-Warnung vor Prisma 7 |
+| `prisma.config.ts` | `S` | Beseitigt die Deprecation-Warnung vor Prisma 7. Achtung: danach lädt Prisma die `.env` nicht mehr von selbst |
 | Audit-Log für Adminaktionen | `M` | Nachvollziehbar, wer Konten geändert hat |

 ---
@@ -156,6 +130,8 @@ Damit klar ist, was **nicht** kommt und warum:
 | Docker- und Standalone-Betrieb | ✓ |
 | Automatischer Abgleich mit Zeitplan | ✓ |
 | Export, Import und Sicherung | ✓ |
+| **v0.3.0** Markdown, Volltextsuche über Notizen, PR- und Issue-Listen, Testfundament | ✓ |
+| **v0.4.0** Kanban mit Drag & Drop, CI-Status je Branch, Commit-Aktivität | ✓ |

 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
@@ -1,6 +1,6 @@
 {
  "name": "nebula",
-  "version": "0.4.0",
+  "version": "0.5.0",
  "private": true,
  "description": "Nebula – Dashboard fuer Vibe-Coding Projekte mit Git-Anbindung (GitHub, GitLab, Gitea)",
  "scripts": {
@@ -0,0 +1,16 @@
+-- Volltextsuche ueber Notizen.
+--
+-- Dies ist ein Ausdrucksindex. Prisma kann so etwas im Schema nicht abbilden
+-- und kennt ihn deshalb nicht. Nachgeprueft: "prisma migrate diff" laesst ihn
+-- in Ruhe und schlaegt kein DROP vor - Ausdrucksindizes werden schlicht
+-- ignoriert. Trotzdem beim Erzeugen kuenftiger Migrationen kurz hinsehen.
+--
+-- Faellt er doch einmal weg, funktioniert die Suche weiter, nur langsamer:
+-- Postgres berechnet to_tsvector dann je Zeile.
+--
+-- Der Ausdruck muss mit dem in src/app/api/search/route.ts uebereinstimmen,
+-- sonst greift der Index nicht. Die zweistellige Form von to_tsvector mit
+-- fester Konfiguration ist IMMUTABLE und damit indizierbar.
+
+CREATE INDEX "Note_fulltext_idx" ON "Note"
+  USING GIN (to_tsvector('german', coalesce("title", '') || ' ' || "content"));
@@ -0,0 +1,9 @@
+-- AlterTable
+ALTER TABLE "RepoSnapshot" ADD COLUMN     "ciBranch" TEXT,
+ADD COLUMN     "ciFinishedAt" TIMESTAMP(3),
+ADD COLUMN     "ciName" TEXT,
+ADD COLUMN     "ciState" TEXT,
+ADD COLUMN     "ciUrl" TEXT,
+ADD COLUMN     "commitActivity" JSONB NOT NULL DEFAULT '[]',
+ADD COLUMN     "issues" JSONB NOT NULL DEFAULT '[]',
+ADD COLUMN     "pullRequests" JSONB NOT NULL DEFAULT '[]';
@@ -0,0 +1,28 @@
+-- CreateEnum
+CREATE TYPE "TaskStatus" AS ENUM ('TODO', 'DOING', 'BLOCKED', 'DONE');
+
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN     "progressFromTasks" BOOLEAN NOT NULL DEFAULT false;
+
+-- CreateTable
+CREATE TABLE "Task" (
+    "id" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "description" TEXT,
+    "status" "TaskStatus" NOT NULL DEFAULT 'TODO',
+    "position" INTEGER NOT NULL DEFAULT 0,
+    "dueDate" TIMESTAMP(3),
+    "labels" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "doneAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "Task_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "Task_projectId_status_position_idx" ON "Task"("projectId", "status", "position");
+
+-- AddForeignKey
+ALTER TABLE "Task" ADD CONSTRAINT "Task_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
@@ -33,6 +33,14 @@ enum GitProvider {
  GITEA
 }

+/// Spalten des Aufgabenbretts innerhalb eines Projekts.
+enum TaskStatus {
+  TODO
+  DOING
+  BLOCKED
+  DONE
+}
+
 /// ADMIN darf Benutzer und Einstellungen verwalten. Auf fremde Projekte hat
 /// auch ein Admin keinen Zugriff – die Trennung ist bewusst hart.
 enum UserRole {
@@ -237,7 +245,12 @@ model Project {
  ownerId String?
  owner   User?   @relation(fields: [ownerId], references: [id], onDelete: Cascade)

+  /// Fortschritt aus dem Verhaeltnis erledigter Aufgaben berechnen statt
+  /// von Hand zu schieben. Nur sinnvoll, wenn es ueberhaupt Aufgaben gibt.
+  progressFromTasks Boolean @default(false)
+
  notes    Note[]
+  tasks    Task[]
  snapshot RepoSnapshot?

  createdAt DateTime @default(now())
@@ -250,6 +263,30 @@ model Project {
  @@index([ownerId])
 }

+/// Eine Aufgabe innerhalb eines Projekts – die Karten des Aufgabenbretts.
+model Task {
+  id          String     @id @default(cuid())
+  projectId   String
+  project     Project    @relation(fields: [projectId], references: [id], onDelete: Cascade)
+  title       String
+  /// Optionale Notiz zur Aufgabe, Markdown wird dargestellt.
+  description String?
+  status      TaskStatus @default(TODO)
+  /// Rang innerhalb der Spalte. Anders als beim Projektbrett braucht es ihn
+  /// hier wirklich: Aufgaben haben eine Reihenfolge, die der Benutzer setzt.
+  /// Beim Umsortieren werden die Positionen einer Spalte neu durchnummeriert.
+  position    Int        @default(0)
+  dueDate     DateTime?
+  labels      String[]   @default([])
+  /// Zeitpunkt, zu dem die Aufgabe nach DONE gewandert ist.
+  doneAt      DateTime?
+
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@index([projectId, status, position])
+}
+
 /// Freie Notizen zu einem Projekt.
 model Note {
  id        String   @id @default(cuid())
@@ -303,6 +340,18 @@ model RepoSnapshot {
  commits       Json @default("[]")
  releases      Json @default("[]")
  languages     Json @default("{}")
+  pullRequests  Json @default("[]")
+  issues        Json @default("[]")
+  /// Commits je Tag der letzten 30 Tage, aeltester zuerst.
+  commitActivity Json @default("[]")
+
+  // ── Letzter CI-Lauf auf dem Default-Branch ─────────────────
+  /// success | failure | running | pending | cancelled
+  ciState      String?
+  ciName       String?
+  ciBranch     String?
+  ciUrl        String?
+  ciFinishedAt DateTime?

  pushedAt  DateTime?
  fetchedAt DateTime @default(now())
@@ -56,6 +56,7 @@ export async function GET() {
    prisma.project.findMany({
      include: {
        notes: { orderBy: { createdAt: "asc" } },
+        tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
        // Snapshots bleiben draussen: reproduzierbar und gross.
      },
      orderBy: { name: "asc" },
@@ -25,6 +25,7 @@ export async function GET(request: Request, { params }: Params) {
    where: { id, ownerId: auth.user.id },
    include: {
      notes: { orderBy: [{ pinned: "desc" }, { createdAt: "asc" }] },
+      tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
      connection: { select: { name: true, provider: true, baseUrl: true } },
      snapshot: true,
    },
@@ -0,0 +1,93 @@
+import { NextResponse } from "next/server";
+import type { Prisma, TaskStatus } from "@prisma/client";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { ownedProject, refreshDerivedProgress } from "@/lib/tasks";
+import { formatZodError, taskReorderSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/**
+ * Neue Reihenfolge nach dem Ziehen.
+ *
+ * Uebergeben wird je betroffener Spalte die vollstaendige Liste der Aufgaben
+ * in ihrer neuen Reihenfolge. Daraus ergeben sich Status und Position
+ * eindeutig – der Aufruf ist damit wiederholbar, ohne Schaden anzurichten,
+ * und ein verlorener Aufruf laesst sich einfach erneut senden.
+ */
+export async function PATCH(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = taskReorderSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const columns = parsed.data.columns as Partial<Record<TaskStatus, string[]>>;
+  const requestedIds = Object.values(columns).flat();
+
+  // Nur Aufgaben anfassen, die wirklich zu diesem Projekt gehoeren – sonst
+  // liessen sich fremde Aufgaben ueber untergeschobene IDs verschieben.
+  const owned = await prisma.task.findMany({
+    where: { projectId: id, id: { in: requestedIds } },
+    select: { id: true, status: true },
+  });
+  const ownedIds = new Set(owned.map((task) => task.id));
+  const previousStatus = new Map(owned.map((task) => [task.id, task.status]));
+
+  const now = new Date();
+  const updates: Prisma.PrismaPromise<unknown>[] = [];
+
+  for (const [status, ids] of Object.entries(columns) as Array<[TaskStatus, string[]]>) {
+    ids.forEach((taskId, index) => {
+      if (!ownedIds.has(taskId)) return;
+      const before = previousStatus.get(taskId);
+      updates.push(
+        prisma.task.update({
+          where: { id: taskId },
+          data: {
+            status,
+            position: index,
+            // doneAt nur beim tatsaechlichen Wechsel setzen oder loeschen,
+            // damit ein Umsortieren innerhalb von "Erledigt" das Datum nicht
+            // immer wieder erneuert.
+            ...(before !== status
+              ? { doneAt: status === "DONE" ? now : null }
+              : {}),
+          },
+        }),
+      );
+    });
+  }
+
+  if (updates.length > 0) {
+    await prisma.$transaction(updates);
+    await refreshDerivedProgress(id);
+  }
+
+  const tasks = await prisma.task.findMany({
+    where: { projectId: id },
+    orderBy: [{ status: "asc" }, { position: "asc" }],
+  });
+
+  return NextResponse.json({
+    tasks,
+    updated: updates.length,
+    ignored: requestedIds.length - updates.length,
+  });
+}
@@ -0,0 +1,69 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { nextPosition, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
+import { formatZodError, taskCreateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function GET(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const tasks = await prisma.task.findMany({
+    where: { projectId: id },
+    orderBy: [{ status: "asc" }, { position: "asc" }],
+  });
+  return NextResponse.json({ tasks });
+}
+
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = taskCreateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const { title, description, status, dueDate, labels } = parsed.data;
+
+  const task = await prisma.task.create({
+    data: {
+      projectId: id,
+      title,
+      description: description ?? null,
+      status,
+      // Neue Aufgaben landen unten in ihrer Spalte.
+      position: await nextPosition(id, status),
+      dueDate: dueDate ? new Date(dueDate) : null,
+      labels,
+      doneAt: status === "DONE" ? new Date() : null,
+    },
+  });
+
+  await refreshDerivedProgress(id);
+  // Damit die Sortierung nach Aktivitaet stimmt.
+  await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
+
+  return NextResponse.json({ task }, { status: 201 });
+}
@@ -159,8 +159,25 @@ export async function POST(request: Request) {
      repoOwner: incoming.repoOwner ?? null,
      repoName: incoming.repoName ?? null,
      connectionId: connection?.id ?? null,
+      progressFromTasks: incoming.progressFromTasks,
    };

+    const tasks = incoming.tasks.map((task, index) => ({
+      title: task.title,
+      description: task.description ?? null,
+      status: task.status,
+      // Position aus der Datei uebernehmen, notfalls die Reihenfolge in ihr.
+      position: task.position ?? index,
+      dueDate: task.dueDate && !Number.isNaN(Date.parse(task.dueDate))
+        ? new Date(task.dueDate)
+        : null,
+      labels: task.labels,
+      doneAt: task.status === "DONE" ? new Date() : null,
+      ...(task.createdAt && !Number.isNaN(Date.parse(task.createdAt))
+        ? { createdAt: new Date(task.createdAt) }
+        : {}),
+    }));
+
    const notes = incoming.notes.map((note) => ({
      title: note.title ?? null,
      content: note.content,
@@ -176,9 +193,10 @@ export async function POST(request: Request) {
        // erneuter Import erzeugt keine Dubletten.
        await prisma.$transaction([
          prisma.note.deleteMany({ where: { projectId: existing.id } }),
+          prisma.task.deleteMany({ where: { projectId: existing.id } }),
          prisma.project.update({
            where: { id: existing.id },
-            data: { ...data, slug, notes: { create: notes } },
+            data: { ...data, slug, notes: { create: notes }, tasks: { create: tasks } },
          }),
        ]);
        results.push({ ...base, action: "overwrite" });
@@ -190,6 +208,7 @@ export async function POST(request: Request) {
            ownerId: auth.user.id,
            slug: finalSlug,
            notes: { create: notes },
+            tasks: { create: tasks },
          },
        });
        results.push({
@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+
+export const dynamic = "force-dynamic";
+
+interface Hit {
+  projectId: string;
+  noteId: string;
+  title: string | null;
+  /** Textausschnitt mit hervorgehobener Fundstelle. */
+  snippet: string;
+}
+
+/**
+ * Volltextsuche ueber Notizen.
+ *
+ * Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt
+ * Name, Kurzbeschreibung und Tags ab. Notizen liegen dort nicht vor – die
+ * mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb dieser Endpunkt:
+ * Postgres sucht mit seiner deutschen Textsuche direkt in der Datenbank.
+ *
+ * ts_headline liefert gleich den passenden Ausschnitt mit; die Hervorhebung
+ * kommt als [[…]] zurueck, damit die Oberflaeche kein HTML einbetten muss.
+ */
+export async function GET(request: Request) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const query = (new URL(request.url).searchParams.get("q") ?? "").trim();
+  if (query.length < 2) {
+    return NextResponse.json({ query, hits: [], projectIds: [] });
+  }
+
+  // websearch_to_tsquery versteht Eingaben wie "docker -compose" oder
+  // Anfuehrungszeichen und wirft bei Unsinn keinen Fehler.
+  const hits = await prisma.$queryRaw<Hit[]>`
+    SELECT
+      n."projectId" AS "projectId",
+      n."id"        AS "noteId",
+      n."title"     AS "title",
+      ts_headline(
+        'german',
+        n."content",
+        websearch_to_tsquery('german', ${query}),
+        'StartSel=[[, StopSel=]], MaxWords=18, MinWords=6, ShortWord=2, MaxFragments=1'
+      ) AS "snippet"
+    FROM "Note" n
+    JOIN "Project" p ON p."id" = n."projectId"
+    WHERE p."ownerId" = ${auth.user.id}
+      AND to_tsvector('german', coalesce(n."title", '') || ' ' || n."content")
+          @@ websearch_to_tsquery('german', ${query})
+    ORDER BY ts_rank(
+      to_tsvector('german', coalesce(n."title", '') || ' ' || n."content"),
+      websearch_to_tsquery('german', ${query})
+    ) DESC
+    LIMIT 50
+  `;
+
+  return NextResponse.json({
+    query,
+    hits,
+    // Die Oberflaeche braucht vor allem die betroffenen Projekte, um sie im
+    // Board einzublenden.
+    projectIds: Array.from(new Set(hits.map((hit) => hit.projectId))),
+  });
+}
@@ -0,0 +1,75 @@
+import { NextResponse } from "next/server";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { nextPosition, refreshDerivedProgress } from "@/lib/tasks";
+import { formatZodError, taskUpdateSchema } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+/** Eine Aufgabe gehoert dem, dem das zugehoerige Projekt gehoert. */
+async function ownedTask(taskId: string, ownerId: string) {
+  return prisma.task.findFirst({
+    where: { id: taskId, project: { ownerId } },
+    select: { id: true, projectId: true, status: true },
+  });
+}
+
+export async function PATCH(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const existing = await ownedTask(id, auth.user.id);
+  if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = taskUpdateSchema.safeParse(body.data);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const data = parsed.data;
+  const update: Record<string, unknown> = {};
+
+  if (data.title !== undefined) update.title = data.title;
+  if (data.description !== undefined) update.description = data.description;
+  if (data.labels !== undefined) update.labels = data.labels;
+  if (data.dueDate !== undefined) {
+    update.dueDate = data.dueDate ? new Date(data.dueDate) : null;
+  }
+
+  if (data.status !== undefined && data.status !== existing.status) {
+    update.status = data.status;
+    // Beim Spaltenwechsel ans Ende der neuen Spalte.
+    update.position = await nextPosition(existing.projectId, data.status);
+    // doneAt nur setzen, wenn die Aufgabe wirklich nach DONE wandert.
+    update.doneAt = data.status === "DONE" ? new Date() : null;
+  }
+
+  const task = await prisma.task.update({ where: { id }, data: update });
+  await refreshDerivedProgress(existing.projectId);
+
+  return NextResponse.json({ task });
+}
+
+export async function DELETE(_request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  const existing = await ownedTask(id, auth.user.id);
+  if (!existing) return jsonError("Aufgabe nicht gefunden", 404);
+
+  await prisma.task.delete({ where: { id } });
+  await refreshDerivedProgress(existing.projectId);
+
+  return NextResponse.json({ ok: true });
+}
@@ -1,7 +1,7 @@
 import type { Metadata, Viewport } from "next";
 import { TopNav } from "@/components/TopNav";
 import { getSessionUser } from "@/lib/auth/session";
-import { APP_NAME, APP_TAGLINE } from "@/lib/config";
+import { APP_NAME, APP_TAGLINE, APP_VERSION } from "@/lib/config";
 import "./globals.css";

 /**
@@ -52,7 +52,7 @@ export default async function RootLayout({
        <footer className="mx-auto w-full max-w-[1400px] px-4 pb-10 text-xs text-slate-500 sm:px-6 lg:px-8">
          <div className="flex flex-wrap items-center justify-between gap-2 border-t border-white/5 pt-6">
            <span>{APP_NAME} · lokal betrieben, Daten bleiben in deiner PostgreSQL.</span>
-            <span className="font-mono text-slate-600">v0.2.0</span>
+            <span className="font-mono text-slate-600">v{APP_VERSION}</span>
          </div>
        </footer>
      </body>
@@ -5,6 +5,7 @@ import { GitPanel } from "@/components/GitPanel";
 import { Markdown } from "@/components/Markdown";
 import { NotesPanel } from "@/components/NotesPanel";
 import { ProjectHeader } from "@/components/ProjectHeader";
+import { TaskBoard } from "@/components/tasks/TaskBoard";
 import { requireUserPage } from "@/lib/auth/guard";
 import { getSessionUser } from "@/lib/auth/session";
 import { prisma } from "@/lib/db";
@@ -59,6 +60,12 @@ export default async function ProjectPage({ params }: PageProps) {
        connections={connections as unknown as ConnectionSafe[]}
      />

+      <TaskBoard
+        projectId={detail.id}
+        tasks={detail.tasks}
+        progressFromTasks={detail.progressFromTasks}
+      />
+
      <div className="grid gap-6 lg:grid-cols-12">
        <div className="space-y-6 lg:col-span-5">
          <section className="glass p-5">
@@ -0,0 +1,90 @@
+import { CircleCheck, CircleDashed, CircleSlash, CircleX, LoaderCircle } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+export type CiState = "success" | "failure" | "running" | "pending" | "cancelled";
+
+const META: Record<
+  CiState,
+  { label: string; short: string; className: string; icon: typeof CircleCheck; spin?: boolean }
+> = {
+  success: {
+    label: "CI erfolgreich",
+    short: "CI ok",
+    className: "bg-emerald-500/12 text-emerald-200 ring-emerald-400/30",
+    icon: CircleCheck,
+  },
+  failure: {
+    label: "CI fehlgeschlagen",
+    short: "CI rot",
+    className: "bg-rose-500/12 text-rose-200 ring-rose-400/30",
+    icon: CircleX,
+  },
+  running: {
+    label: "CI laeuft",
+    short: "CI laeuft",
+    className: "bg-amber-500/12 text-amber-200 ring-amber-400/30",
+    icon: LoaderCircle,
+    spin: true,
+  },
+  pending: {
+    label: "CI wartet",
+    short: "CI wartet",
+    className: "bg-slate-500/12 text-slate-300 ring-slate-400/25",
+    icon: CircleDashed,
+  },
+  cancelled: {
+    label: "CI abgebrochen",
+    short: "CI abgebrochen",
+    className: "bg-slate-500/12 text-slate-400 ring-slate-400/20",
+    icon: CircleSlash,
+  },
+};
+
+export function CiBadge({
+  state,
+  name,
+  url,
+  compact = false,
+}: {
+  state: string | null | undefined;
+  name?: string | null;
+  url?: string | null;
+  compact?: boolean;
+}) {
+  if (!state || !(state in META)) return null;
+  const meta = META[state as CiState];
+  const Icon = meta.icon;
+
+  const content = (
+    <>
+      <Icon className={cn("h-3 w-3 shrink-0", meta.spin && "animate-spin")} />
+      {compact ? meta.short : (name ?? meta.label)}
+    </>
+  );
+
+  const className = cn(
+    "inline-flex items-center gap-1.5 rounded-full ring-1 ring-inset",
+    meta.className,
+    compact ? "px-2 py-0.5 text-[10px]" : "px-2.5 py-1 text-[11px]",
+  );
+
+  if (url && !compact) {
+    return (
+      <a
+        href={url}
+        target="_blank"
+        rel="noreferrer noopener"
+        className={cn(className, "transition-all hover:brightness-125")}
+        title={meta.label}
+      >
+        {content}
+      </a>
+    );
+  }
+
+  return (
+    <span className={className} title={name ? `${meta.label} · ${name}` : meta.label}>
+      {content}
+    </span>
+  );
+}
@@ -3,7 +3,9 @@
 import { useState } from "react";
 import { useRouter } from "next/navigation";
 import {
+  Activity,
  AlertTriangle,
+  CircleDot,
  ExternalLink,
  GitBranch,
  GitCommitHorizontal,
@@ -18,6 +20,8 @@ import {
  Star,
  Tag,
 } from "lucide-react";
+import { CiBadge } from "@/components/CiBadge";
+import { Sparkline } from "@/components/Sparkline";
 import { asArray, asRecord } from "@/types";
 import type {
  BranchInfo,
@@ -25,10 +29,13 @@ import type {
  ProjectDetail,
  ReleaseInfo,
  TagInfo,
+  TicketInfo,
 } from "@/types";
 import { cn, formatDateTime, formatNumber, formatRelative } from "@/lib/utils";

 const TABS = [
+  { key: "pulls", label: "PRs", icon: GitPullRequest },
+  { key: "issues", label: "Issues", icon: CircleDot },
  { key: "branches", label: "Branches", icon: GitBranch },
  { key: "tags", label: "Tags", icon: Tag },
  { key: "commits", label: "Commits", icon: GitCommitHorizontal },
@@ -39,7 +46,7 @@ type TabKey = (typeof TABS)[number]["key"];

 export function GitPanel({ project }: { project: ProjectDetail }) {
  const router = useRouter();
-  const [tab, setTab] = useState<TabKey>("branches");
+  const [tab, setTab] = useState<TabKey>("pulls");
  const [syncing, setSyncing] = useState(false);
  const [message, setMessage] = useState<{ ok: boolean; text: string } | null>(null);

@@ -49,6 +56,9 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
  const commits = asArray<CommitInfo>(snapshot?.commits);
  const releases = asArray<ReleaseInfo>(snapshot?.releases);
  const languages = asRecord(snapshot?.languages);
+  const pulls = asArray<TicketInfo>(snapshot?.pullRequests);
+  const issues = asArray<TicketInfo>(snapshot?.issues);
+  const activity = asArray<number>(snapshot?.commitActivity);

  const hasRepo = Boolean(project.repoOwner && project.repoName) || Boolean(project.repoUrl);

@@ -118,6 +128,7 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
                <ExternalLink className="h-3.5 w-3.5" />
              </a>
            ) : null}
+            <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} url={snapshot?.ciUrl} />
          </div>
          <p className="mt-1 text-xs text-slate-500" suppressHydrationWarning>
            {project.lastSyncedAt
@@ -224,6 +235,24 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
            </div>
          </div>

+          {/* Commit-Aktivitaet */}
+          {activity.some((value) => value > 0) ? (
+            <div className="glass p-4">
+              <div className="mb-2.5 flex items-center justify-between">
+                <p className="flex items-center gap-1.5 text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">
+                  <Activity className="h-3 w-3" />
+                  {/* Der Zeitraum richtet sich danach, wie weit die geholten
+                      Commits zurueckreichen – hoechstens 30 Tage. */}
+                  Commits der letzten {activity.length} Tage
+                </p>
+                <span className="text-xs tabular-nums text-slate-400">
+                  {activity.reduce((sum, value) => sum + value, 0)}
+                </span>
+              </div>
+              <Sparkline values={activity} height={40} />
+            </div>
+          ) : null}
+
          {/* Sprachen */}
          {languageTotal > 0 ? (
            <div className="glass p-4">
@@ -263,14 +292,14 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
          <div className="glass overflow-hidden">
            <div className="flex flex-wrap gap-1 border-b border-white/6 p-2">
              {TABS.map(({ key, label, icon: Icon }) => {
-                const count =
-                  key === "branches"
-                    ? branches.length
-                    : key === "tags"
-                      ? tags.length
-                      : key === "commits"
-                        ? commits.length
-                        : releases.length;
+                const count = {
+                  pulls: pulls.length,
+                  issues: issues.length,
+                  branches: branches.length,
+                  tags: tags.length,
+                  commits: commits.length,
+                  releases: releases.length,
+                }[key];
                return (
                  <button
                    key={key}
@@ -292,6 +321,16 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
            </div>

            <div className="max-h-[26rem] overflow-y-auto">
+              {tab === "pulls" ? (
+                <TicketList
+                  tickets={pulls}
+                  empty="Keine offenen Pull oder Merge Requests."
+                  icon={GitPullRequest}
+                />
+              ) : null}
+              {tab === "issues" ? (
+                <TicketList tickets={issues} empty="Keine offenen Issues." icon={CircleDot} />
+              ) : null}
              {tab === "branches" ? <BranchList branches={branches} /> : null}
              {tab === "tags" ? <TagList tags={tags} /> : null}
              {tab === "commits" ? <CommitList commits={commits} /> : null}
@@ -342,6 +381,67 @@ function Empty({ text }: { text: string }) {
  return <p className="px-4 py-8 text-center text-xs text-slate-500">{text}</p>;
 }

+function TicketList({
+  tickets,
+  empty,
+  icon: Icon,
+}: {
+  tickets: TicketInfo[];
+  empty: string;
+  icon: typeof GitPullRequest;
+}) {
+  if (tickets.length === 0) return <Empty text={empty} />;
+  return (
+    <div>
+      {tickets.map((ticket) => (
+        <Row key={`${ticket.number}-${ticket.title}`}>
+          <div className="flex min-w-0 items-start gap-2">
+            <Icon
+              className={cn(
+                "mt-0.5 h-3.5 w-3.5 shrink-0",
+                ticket.draft ? "text-slate-600" : "text-emerald-400/70",
+              )}
+            />
+            <div className="min-w-0">
+              <p className="truncate text-xs text-slate-200">
+                {ticket.title}
+                {ticket.draft ? (
+                  <span className="ml-1.5 rounded bg-slate-500/15 px-1 py-0.5 text-[10px] text-slate-400">
+                    Entwurf
+                  </span>
+                ) : null}
+              </p>
+              <p className="mt-0.5 flex flex-wrap items-center gap-x-2 text-[11px] text-slate-500">
+                <span className="font-mono text-slate-600">#{ticket.number}</span>
+                <span>{ticket.author ?? "unbekannt"}</span>
+                {ticket.labels.slice(0, 3).map((label) => (
+                  <span key={label} className="rounded bg-white/6 px-1 py-0.5 text-[10px]">
+                    {label}
+                  </span>
+                ))}
+              </p>
+            </div>
+          </div>
+          <div className="flex shrink-0 items-center gap-2 text-[11px] text-slate-500">
+            <span suppressHydrationWarning>{formatRelative(ticket.createdAt)}</span>
+            {ticket.url ? (
+              <a
+                href={ticket.url}
+                target="_blank"
+                rel="noreferrer noopener"
+                className="text-slate-600 transition-colors hover:text-violet-300"
+                aria-label="Im Git-System oeffnen"
+              >
+                <ExternalLink className="h-3 w-3" />
+              </a>
+            ) : null}
+          </div>
+        </Row>
+      ))}
+    </div>
+  );
+}
+
 function BranchList({ branches }: { branches: BranchInfo[] }) {
  if (branches.length === 0) return <Empty text="Keine Branches gefunden." />;
  return (
@@ -0,0 +1,276 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import Link from "next/link";
+import { useRouter } from "next/navigation";
+import {
+  DndContext,
+  DragOverlay,
+  PointerSensor,
+  TouchSensor,
+  closestCorners,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+  type DragStartEvent,
+} from "@dnd-kit/core";
+import { restrictToWindowEdges } from "@dnd-kit/modifiers";
+import { GitBranch, GripVertical, NotebookPen } from "lucide-react";
+import type { ProjectStatus } from "@prisma/client";
+import { CiBadge } from "@/components/CiBadge";
+import { STATUS_META, STATUS_ORDER, accentOf } from "@/lib/status";
+import { cn, truncate } from "@/lib/utils";
+import type { ProjectListItem } from "@/types";
+
+/**
+ * Statusspalten mit Ziehen und Ablegen.
+ *
+ * Der Statuswechsel wird sofort angezeigt und erst danach gespeichert;
+ * scheitert das Speichern, springt die Karte zurueck. Die Reihenfolge
+ * innerhalb einer Spalte ist nicht frei sortierbar – sie folgt der im Board
+ * gewaehlten Sortierung, sonst muesste eine Position mitgespeichert werden.
+ */
+export function KanbanBoard({
+  projects,
+  showArchived,
+}: {
+  projects: ProjectListItem[];
+  showArchived: boolean;
+}) {
+  const router = useRouter();
+  const [overrides, setOverrides] = useState<Record<string, ProjectStatus>>({});
+  const [activeId, setActiveId] = useState<string | null>(null);
+
+  // Eine Verschiebung, die der Server bestaetigt hat, braucht keine
+  // oertliche Ausnahme mehr.
+  useEffect(() => {
+    setOverrides((current) => {
+      const next: Record<string, ProjectStatus> = {};
+      for (const [id, status] of Object.entries(current)) {
+        const project = projects.find((entry) => entry.id === id);
+        if (project && project.status !== status) next[id] = status;
+      }
+      return Object.keys(next).length === Object.keys(current).length ? current : next;
+    });
+  }, [projects]);
+
+  const sensors = useSensors(
+    // Erst ab ein paar Pixeln Bewegung ziehen – sonst liesse sich die Karte
+    // nicht mehr anklicken.
+    useSensor(PointerSensor, { activationConstraint: { distance: 6 } }),
+    useSensor(TouchSensor, { activationConstraint: { delay: 180, tolerance: 8 } }),
+  );
+
+  const statusOf = (project: ProjectListItem) => overrides[project.id] ?? project.status;
+
+  const columns = useMemo(() => {
+    const visible = STATUS_ORDER.filter(
+      (status) => showArchived || status !== "ARCHIVED",
+    );
+    return visible.map((status) => ({
+      status,
+      items: projects.filter((project) => statusOf(project) === status),
+    }));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [projects, overrides, showArchived]);
+
+  const active = activeId ? projects.find((project) => project.id === activeId) : null;
+
+  function onDragStart(event: DragStartEvent) {
+    setActiveId(String(event.active.id));
+  }
+
+  async function onDragEnd(event: DragEndEvent) {
+    setActiveId(null);
+
+    const id = String(event.active.id);
+    const target = event.over?.id ? (String(event.over.id) as ProjectStatus) : null;
+    if (!target) return;
+
+    const project = projects.find((entry) => entry.id === id);
+    if (!project) return;
+
+    const previous = statusOf(project);
+    if (previous === target) return;
+
+    setOverrides((current) => ({ ...current, [id]: target }));
+
+    try {
+      const response = await fetch(`/api/projects/${id}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ status: target }),
+      });
+      if (!response.ok) throw new Error("failed");
+      router.refresh();
+    } catch {
+      setOverrides((current) => {
+        const next = { ...current };
+        delete next[id];
+        return next;
+      });
+    }
+  }
+
+  return (
+    <DndContext
+      sensors={sensors}
+      collisionDetection={closestCorners}
+      modifiers={[restrictToWindowEdges]}
+      onDragStart={onDragStart}
+      onDragEnd={onDragEnd}
+      onDragCancel={() => setActiveId(null)}
+    >
+      <div className="flex gap-3 overflow-x-auto pb-3">
+        {columns.map((column) => (
+          <Column key={column.status} status={column.status} count={column.items.length}>
+            {column.items.map((project) => (
+              <KanbanCard key={project.id} project={project} />
+            ))}
+          </Column>
+        ))}
+      </div>
+
+      {/* Die mitgezogene Karte haengt am Cursor, nicht in der Spalte. */}
+      <DragOverlay dropAnimation={{ duration: 180, easing: "cubic-bezier(0.22, 1, 0.36, 1)" }}>
+        {active ? <KanbanCard project={active} overlay /> : null}
+      </DragOverlay>
+    </DndContext>
+  );
+}
+
+function Column({
+  status,
+  count,
+  children,
+}: {
+  status: ProjectStatus;
+  count: number;
+  children: React.ReactNode;
+}) {
+  const meta = STATUS_META[status];
+  const { setNodeRef, isOver } = useDroppable({ id: status });
+
+  return (
+    <section
+      ref={setNodeRef}
+      // Eindeutiger Anker fuer Tests und Automatisierung.
+      data-column={status}
+      className={cn(
+        "flex w-[17rem] shrink-0 flex-col rounded-2xl border border-white/6 bg-white/2 transition-colors",
+        isOver && "border-violet-400/40 bg-violet-500/6",
+      )}
+    >
+      <header className="flex items-center gap-2 px-3 py-2.5">
+        <span
+          className="accent-dot h-2 w-2 rounded-full"
+          style={{ backgroundColor: meta.color, color: meta.color }}
+        />
+        <h3 className="text-xs font-semibold uppercase tracking-wider text-slate-300">
+          {meta.label}
+        </h3>
+        <span className="ml-auto rounded-full bg-white/6 px-1.5 py-0.5 text-[10px] tabular-nums text-slate-400">
+          {count}
+        </span>
+      </header>
+
+      <div className="flex min-h-[7rem] flex-1 flex-col gap-2 px-2 pb-2">
+        {children}
+        {count === 0 ? (
+          <p
+            className={cn(
+              "rounded-xl border border-dashed border-white/8 px-3 py-6 text-center text-[11px] text-slate-600 transition-colors",
+              isOver && "border-violet-400/40 text-violet-200",
+            )}
+          >
+            {isOver ? "Hier ablegen" : "leer"}
+          </p>
+        ) : null}
+      </div>
+    </section>
+  );
+}
+
+function KanbanCard({
+  project,
+  overlay = false,
+}: {
+  project: ProjectListItem;
+  overlay?: boolean;
+}) {
+  const accent = accentOf(project.accent);
+  const { attributes, listeners, setNodeRef, isDragging } = useDraggable({ id: project.id });
+
+  return (
+    <article
+      ref={overlay ? undefined : setNodeRef}
+      className={cn(
+        "popover group relative overflow-hidden p-3",
+        // Das Original bleibt als blasser Platzhalter stehen.
+        isDragging && !overlay && "opacity-30",
+        overlay && "rotate-2 cursor-grabbing shadow-2xl ring-1 ring-violet-400/40",
+      )}
+      style={
+        {
+          "--accent-from": accent.from,
+          "--accent-to": accent.to,
+        } as React.CSSProperties
+      }
+    >
+      <span className="accent-bar absolute inset-x-0 top-0 h-[2px] opacity-70" aria-hidden="true" />
+
+      <div className="flex items-start gap-2">
+        {/* Nur der Griff zieht – so bleibt der Titel ein normaler Link. */}
+        <button
+          type="button"
+          className="mt-0.5 shrink-0 cursor-grab touch-none rounded p-0.5 text-slate-600 transition-colors hover:text-slate-300 active:cursor-grabbing"
+          aria-label={`${project.name} verschieben`}
+          {...attributes}
+          {...listeners}
+        >
+          <GripVertical className="h-3.5 w-3.5" />
+        </button>
+
+        <div className="min-w-0 flex-1">
+          <Link
+            href={`/projects/${project.id}`}
+            className="block truncate text-sm font-medium text-slate-100 hover:text-violet-200"
+          >
+            {project.name}
+          </Link>
+          {project.summary ? (
+            <p className="mt-0.5 line-clamp-2 text-[11px] leading-snug text-slate-500">
+              {truncate(project.summary, 90)}
+            </p>
+          ) : null}
+        </div>
+      </div>
+
+      <div className="mt-2.5 h-1 w-full overflow-hidden rounded-full bg-white/6">
+        <div
+          className="accent-bar h-full rounded-full"
+          style={{ width: `${Math.max(2, project.progress)}%` }}
+        />
+      </div>
+
+      <div className="mt-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 text-[10px] text-slate-500">
+        <CiBadge state={project.snapshot?.ciState} compact />
+        {project.snapshot?.defaultBranch ? (
+          <span className="inline-flex items-center gap-1 font-mono">
+            <GitBranch className="h-3 w-3" />
+            {project.snapshot.defaultBranch}
+          </span>
+        ) : null}
+        {project._count.notes > 0 ? (
+          <span className="inline-flex items-center gap-1">
+            <NotebookPen className="h-3 w-3" />
+            {project._count.notes}
+          </span>
+        ) : null}
+        <span className="ml-auto tabular-nums">{project.progress}%</span>
+      </div>
+    </article>
+  );
+}
@@ -1,11 +1,14 @@
 "use client";

-import { useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
+import Link from "next/link";
 import {
+  Columns3,
  Database,
  Download,
  LayoutGrid,
  ListFilter,
+  NotebookPen,
  Plus,
  Rows3,
  Search,
@@ -14,6 +17,7 @@ import {
 } from "lucide-react";
 import type { ProjectStatus } from "@prisma/client";
 import { ImportDialog } from "@/components/ImportDialog";
+import { KanbanBoard } from "@/components/KanbanBoard";
 import { ProjectCard } from "@/components/ProjectCard";
 import { ProjectDialog } from "@/components/ProjectDialog";
 import { Popover } from "@/components/ui/Popover";
@@ -21,8 +25,34 @@ import { STATUS_META, STATUS_ORDER } from "@/lib/status";
 import { cn } from "@/lib/utils";
 import type { ConnectionSafe, ProjectListItem } from "@/types";

+interface NoteHit {
+  projectId: string;
+  noteId: string;
+  title: string | null;
+  /** Ausschnitt mit [[…]] um die Fundstelle – siehe /api/search. */
+  snippet: string;
+}
+
+/**
+ * Wandelt die [[…]]-Markierungen von ts_headline in hervorgehobene Stellen.
+ * Bewusst kein HTML aus der Datenbank einbetten – der Text stammt aus einer
+ * Notiz und damit vom Benutzer.
+ */
+function highlight(snippet: string): React.ReactNode[] {
+  return snippet.split(/(\[\[.*?\]\])/g).map((part, index) => {
+    if (part.startsWith("[[") && part.endsWith("]]")) {
+      return (
+        <mark key={index} className="rounded bg-violet-500/25 px-0.5 text-violet-100">
+          {part.slice(2, -2)}
+        </mark>
+      );
+    }
+    return <span key={index}>{part}</span>;
+  });
+}
+
 type SortKey = "updated" | "created" | "name" | "progress" | "priority";
-type ViewMode = "grid" | "grouped";
+type ViewMode = "grid" | "grouped" | "kanban";

 const SORT_LABEL: Record<SortKey, string> = {
  updated: "Zuletzt geaendert",
@@ -48,6 +78,45 @@ export function ProjectBoard({
  const [importOpen, setImportOpen] = useState(false);
  const [dataMenuOpen, setDataMenuOpen] = useState(false);
  const dataButtonRef = useRef<HTMLButtonElement>(null);
+  const [noteHits, setNoteHits] = useState<NoteHit[]>([]);
+
+  /**
+   * Notizen liegen im Board nicht vor – sie mitzuladen wuerde die Seite
+   * unnoetig aufblaehen. Stattdessen sucht Postgres serverseitig, sobald der
+   * Begriff lang genug ist. Entprellt, damit nicht jeder Tastendruck eine
+   * Abfrage ausloest.
+   */
+  useEffect(() => {
+    const needle = query.trim();
+    if (needle.length < 2) {
+      setNoteHits([]);
+      return;
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(async () => {
+      try {
+        const response = await fetch(`/api/search?q=${encodeURIComponent(needle)}`, {
+          signal: controller.signal,
+        });
+        if (!response.ok) return;
+        const body = (await response.json()) as { hits: NoteHit[] };
+        setNoteHits(body.hits ?? []);
+      } catch {
+        // Abgebrochene Anfragen sind der Normalfall beim Tippen.
+      }
+    }, 300);
+
+    return () => {
+      clearTimeout(timer);
+      controller.abort();
+    };
+  }, [query]);
+
+  const noteHitProjectIds = useMemo(
+    () => new Set(noteHits.map((hit) => hit.projectId)),
+    [noteHits],
+  );

  const counts = useMemo(() => {
    const map = new Map<ProjectStatus, number>();
@@ -71,7 +140,9 @@ export function ProjectBoard({
        (project.summary ?? "").toLowerCase().includes(needle) ||
        (project.description ?? "").toLowerCase().includes(needle) ||
        project.tags.some((tag) => tag.includes(needle)) ||
-        (project.snapshot?.fullName ?? "").toLowerCase().includes(needle)
+        (project.snapshot?.fullName ?? "").toLowerCase().includes(needle) ||
+        // Treffer in Notizen kommen vom Server dazu.
+        noteHitProjectIds.has(project.id)
      );
    });

@@ -92,7 +163,7 @@ export function ProjectBoard({
    });

    return sorted;
-  }, [projects, query, statusFilter, sort, showArchived]);
+  }, [projects, query, statusFilter, sort, showArchived, noteHitProjectIds]);

  const grouped = useMemo(() => {
    return STATUS_ORDER.map((status) => ({
@@ -178,6 +249,18 @@ export function ProjectBoard({
              >
                <Rows3 className="h-4 w-4" />
              </button>
+              <button
+                type="button"
+                onClick={() => setView("kanban")}
+                className={cn(
+                  "p-2 transition-colors",
+                  view === "kanban" ? "bg-white/10 text-white" : "text-slate-500 hover:text-white",
+                )}
+                aria-label="Kanban-Spalten"
+                title="Kanban – Status per Ziehen aendern"
+              >
+                <Columns3 className="h-4 w-4" />
+              </button>
            </div>

            <button
@@ -256,9 +339,54 @@ export function ProjectBoard({
        </div>
      </div>

+      {/* Treffer in Notizen */}
+      {noteHits.length > 0 ? (
+        <div className="glass fade-up p-4">
+          <h2 className="mb-2.5 flex items-center gap-2 text-[11px] font-semibold uppercase tracking-wider text-slate-400">
+            <NotebookPen className="h-3.5 w-3.5 text-violet-300" />
+            Treffer in Notizen
+            <span className="rounded-full bg-white/6 px-2 py-0.5 tabular-nums text-slate-400">
+              {noteHits.length}
+            </span>
+          </h2>
+          <ul className="space-y-1">
+            {noteHits.slice(0, 8).map((hit) => {
+              const project = projects.find((entry) => entry.id === hit.projectId);
+              return (
+                <li key={hit.noteId}>
+                  <Link
+                    href={`/projects/${hit.projectId}`}
+                    className="block rounded-lg px-2.5 py-2 transition-colors hover:bg-white/5"
+                  >
+                    <span className="flex flex-wrap items-baseline gap-x-2">
+                      <span className="text-sm text-slate-200">
+                        {project?.name ?? "Projekt"}
+                      </span>
+                      {hit.title ? (
+                        <span className="text-[11px] text-slate-500">· {hit.title}</span>
+                      ) : null}
+                    </span>
+                    <span className="mt-0.5 block text-xs leading-snug text-slate-400">
+                      {highlight(hit.snippet)}
+                    </span>
+                  </Link>
+                </li>
+              );
+            })}
+          </ul>
+          {noteHits.length > 8 ? (
+            <p className="mt-2 px-2.5 text-[11px] text-slate-600">
+              … und {noteHits.length - 8} weitere
+            </p>
+          ) : null}
+        </div>
+      ) : null}
+
      {/* Inhalt */}
      {visible.length === 0 ? (
        <EmptyState hasFilters={hasFilters} onCreate={() => setDialogOpen(true)} />
+      ) : view === "kanban" ? (
+        <KanbanBoard projects={visible} showArchived={showArchived} />
      ) : view === "grid" ? (
        <div className="grid gap-4 sm:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4">
          {visible.map((project, index) => (
@@ -4,16 +4,19 @@ import Link from "next/link";
 import { useState } from "react";
 import {
  AlertTriangle,
+  CheckSquare,
  GitBranch,
  GitCommitHorizontal,
  NotebookPen,
  Star,
  Tag,
 } from "lucide-react";
+import { CiBadge } from "@/components/CiBadge";
+import { Sparkline } from "@/components/Sparkline";
 import { StatusSelect } from "@/components/StatusSelect";
 import { PRIORITY_META, accentOf } from "@/lib/status";
 import { cn, formatRelative, truncate } from "@/lib/utils";
-import type { ProjectListItem } from "@/types";
+import { asArray, type ProjectListItem } from "@/types";

 const PROVIDER_LABEL: Record<string, string> = {
  GITHUB: "GitHub",
@@ -29,6 +32,7 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
  const accent = accentOf(project.accent);
  const priority = PRIORITY_META[project.priority] ?? PRIORITY_META[2];
  const snapshot = project.snapshot;
+  const activity = asArray<number>(snapshot?.commitActivity);
  const [favorite, setFavorite] = useState(project.favorite);

  async function toggleFavorite() {
@@ -110,8 +114,17 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
          </div>
        </div>

+        {/* Commit-Aktivitaet */}
+        {activity.some((value) => value > 0) ? (
+          <div className="mt-3">
+            <Sparkline values={activity} height={20} />
+          </div>
+        ) : null}
+
        {/* Git-Kurzinfo */}
        <div className="mt-4 flex flex-wrap items-center gap-x-3 gap-y-2 text-[11px] text-slate-400">
+          <CiBadge state={snapshot?.ciState} name={snapshot?.ciName} compact />
+
          {project.connection ? (
            <span className="glass-soft inline-flex items-center gap-1.5 px-2 py-1">
              <span className="h-1.5 w-1.5 rounded-full bg-violet-400" aria-hidden="true" />
@@ -143,6 +156,16 @@ export function ProjectCard({ project, index = 0 }: { project: ProjectListItem;
            </span>
          ) : null}

+          {project._count.tasks > 0 ? (
+            <span
+              className="inline-flex items-center gap-1.5"
+              title={`${project.tasks.length} von ${project._count.tasks} Aufgaben erledigt`}
+            >
+              <CheckSquare className="h-3.5 w-3.5 text-slate-500" />
+              {project.tasks.length}/{project._count.tasks}
+            </span>
+          ) : null}
+
          {project._count.notes > 0 ? (
            <span className="inline-flex items-center gap-1.5">
              <NotebookPen className="h-3.5 w-3.5 text-slate-500" />
@@ -32,6 +32,7 @@ interface FormState {
  repoOwner: string;
  repoName: string;
  autoSync: boolean;
+  progressFromTasks: boolean;
 }

 const EMPTY: FormState = {
@@ -49,6 +50,7 @@ const EMPTY: FormState = {
  repoOwner: "",
  repoName: "",
  autoSync: true,
+  progressFromTasks: false,
 };

 export function ProjectDialog({ open, onClose, connections, project }: ProjectDialogProps) {
@@ -90,6 +92,7 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
            repoOwner: project.repoOwner ?? "",
            repoName: project.repoName ?? "",
            autoSync: project.autoSync,
+            progressFromTasks: project.progressFromTasks,
          }
        : EMPTY,
    );
@@ -158,6 +161,7 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
      repoOwner: form.repoOwner,
      repoName: form.repoName,
      autoSync: form.autoSync,
+      progressFromTasks: form.progressFromTasks,
    };

    try {
@@ -291,9 +295,25 @@ export function ProjectDialog({ open, onClose, connections, project }: ProjectDi
              step={5}
              value={form.progress}
              onChange={(event) => update("progress", Number(event.target.value))}
-              className="range"
+              disabled={form.progressFromTasks}
+              className={cn("range", form.progressFromTasks && "cursor-not-allowed opacity-40")}
              style={{ "--fill": `${form.progress}%` } as React.CSSProperties}
            />
+            <label className="mt-2 flex cursor-pointer items-start gap-2.5 text-sm text-slate-400">
+              <input
+                type="checkbox"
+                checked={form.progressFromTasks}
+                onChange={(event) => update("progressFromTasks", event.target.checked)}
+                className="mt-0.5 h-4 w-4 accent-violet-500"
+              />
+              <span>
+                Aus Aufgaben berechnen
+                <span className="mt-0.5 block text-[11px] text-slate-600">
+                  Der Fortschritt ergibt sich dann aus dem Anteil erledigter Aufgaben und
+                  laesst sich nicht mehr von Hand schieben.
+                </span>
+              </span>
+            </label>
          </div>

          <div className="sm:col-span-2">
@@ -6,6 +6,7 @@ import Link from "next/link";
 import {
  ArrowLeft,
  CalendarDays,
+  CheckSquare,
  Download,
  ExternalLink,
  FileJson,
@@ -207,7 +208,15 @@ export function ProjectHeader({
      {/* Fortschritt direkt regelbar */}
      <div className="mt-6">
        <div className="mb-2 flex items-center justify-between text-xs text-slate-500">
-          <span>Fortschritt</span>
+          <span className="flex items-center gap-1.5">
+            Fortschritt
+            {project.progressFromTasks ? (
+              <span className="inline-flex items-center gap-1 rounded bg-white/6 px-1.5 py-0.5 text-[10px] text-slate-400">
+                <CheckSquare className="h-2.5 w-2.5" />
+                aus Aufgaben
+              </span>
+            ) : null}
+          </span>
          <span className="tabular-nums text-slate-300">{progress}%</span>
        </div>
        {/* Eigener Regler statt eines unsichtbaren Eingabefelds ueber einem
@@ -223,7 +232,11 @@ export function ProjectHeader({
          onTouchEnd={() => patch({ progress })}
          onKeyUp={() => patch({ progress })}
          aria-label="Fortschritt anpassen"
-          className="range"
+          // Wird der Wert aus Aufgaben abgeleitet, waere ein Zug hier
+          // wirkungslos – er wuerde beim naechsten Aufgabenwechsel wieder
+          // ueberschrieben.
+          disabled={project.progressFromTasks}
+          className={cn("range", project.progressFromTasks && "cursor-not-allowed opacity-50")}
          style={{ "--fill": `${progress}%` } as React.CSSProperties}
        />
      </div>
@@ -0,0 +1,57 @@
+import { cn } from "@/lib/utils";
+
+/**
+ * Commit-Aktivitaet als kleine Balkenreihe.
+ *
+ * Bewusst als reines SVG ohne Diagrammbibliothek: es sind dreissig Werte,
+ * die Achsen, Legende und Tooltips einer Bibliothek waeren hier nur Ballast.
+ */
+export function Sparkline({
+  values,
+  className,
+  height = 28,
+  label = "Commits",
+}: {
+  values: number[];
+  className?: string;
+  height?: number;
+  label?: string;
+}) {
+  if (!values.length) return null;
+
+  const total = values.reduce((sum, value) => sum + value, 0);
+  if (total === 0) return null;
+
+  const max = Math.max(...values);
+  const gap = 1;
+  const barWidth = 3;
+  const width = values.length * (barWidth + gap) - gap;
+
+  return (
+    <svg
+      viewBox={`0 0 ${width} ${height}`}
+      preserveAspectRatio="none"
+      className={cn("w-full", className)}
+      style={{ height }}
+      role="img"
+      aria-label={`${label} der letzten ${values.length} Tage: insgesamt ${total}`}
+    >
+      <title>{`${label} der letzten ${values.length} Tage: insgesamt ${total}`}</title>
+      {values.map((value, index) => {
+        // Auch ein einzelner Commit soll sichtbar sein, daher die Untergrenze.
+        const barHeight = value === 0 ? 1.5 : Math.max(3, (value / max) * height);
+        return (
+          <rect
+            key={index}
+            x={index * (barWidth + gap)}
+            y={height - barHeight}
+            width={barWidth}
+            height={barHeight}
+            rx={1}
+            className={value === 0 ? "fill-white/10" : "fill-violet-400/80"}
+          />
+        );
+      })}
+    </svg>
+  );
+}
@@ -0,0 +1,329 @@
+"use client";
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useRouter } from "next/navigation";
+import {
+  DndContext,
+  DragOverlay,
+  PointerSensor,
+  TouchSensor,
+  pointerWithin,
+  useDroppable,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+  type DragOverEvent,
+  type DragStartEvent,
+} from "@dnd-kit/core";
+import { restrictToWindowEdges } from "@dnd-kit/modifiers";
+import { SortableContext, useSortable, verticalListSortingStrategy } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { CheckSquare, Loader2, Plus } from "lucide-react";
+import type { Task, TaskStatus } from "@prisma/client";
+import { TaskCard } from "@/components/tasks/TaskCard";
+import { TaskDialog } from "@/components/tasks/TaskDialog";
+import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
+import { cn } from "@/lib/utils";
+
+type Columns = Record<TaskStatus, Task[]>;
+
+function group(tasks: Task[]): Columns {
+  const columns = { TODO: [], DOING: [], BLOCKED: [], DONE: [] } as Columns;
+  for (const task of [...tasks].sort((a, b) => a.position - b.position)) {
+    columns[task.status].push(task);
+  }
+  return columns;
+}
+
+/**
+ * Aufgabenbrett eines Projekts.
+ *
+ * Anders als beim Projektbrett ist die Reihenfolge innerhalb einer Spalte
+ * hier bedeutsam, deshalb @dnd-kit/sortable statt einfacher Ablageflaechen.
+ * Waehrend des Ziehens fuehrt der oertliche Zustand, danach wird die neue
+ * Ordnung als Ganzes gespeichert: je Spalte die vollstaendige Liste. Das ist
+ * wiederholbar und kommt ohne Nachrechnen von Positionen im Browser aus.
+ */
+export function TaskBoard({
+  projectId,
+  tasks,
+  progressFromTasks,
+}: {
+  projectId: string;
+  tasks: Task[];
+  progressFromTasks: boolean;
+}) {
+  const router = useRouter();
+  const [columns, setColumns] = useState<Columns>(() => group(tasks));
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const [editing, setEditing] = useState<Task | null>(null);
+  const [creatingIn, setCreatingIn] = useState<TaskStatus | null>(null);
+  const [saving, setSaving] = useState(false);
+  const dragging = useRef(false);
+
+  // Serverstand uebernehmen, solange nicht gerade gezogen wird – sonst
+  // wuerde die Karte mitten in der Bewegung zurueckspringen.
+  useEffect(() => {
+    if (!dragging.current) setColumns(group(tasks));
+  }, [tasks]);
+
+  const sensors = useSensors(
+    useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+    useSensor(TouchSensor, { activationConstraint: { delay: 180, tolerance: 8 } }),
+  );
+
+  const allTasks = useMemo(() => Object.values(columns).flat(), [columns]);
+  const active = activeId ? allTasks.find((task) => task.id === activeId) ?? null : null;
+  const total = allTasks.length;
+  const done = columns.DONE.length;
+
+  function containerOf(id: string): TaskStatus | null {
+    if (TASK_STATUS_ORDER.includes(id as TaskStatus)) return id as TaskStatus;
+    for (const status of TASK_STATUS_ORDER) {
+      if (columns[status].some((task) => task.id === id)) return status;
+    }
+    return null;
+  }
+
+  function onDragStart(event: DragStartEvent) {
+    dragging.current = true;
+    setActiveId(String(event.active.id));
+  }
+
+  /** Wechsel der Spalte passiert schon beim Darueberziehen, nicht erst beim Ablegen. */
+  function onDragOver(event: DragOverEvent) {
+    const activeKey = String(event.active.id);
+    const overKey = event.over ? String(event.over.id) : null;
+    if (!overKey) return;
+
+    const from = containerOf(activeKey);
+    const to = containerOf(overKey);
+    if (!from || !to || from === to) return;
+
+    setColumns((current) => {
+      const moved = current[from].find((task) => task.id === activeKey);
+      if (!moved) return current;
+
+      const targetIndex = current[to].findIndex((task) => task.id === overKey);
+      const insertAt = targetIndex >= 0 ? targetIndex : current[to].length;
+
+      return {
+        ...current,
+        [from]: current[from].filter((task) => task.id !== activeKey),
+        [to]: [
+          ...current[to].slice(0, insertAt),
+          { ...moved, status: to },
+          ...current[to].slice(insertAt),
+        ],
+      };
+    });
+  }
+
+  async function onDragEnd(event: DragEndEvent) {
+    const activeKey = String(event.active.id);
+    const overKey = event.over ? String(event.over.id) : null;
+
+    let next = columns;
+
+    if (overKey) {
+      const container = containerOf(activeKey);
+      const overContainer = containerOf(overKey);
+      if (container && container === overContainer) {
+        const list = columns[container];
+        const oldIndex = list.findIndex((task) => task.id === activeKey);
+        const newIndex = list.findIndex((task) => task.id === overKey);
+        if (oldIndex >= 0 && newIndex >= 0 && oldIndex !== newIndex) {
+          const reordered = [...list];
+          const [moved] = reordered.splice(oldIndex, 1);
+          reordered.splice(newIndex, 0, moved);
+          next = { ...columns, [container]: reordered };
+          setColumns(next);
+        }
+      }
+    }
+
+    setActiveId(null);
+    dragging.current = false;
+    await persist(next);
+  }
+
+  async function persist(next: Columns) {
+    setSaving(true);
+    try {
+      const payload = {
+        columns: Object.fromEntries(
+          TASK_STATUS_ORDER.map((status) => [status, next[status].map((task) => task.id)]),
+        ),
+      };
+      const response = await fetch(`/api/projects/${projectId}/tasks/reorder`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) throw new Error("failed");
+      router.refresh();
+    } catch {
+      // Zurueck auf den Serverstand – die Bewegung war dann nur optisch.
+      setColumns(group(tasks));
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  return (
+    <section className="glass p-5">
+      <div className="mb-4 flex flex-wrap items-center justify-between gap-3">
+        <div className="flex items-center gap-3">
+          <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-violet-500/12 text-violet-300">
+            <CheckSquare className="h-4 w-4" />
+          </span>
+          <div>
+            <h2 className="flex items-center gap-2 text-sm font-semibold uppercase tracking-wider text-slate-200">
+              Aufgaben
+              {total > 0 ? (
+                <span className="rounded-full bg-white/6 px-2 py-0.5 text-[11px] tabular-nums text-slate-400">
+                  {done}/{total}
+                </span>
+              ) : null}
+              {saving ? <Loader2 className="h-3 w-3 animate-spin text-slate-500" /> : null}
+            </h2>
+            <p className="mt-0.5 text-[11px] text-slate-500">
+              {progressFromTasks
+                ? "Der Fortschritt des Projekts folgt diesen Aufgaben."
+                : "Ziehen zum Verschieben und Sortieren."}
+            </p>
+          </div>
+        </div>
+
+        <button
+          type="button"
+          className="btn btn-ghost px-3 py-1.5 text-xs"
+          onClick={() => setCreatingIn("TODO")}
+        >
+          <Plus className="h-3.5 w-3.5" />
+          Aufgabe
+        </button>
+      </div>
+
+      <DndContext
+        sensors={sensors}
+        collisionDetection={pointerWithin}
+        modifiers={[restrictToWindowEdges]}
+        onDragStart={onDragStart}
+        onDragOver={onDragOver}
+        onDragEnd={onDragEnd}
+        onDragCancel={() => {
+          setActiveId(null);
+          dragging.current = false;
+          setColumns(group(tasks));
+        }}
+      >
+        <div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-4">
+          {TASK_STATUS_ORDER.map((status) => (
+            <TaskColumn
+              key={status}
+              status={status}
+              tasks={columns[status]}
+              onAdd={() => setCreatingIn(status)}
+              onEdit={setEditing}
+            />
+          ))}
+        </div>
+
+        <DragOverlay dropAnimation={{ duration: 180, easing: "cubic-bezier(0.22, 1, 0.36, 1)" }}>
+          {active ? <TaskCard task={active} overlay /> : null}
+        </DragOverlay>
+      </DndContext>
+
+      <TaskDialog
+        open={creatingIn !== null || editing !== null}
+        projectId={projectId}
+        task={editing}
+        initialStatus={creatingIn ?? "TODO"}
+        onClose={() => {
+          setCreatingIn(null);
+          setEditing(null);
+        }}
+      />
+    </section>
+  );
+}
+
+function TaskColumn({
+  status,
+  tasks,
+  onAdd,
+  onEdit,
+}: {
+  status: TaskStatus;
+  tasks: Task[];
+  onAdd: () => void;
+  onEdit: (task: Task) => void;
+}) {
+  const meta = TASK_STATUS_META[status];
+  const { setNodeRef, isOver } = useDroppable({ id: status });
+
+  return (
+    <div
+      ref={setNodeRef}
+      data-task-column={status}
+      className={cn(
+        "flex min-h-[8rem] flex-col rounded-xl border border-white/6 bg-black/20 p-2 transition-colors",
+        isOver && "border-violet-400/40 bg-violet-500/6",
+      )}
+    >
+      <div className="mb-2 flex items-center gap-2 px-1">
+        <span
+          className="h-1.5 w-1.5 rounded-full"
+          style={{ backgroundColor: meta.color }}
+          aria-hidden="true"
+        />
+        <h3 className="text-[11px] font-semibold uppercase tracking-wider text-slate-400">
+          {meta.label}
+        </h3>
+        <span className="ml-auto text-[10px] tabular-nums text-slate-600">{tasks.length}</span>
+      </div>
+
+      <SortableContext
+        items={tasks.map((task) => task.id)}
+        strategy={verticalListSortingStrategy}
+      >
+        <div className="flex flex-1 flex-col gap-1.5">
+          {tasks.map((task) => (
+            <SortableTask key={task.id} task={task} onEdit={onEdit} />
+          ))}
+          {tasks.length === 0 ? (
+            <p className="rounded-lg border border-dashed border-white/8 px-2 py-4 text-center text-[10px] text-slate-600">
+              {isOver ? "Hier ablegen" : "leer"}
+            </p>
+          ) : null}
+        </div>
+      </SortableContext>
+
+      <button
+        type="button"
+        onClick={onAdd}
+        className="mt-1.5 flex items-center gap-1.5 rounded-lg px-2 py-1.5 text-[11px] text-slate-600 transition-colors hover:bg-white/5 hover:text-slate-300"
+      >
+        <Plus className="h-3 w-3" />
+        hinzufuegen
+      </button>
+    </div>
+  );
+}
+
+function SortableTask({ task, onEdit }: { task: Task; onEdit: (task: Task) => void }) {
+  const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({
+    id: task.id,
+  });
+
+  return (
+    <div
+      ref={setNodeRef}
+      style={{ transform: CSS.Translate.toString(transform), transition }}
+      className={cn(isDragging && "opacity-30")}
+    >
+      <TaskCard task={task} onEdit={onEdit} dragHandle={{ ...attributes, ...listeners }} />
+    </div>
+  );
+}
@@ -0,0 +1,96 @@
+"use client";
+
+import { AlignLeft, CalendarClock, GripVertical } from "lucide-react";
+import type { Task } from "@prisma/client";
+import { cn, formatDate } from "@/lib/utils";
+
+/** Faelligkeit einordnen: ueberfaellig, heute, demnaechst. */
+function dueTone(due: Date | string | null, done: boolean) {
+  if (!due || done) return null;
+  const date = new Date(due);
+  if (Number.isNaN(date.getTime())) return null;
+
+  const today = new Date();
+  today.setHours(0, 0, 0, 0);
+  const target = new Date(date);
+  target.setHours(0, 0, 0, 0);
+
+  const days = Math.round((target.getTime() - today.getTime()) / 86_400_000);
+  if (days < 0) return { className: "text-rose-300", label: "ueberfaellig" };
+  if (days === 0) return { className: "text-amber-300", label: "heute" };
+  if (days <= 3) return { className: "text-amber-200/70", label: null };
+  return { className: "text-slate-500", label: null };
+}
+
+export function TaskCard({
+  task,
+  onEdit,
+  dragHandle,
+  overlay = false,
+}: {
+  task: Task;
+  onEdit?: (task: Task) => void;
+  dragHandle?: Record<string, unknown>;
+  overlay?: boolean;
+}) {
+  const done = task.status === "DONE";
+  const due = dueTone(task.dueDate, done);
+
+  return (
+    <article
+      className={cn(
+        "group rounded-lg border border-white/8 bg-[#0b0d1c] p-2 transition-colors",
+        !overlay && "hover:border-white/16",
+        overlay && "rotate-2 cursor-grabbing shadow-2xl ring-1 ring-violet-400/40",
+      )}
+    >
+      <div className="flex items-start gap-1.5">
+        <button
+          type="button"
+          className="mt-0.5 shrink-0 cursor-grab touch-none rounded p-0.5 text-slate-700 transition-colors hover:text-slate-400 active:cursor-grabbing"
+          aria-label={`${task.title} verschieben`}
+          {...dragHandle}
+        >
+          <GripVertical className="h-3 w-3" />
+        </button>
+
+        <button
+          type="button"
+          onClick={() => onEdit?.(task)}
+          disabled={!onEdit}
+          className="min-w-0 flex-1 text-left"
+        >
+          <p
+            className={cn(
+              "break-words text-xs leading-snug text-slate-200",
+              done && "text-slate-500 line-through",
+            )}
+          >
+            {task.title}
+          </p>
+
+          {(task.description || task.dueDate || task.labels.length > 0) && (
+            <div className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-[10px]">
+              {task.description ? (
+                <AlignLeft className="h-2.5 w-2.5 text-slate-600" aria-label="hat Beschreibung" />
+              ) : null}
+
+              {task.dueDate ? (
+                <span className={cn("inline-flex items-center gap-1", due?.className)}>
+                  <CalendarClock className="h-2.5 w-2.5" />
+                  {due?.label ?? formatDate(task.dueDate)}
+                </span>
+              ) : null}
+
+              {task.labels.slice(0, 3).map((label) => (
+                <span key={label} className="rounded bg-white/6 px-1 py-0.5 text-slate-400">
+                  {label}
+                </span>
+              ))}
+            </div>
+          )}
+        </button>
+      </div>
+    </article>
+  );
+}
@@ -0,0 +1,233 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { useRouter } from "next/navigation";
+import { Loader2, Trash2 } from "lucide-react";
+import type { Task, TaskStatus } from "@prisma/client";
+import { Modal } from "@/components/ui/Modal";
+import { TASK_STATUS_META, TASK_STATUS_ORDER } from "@/lib/tasks";
+import { cn, parseTags } from "@/lib/utils";
+
+/** Datum fuer <input type="date"> – ortszeitbezogen, nicht UTC. */
+function toDateInput(value: Date | string | null): string {
+  if (!value) return "";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  const offset = date.getTimezoneOffset() * 60_000;
+  return new Date(date.getTime() - offset).toISOString().slice(0, 10);
+}
+
+export function TaskDialog({
+  open,
+  projectId,
+  task,
+  initialStatus,
+  onClose,
+}: {
+  open: boolean;
+  projectId: string;
+  task: Task | null;
+  initialStatus: TaskStatus;
+  onClose: () => void;
+}) {
+  const router = useRouter();
+  const [title, setTitle] = useState("");
+  const [description, setDescription] = useState("");
+  const [status, setStatus] = useState<TaskStatus>(initialStatus);
+  const [dueDate, setDueDate] = useState("");
+  const [labels, setLabels] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const isEdit = Boolean(task);
+
+  useEffect(() => {
+    if (!open) return;
+    setTitle(task?.title ?? "");
+    setDescription(task?.description ?? "");
+    setStatus(task?.status ?? initialStatus);
+    setDueDate(toDateInput(task?.dueDate ?? null));
+    setLabels(task?.labels.join(", ") ?? "");
+    setError(null);
+  }, [open, task, initialStatus]);
+
+  async function submit(event: React.FormEvent) {
+    event.preventDefault();
+    setBusy(true);
+    setError(null);
+
+    const body = {
+      title,
+      description,
+      status,
+      // Ohne Uhrzeit auf Mittag legen, damit Zeitzonenverschiebungen das
+      // Datum nicht auf den Vortag ziehen.
+      dueDate: dueDate ? `${dueDate}T12:00:00` : null,
+      labels: parseTags(labels),
+    };
+
+    try {
+      const response = await fetch(
+        isEdit ? `/api/tasks/${task?.id}` : `/api/projects/${projectId}/tasks`,
+        {
+          method: isEdit ? "PATCH" : "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+        },
+      );
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(payload.error ?? "Speichern fehlgeschlagen.");
+      onClose();
+      router.refresh();
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function remove() {
+    if (!task) return;
+    if (!window.confirm(`Aufgabe „${task.title}“ loeschen?`)) return;
+    setBusy(true);
+    try {
+      const response = await fetch(`/api/tasks/${task.id}`, { method: "DELETE" });
+      if (!response.ok) throw new Error("Loeschen fehlgeschlagen.");
+      onClose();
+      router.refresh();
+    } catch (caught) {
+      setError(caught instanceof Error ? caught.message : String(caught));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      width="md"
+      title={isEdit ? "Aufgabe bearbeiten" : "Neue Aufgabe"}
+      description={isEdit ? undefined : "Titel genuegt – alles andere ist optional."}
+    >
+      <form onSubmit={submit} className="space-y-4">
+        <div>
+          <label className="field-label" htmlFor="task-title">
+            Titel *
+          </label>
+          <input
+            id="task-title"
+            className="field"
+            value={title}
+            onChange={(event) => setTitle(event.target.value)}
+            required
+            maxLength={200}
+            autoFocus
+          />
+        </div>
+
+        <div>
+          <span className="field-label">Spalte</span>
+          <div className="grid grid-cols-2 gap-2 sm:grid-cols-4">
+            {TASK_STATUS_ORDER.map((value) => {
+              const meta = TASK_STATUS_META[value];
+              return (
+                <button
+                  key={value}
+                  type="button"
+                  onClick={() => setStatus(value)}
+                  className={cn(
+                    "rounded-lg border px-2 py-2 text-xs transition-all",
+                    status === value
+                      ? "border-violet-400/60 bg-violet-500/12 text-white"
+                      : "border-white/9 text-slate-400 hover:border-white/20",
+                  )}
+                >
+                  <span className="flex items-center justify-center gap-1.5">
+                    <span
+                      className="h-1.5 w-1.5 rounded-full"
+                      style={{ backgroundColor: meta.color }}
+                    />
+                    {meta.label}
+                  </span>
+                </button>
+              );
+            })}
+          </div>
+        </div>
+
+        <div>
+          <label className="field-label" htmlFor="task-description">
+            Beschreibung
+          </label>
+          <textarea
+            id="task-description"
+            className="field min-h-24 resize-y font-mono text-[13px]"
+            value={description}
+            onChange={(event) => setDescription(event.target.value)}
+            placeholder="Markdown wird dargestellt."
+          />
+        </div>
+
+        <div className="grid gap-4 sm:grid-cols-2">
+          <div>
+            <label className="field-label" htmlFor="task-due">
+              Faellig am
+            </label>
+            <input
+              id="task-due"
+              className="field"
+              type="date"
+              value={dueDate}
+              onChange={(event) => setDueDate(event.target.value)}
+            />
+          </div>
+          <div>
+            <label className="field-label" htmlFor="task-labels">
+              Labels (kommagetrennt)
+            </label>
+            <input
+              id="task-labels"
+              className="field"
+              value={labels}
+              onChange={(event) => setLabels(event.target.value)}
+              placeholder="bug, ui"
+            />
+          </div>
+        </div>
+
+        {error ? (
+          <p className="rounded-lg border border-rose-500/30 bg-rose-500/10 px-3 py-2 text-sm text-rose-200">
+            {error}
+          </p>
+        ) : null}
+
+        <div className="flex items-center justify-between gap-2 pt-1">
+          {isEdit ? (
+            <button
+              type="button"
+              className="btn btn-danger px-3 py-1.5 text-xs"
+              onClick={remove}
+              disabled={busy}
+            >
+              <Trash2 className="h-3.5 w-3.5" />
+              Loeschen
+            </button>
+          ) : (
+            <span />
+          )}
+
+          <div className="flex gap-2">
+            <button type="button" className="btn btn-ghost" onClick={onClose} disabled={busy}>
+              Abbrechen
+            </button>
+            <button type="submit" className="btn btn-primary" disabled={busy || !title.trim()}>
+              {busy ? <Loader2 className="h-4 w-4 animate-spin" /> : null}
+              {isEdit ? "Speichern" : "Anlegen"}
+            </button>
+          </div>
+        </div>
+      </form>
+    </Modal>
+  );
+}
@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { PASSWORD_MIN_LENGTH } from "./constants";
+import { hashPassword, validatePasswordStrength, verifyPassword } from "./password";
+
+describe("hashPassword und verifyPassword", () => {
+  it("erkennt das richtige Passwort wieder", async () => {
+    const hash = await hashPassword("ein-langes-testpasswort");
+    await expect(verifyPassword("ein-langes-testpasswort", hash)).resolves.toBe(true);
+  });
+
+  it("weist ein falsches Passwort ab", async () => {
+    const hash = await hashPassword("ein-langes-testpasswort");
+    await expect(verifyPassword("etwas-anderes", hash)).resolves.toBe(false);
+  });
+
+  it("erzeugt fuer dasselbe Passwort unterschiedliche Hashes", async () => {
+    // Unterschiedliches Salz – sonst waere an gleichen Hashes ablesbar,
+    // wer dasselbe Passwort benutzt.
+    const a = await hashPassword("ein-langes-testpasswort");
+    const b = await hashPassword("ein-langes-testpasswort");
+    expect(a).not.toBe(b);
+  });
+
+  it("haelt das erwartete Ablageformat ein", async () => {
+    const hash = await hashPassword("ein-langes-testpasswort");
+    expect(hash).toMatch(/^scrypt\$\d+\$\d+\$\d+\$[\w-]+\$[\w-]+$/);
+  });
+
+  it("stuerzt bei kaputten oder fehlenden Hashes nicht ab", async () => {
+    await expect(verifyPassword("x", null)).resolves.toBe(false);
+    await expect(verifyPassword("x", "")).resolves.toBe(false);
+    await expect(verifyPassword("x", "voelliger-unsinn")).resolves.toBe(false);
+    await expect(verifyPassword("x", "scrypt$a$b$c$d$e")).resolves.toBe(false);
+  });
+
+  it("behandelt gleichwertige Unicode-Schreibweisen gleich", async () => {
+    // "é" als ein Zeichen und als e + Akzent kombiniert.
+    const hash = await hashPassword("passwort-café-lang");
+    await expect(verifyPassword("passwort-café-lang", hash)).resolves.toBe(true);
+  });
+});
+
+describe("validatePasswordStrength", () => {
+  it("nimmt ein ausreichend langes Passwort an", () => {
+    expect(validatePasswordStrength("ein-langes-testpasswort")).toBeNull();
+  });
+
+  it("weist zu kurze Passwoerter ab", () => {
+    expect(validatePasswordStrength("a".repeat(PASSWORD_MIN_LENGTH - 1))).toMatch(
+      /mindestens/,
+    );
+  });
+
+  it("weist naheliegende Passwoerter ab", () => {
+    expect(validatePasswordStrength("password")).toBeTruthy();
+    expect(validatePasswordStrength("Passwort")).toBeTruthy();
+  });
+
+  it("weist reine Ziffernfolgen ab", () => {
+    expect(validatePasswordStrength("1234567890123")).toMatch(/Ziffern/);
+  });
+
+  it("weist uebermaessig lange Passwoerter ab", () => {
+    expect(validatePasswordStrength("a".repeat(300))).toMatch(/hoechstens/);
+  });
+});
@@ -12,6 +12,17 @@ function trimmed(value: string | undefined): string | null {
  return result ? result : null;
 }

+import packageJson from "../../package.json";
+
+/**
+ * Version aus der package.json – eine einzige Quelle. Vorher stand sie
+ * zusaetzlich in der Fusszeile und lief prompt auseinander.
+ *
+ * Bewusst als Standardimport: ein benannter Import aus einer JSON-Datei
+ * loest in Webpack eine Warnung aus.
+ */
+export const APP_VERSION: string = packageJson.version;
+
 /** Anzeigename der Instanz – Seitentitel, Kopfzeile, Passkey-Dialog. */
 export const APP_NAME = trimmed(process.env.APP_NAME) ?? "Nebula";

@@ -27,6 +27,16 @@ export const exportedNoteSchema = z.object({
  createdAt: z.string().optional(),
 });

+export const exportedTaskSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(5000).nullable().optional(),
+  status: z.enum(["TODO", "DOING", "BLOCKED", "DONE"]).optional().default("TODO"),
+  position: z.number().int().min(0).optional().default(0),
+  dueDate: z.string().nullable().optional(),
+  labels: z.array(z.string().max(30)).max(8).optional().default([]),
+  createdAt: z.string().optional(),
+});
+
 export const exportedConnectionSchema = z.object({
  name: z.string().max(80),
  provider: z.enum(PROVIDERS),
@@ -51,6 +61,8 @@ export const exportedProjectSchema = z.object({
  /** Nur zur Wiedererkennung – ohne Token. */
  connection: exportedConnectionSchema.nullable().optional(),
  notes: z.array(exportedNoteSchema).max(500).optional().default([]),
+  tasks: z.array(exportedTaskSchema).max(1000).optional().default([]),
+  progressFromTasks: z.boolean().optional().default(false),
  createdAt: z.string().optional(),
 });

@@ -1,12 +1,13 @@
-import type { GitConnection, Note, Project, RepoSnapshot } from "@prisma/client";
+import type { GitConnection, Note, Project, RepoSnapshot, Task } from "@prisma/client";
 import { APP_NAME } from "@/lib/config";
 import { prisma } from "@/lib/db";
 import { PRIORITY_META, statusOf } from "@/lib/status";
-import { formatDateTime } from "@/lib/utils";
+import { formatDate, formatDateTime } from "@/lib/utils";
 import { EXPORT_KIND, EXPORT_VERSION, type ExportFile, type ExportedProject } from "./format";

 type ProjectForExport = Project & {
  notes: Note[];
+  tasks: Task[];
  connection: Pick<GitConnection, "name" | "provider" | "baseUrl"> | null;
 };

@@ -40,6 +41,16 @@ export function toExportedProject(project: ProjectForExport): ExportedProject {
      pinned: note.pinned,
      createdAt: note.createdAt.toISOString(),
    })),
+    tasks: project.tasks.map((task) => ({
+      title: task.title,
+      description: task.description,
+      status: task.status,
+      position: task.position,
+      dueDate: task.dueDate?.toISOString() ?? null,
+      labels: task.labels,
+      createdAt: task.createdAt.toISOString(),
+    })),
+    progressFromTasks: project.progressFromTasks,
    createdAt: project.createdAt.toISOString(),
  };
 }
@@ -63,6 +74,7 @@ export async function loadProjectsForExport(
    where: { ownerId, ...(projectId ? { id: projectId } : {}) },
    include: {
      notes: { orderBy: [{ pinned: "desc" }, { createdAt: "asc" }] },
+      tasks: { orderBy: [{ status: "asc" }, { position: "asc" }] },
      connection: { select: { name: true, provider: true, baseUrl: true } },
    },
    orderBy: { name: "asc" },
@@ -77,6 +89,13 @@ const PROVIDER_LABEL: Record<string, string> = {
  GITEA: "Gitea",
 };

+const TASK_LABEL: Record<string, string> = {
+  TODO: "Offen",
+  DOING: "In Arbeit",
+  BLOCKED: "Blockiert",
+  DONE: "Erledigt",
+};
+
 /**
 * Ein Projekt als lesbares Markdown – zum Archivieren oder als Grundlage
 * fuer ein README. Der Git-Stand kommt aus dem letzten Snapshot, damit die
@@ -131,6 +150,21 @@ export function toMarkdown(
    lines.push("");
  }

+  if (project.tasks.length) {
+    lines.push("## Aufgaben", "");
+    for (const status of ["TODO", "DOING", "BLOCKED", "DONE"] as const) {
+      const inColumn = project.tasks.filter((task) => task.status === status);
+      if (!inColumn.length) continue;
+      lines.push(`### ${TASK_LABEL[status]}`, "");
+      for (const task of inColumn) {
+        const box = status === "DONE" ? "[x]" : "[ ]";
+        const due = task.dueDate ? ` _(faellig ${formatDate(task.dueDate)})_` : "";
+        lines.push(`- ${box} ${task.title}${due}`);
+      }
+      lines.push("");
+    }
+  }
+
  if (project.notes.length) {
    lines.push("## Notizen", "");
    for (const note of project.notes) {
@@ -1,6 +1,8 @@
 import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
 import type {
  BranchInfo,
+  CiInfo,
+  CiState,
  CommitInfo,
  ConnectionCheck,
  GitClient,
@@ -10,7 +12,9 @@ import type {
  RepoRef,
  RepoSnapshotData,
  TagInfo,
+  TicketInfo,
 } from "./types";
+import { bucketCommitActivity } from "./types";

 /**
 * Gitea (und kompatible Forks wie Forgejo) – API v1.
@@ -95,13 +99,32 @@ export class GiteaClient implements GitClient {

    const repo = await getJson<GiteaRepo>(base, { headers });

-    const [branches, tags, commits, releases, languages, pulls] = await Promise.all([
+    const defaultBranch = repo.default_branch ?? "";
+
+    const [branches, tags, commits, releases, languages, pulls, issues, status] =
+      await Promise.all([
        getJsonSafe<GiteaBranch[]>(`${base}/branches?limit=50`, [], { headers }),
        getJsonSafe<GiteaTag[]>(`${base}/tags?limit=25`, [], { headers }),
-      getJsonSafe<GiteaCommit[]>(`${base}/commits?limit=15&stat=false`, [], { headers }),
+        // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+        getJsonSafe<GiteaCommit[]>(`${base}/commits?limit=100&stat=false`, [], { headers }),
        getJsonSafe<GiteaRelease[]>(`${base}/releases?limit=10`, [], { headers }),
        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
-      getJsonSafe<GiteaPull[]>(`${base}/pulls?state=open&limit=100`, [], { headers }),
+        getJsonSafe<GiteaPull[]>(`${base}/pulls?state=open&limit=50`, [], { headers }),
+        // type=issues, sonst kommen bei Gitea die Pull Requests mit.
+        getJsonSafe<GiteaIssue[]>(`${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>(
+              `${base}/commits/${encodeURIComponent(defaultBranch)}/status`,
+              {} as GiteaCombinedStatus,
+              { headers },
+            )
+          : Promise.resolve({} as GiteaCombinedStatus),
      ]);

    const mappedBranches: BranchInfo[] = branches.map((branch) => ({
@@ -141,6 +164,38 @@ export class GiteaClient implements GitClient {
      draft: Boolean(release.draft),
    }));

+    const mappedPulls: TicketInfo[] = pulls.map((pull) => ({
+      number: pull.number,
+      title: pull.title,
+      author: pull.user?.login ?? null,
+      createdAt: toIso(pull.created_at),
+      url: pull.html_url ?? null,
+      draft: Boolean(pull.draft),
+      labels: (pull.labels ?? []).map((label) => label.name),
+    }));
+
+    const mappedIssues: TicketInfo[] = issues.map((issue) => ({
+      number: issue.number,
+      title: issue.title,
+      author: issue.user?.login ?? null,
+      createdAt: toIso(issue.created_at),
+      url: issue.html_url ?? null,
+      draft: false,
+      labels: (issue.labels ?? []).map((label) => label.name),
+    }));
+
+    const latestStatus = status?.statuses?.[0];
+    const ci: CiInfo | null =
+      status?.state && status.state !== "" && status.statuses?.length
+        ? {
+            state: mapCommitStatus(status.state),
+            name: latestStatus?.context ?? null,
+            branch: defaultBranch || null,
+            url: latestStatus?.target_url ?? null,
+            finishedAt: toIso(latestStatus?.updated_at),
+          }
+        : null;
+
    return {
      fullName: repo.full_name,
      description: repo.description ?? null,
@@ -155,13 +210,31 @@ export class GiteaClient implements GitClient {
      pushedAt: toIso(repo.updated_at),
      branches: mappedBranches,
      tags: mappedTags,
-      commits: mappedCommits,
+      commits: mappedCommits.slice(0, 15),
      releases: mappedReleases,
      languages: languages ?? {},
+      pullRequests: mappedPulls,
+      issues: mappedIssues,
+      ci,
+      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
    };
  }
 }

+function mapCommitStatus(state: string): CiState {
+  switch (state) {
+    case "success":
+      return "success";
+    case "pending":
+      return "running";
+    case "failure":
+    case "error":
+      return "failure";
+    default:
+      return "pending";
+  }
+}
+
 // ── API-Typen ──────────────────────────────────────────────────

 interface GiteaRepo {
@@ -220,6 +293,34 @@ interface GiteaRelease {
  draft: boolean;
 }

+interface GiteaLabel {
+  name: string;
+}
+
 interface GiteaPull {
-  id: number;
+  number: number;
+  title: string;
+  html_url: string | null;
+  created_at: string | null;
+  draft?: boolean;
+  user?: { login: string } | null;
+  labels?: GiteaLabel[];
+}
+
+interface GiteaIssue {
+  number: number;
+  title: string;
+  html_url: string | null;
+  created_at: string | null;
+  user?: { login: string } | null;
+  labels?: GiteaLabel[];
+}
+
+interface GiteaCombinedStatus {
+  state?: string;
+  statuses?: Array<{
+    context?: string;
+    target_url?: string;
+    updated_at?: string;
+  }>;
 }
@@ -1,6 +1,8 @@
 import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
 import type {
  BranchInfo,
+  CiInfo,
+  CiState,
  CommitInfo,
  ConnectionCheck,
  GitClient,
@@ -10,8 +12,9 @@ import type {
  RepoRef,
  RepoSnapshotData,
  TagInfo,
+  TicketInfo,
 } from "./types";
-import { GitApiError } from "./types";
+import { GitApiError, bucketCommitActivity } from "./types";

 /**
 * GitHub – funktioniert mit github.com und GitHub Enterprise.
@@ -85,13 +88,24 @@ export class GitHubClient implements GitClient {

    const repo = await getJson<GitHubRepo>(base, { headers });

-    const [branches, tags, commits, releases, languages, pulls] = await Promise.all([
+    const defaultBranch = repo.default_branch;
+
+    const [branches, tags, commits, releases, languages, pulls, issues, ciRuns] =
+      await Promise.all([
        getJsonSafe<GitHubBranch[]>(`${base}/branches?per_page=50`, [], { headers }),
        getJsonSafe<GitHubTag[]>(`${base}/tags?per_page=25`, [], { headers }),
-      getJsonSafe<GitHubCommit[]>(`${base}/commits?per_page=15`, [], { headers }),
+        // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+        getJsonSafe<GitHubCommit[]>(`${base}/commits?per_page=100`, [], { headers }),
        getJsonSafe<GitHubRelease[]>(`${base}/releases?per_page=10`, [], { headers }),
        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
-      getJsonSafe<GitHubPull[]>(`${base}/pulls?state=open&per_page=100`, [], { headers }),
+        getJsonSafe<GitHubPull[]>(`${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 }),
+        getJsonSafe<{ workflow_runs?: GitHubRun[] }>(
+          `${base}/actions/runs?per_page=1&branch=${encodeURIComponent(defaultBranch)}`,
+          {},
+          { headers },
+        ),
      ]);

    const mappedBranches: BranchInfo[] = branches.map((branch) => ({
@@ -131,10 +145,43 @@ export class GitHubClient implements GitClient {
      draft: Boolean(release.draft),
    }));

+    const mappedPulls: TicketInfo[] = pulls.map((pull) => ({
+      number: pull.number,
+      title: pull.title,
+      author: pull.user?.login ?? null,
+      createdAt: toIso(pull.created_at),
+      url: pull.html_url ?? null,
+      draft: Boolean(pull.draft),
+      labels: (pull.labels ?? []).map((label) => label.name),
+    }));
+
+    const mappedIssues: TicketInfo[] = issues
+      .filter((issue) => !issue.pull_request)
+      .map((issue) => ({
+        number: issue.number,
+        title: issue.title,
+        author: issue.user?.login ?? null,
+        createdAt: toIso(issue.created_at),
+        url: issue.html_url ?? null,
+        draft: false,
+        labels: (issue.labels ?? []).map((label) => label.name),
+      }));
+
    // 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 run = ciRuns?.workflow_runs?.[0];
+    const ci: CiInfo | null = run
+      ? {
+          state: mapRunState(run.status, run.conclusion),
+          name: run.name ?? null,
+          branch: run.head_branch ?? null,
+          url: run.html_url ?? null,
+          finishedAt: toIso(run.updated_at),
+        }
+      : null;
+
    return {
      fullName: repo.full_name,
      description: repo.description ?? null,
@@ -149,13 +196,36 @@ export class GitHubClient implements GitClient {
      pushedAt: toIso(repo.pushed_at),
      branches: mappedBranches,
      tags: mappedTags,
-      commits: mappedCommits,
+      // Angezeigt werden die letzten 15; die uebrigen dienten der Kurve.
+      commits: mappedCommits.slice(0, 15),
      releases: mappedReleases,
      languages: languages ?? {},
+      pullRequests: mappedPulls,
+      issues: mappedIssues,
+      ci,
+      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
    };
  }
 }

+/** GitHub trennt Lauf-Status und Ergebnis; hier auf einen Wert zusammenfuehren. */
+function mapRunState(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":
+      return "success";
+    case "cancelled":
+      return "cancelled";
+    case "failure":
+    case "timed_out":
+    case "startup_failure":
+      return "failure";
+    default:
+      return conclusion ? "failure" : "pending";
+  }
+}
+
 // ── API-Typen (nur die tatsaechlich genutzten Felder) ──────────

 interface GitHubRepo {
@@ -206,6 +276,36 @@ interface GitHubRelease {
  draft: boolean;
 }

+interface GitHubLabel {
+  name: string;
+}
+
 interface GitHubPull {
-  id: number;
+  number: number;
+  title: string;
+  html_url: string | null;
+  created_at: string | null;
+  draft?: boolean;
+  user?: { login: string } | null;
+  labels?: GitHubLabel[];
+}
+
+interface GitHubIssue {
+  number: number;
+  title: string;
+  html_url: string | null;
+  created_at: string | null;
+  user?: { login: string } | null;
+  labels?: GitHubLabel[];
+  /** Gesetzt, wenn der Eintrag in Wahrheit ein Pull Request ist. */
+  pull_request?: unknown;
+}
+
+interface GitHubRun {
+  name: string | null;
+  status: string | null;
+  conclusion: string | null;
+  head_branch: string | null;
+  html_url: string | null;
+  updated_at: string | null;
 }
@@ -1,6 +1,8 @@
 import { getJson, getJsonSafe, normalizeBaseUrl, shortSha, toIso } from "./http";
 import type {
  BranchInfo,
+  CiInfo,
+  CiState,
  CommitInfo,
  ConnectionCheck,
  GitClient,
@@ -10,7 +12,9 @@ import type {
  RepoRef,
  RepoSnapshotData,
  TagInfo,
+  TicketInfo,
 } from "./types";
+import { bucketCommitActivity } from "./types";

 /**
 * GitLab – gitlab.com und selbst gehostete Instanzen (API v4).
@@ -80,15 +84,25 @@ export class GitLabClient implements GitClient {

    const project = await getJson<GitLabProject>(`${base}?statistics=true`, { headers });

-    const [branches, tags, commits, releases, languages, mergeRequests] = await Promise.all([
+    const defaultBranch = project.default_branch ?? "";
+
+    const [branches, tags, commits, releases, languages, mergeRequests, issues, pipelines] =
+      await Promise.all([
        getJsonSafe<GitLabBranch[]>(`${base}/repository/branches?per_page=50`, [], { headers }),
        getJsonSafe<GitLabTag[]>(`${base}/repository/tags?per_page=25`, [], { headers }),
-      getJsonSafe<GitLabCommit[]>(`${base}/repository/commits?per_page=15`, [], { headers }),
+        // 100 statt 15: die aelteren brauchen wir fuer die Aktivitaetskurve.
+        getJsonSafe<GitLabCommit[]>(`${base}/repository/commits?per_page=100`, [], { headers }),
        getJsonSafe<GitLabRelease[]>(`${base}/releases?per_page=10`, [], { headers }),
        getJsonSafe<Record<string, number>>(`${base}/languages`, {}, { headers }),
-      getJsonSafe<GitLabMergeRequest[]>(`${base}/merge_requests?state=opened&per_page=100`, [], {
+        getJsonSafe<GitLabMergeRequest[]>(`${base}/merge_requests?state=opened&per_page=50`, [], {
          headers,
        }),
+        getJsonSafe<GitLabIssue[]>(`${base}/issues?state=opened&per_page=50`, [], { headers }),
+        getJsonSafe<GitLabPipeline[]>(
+          `${base}/pipelines?per_page=1${defaultBranch ? `&ref=${encodeURIComponent(defaultBranch)}` : ""}`,
+          [],
+          { headers },
+        ),
      ]);

    const mappedBranches: BranchInfo[] = branches.map((branch) => ({
@@ -128,6 +142,37 @@ export class GitLabClient implements GitClient {
      draft: false,
    }));

+    const mappedMergeRequests: TicketInfo[] = mergeRequests.map((entry) => ({
+      number: entry.iid,
+      title: entry.title,
+      author: entry.author?.username ?? null,
+      createdAt: toIso(entry.created_at),
+      url: entry.web_url ?? null,
+      draft: Boolean(entry.draft),
+      labels: entry.labels ?? [],
+    }));
+
+    const mappedIssues: TicketInfo[] = issues.map((entry) => ({
+      number: entry.iid,
+      title: entry.title,
+      author: entry.author?.username ?? null,
+      createdAt: toIso(entry.created_at),
+      url: entry.web_url ?? null,
+      draft: false,
+      labels: entry.labels ?? [],
+    }));
+
+    const pipeline = pipelines[0];
+    const ci: CiInfo | null = pipeline
+      ? {
+          state: mapPipelineState(pipeline.status),
+          name: pipeline.name ?? `Pipeline #${pipeline.id}`,
+          branch: pipeline.ref ?? null,
+          url: pipeline.web_url ?? null,
+          finishedAt: toIso(pipeline.updated_at),
+        }
+      : null;
+
    return {
      fullName: project.path_with_namespace,
      description: project.description ?? null,
@@ -144,13 +189,33 @@ export class GitLabClient implements GitClient {
      pushedAt: toIso(project.last_activity_at),
      branches: mappedBranches,
      tags: mappedTags,
-      commits: mappedCommits,
+      commits: mappedCommits.slice(0, 15),
      releases: mappedReleases,
      languages: languages ?? {},
+      pullRequests: mappedMergeRequests,
+      issues: mappedIssues,
+      ci,
+      commitActivity: bucketCommitActivity(mappedCommits.map((commit) => commit.date)),
    };
  }
 }

+function mapPipelineState(status: string | null): CiState {
+  switch (status) {
+    case "success":
+      return "success";
+    case "running":
+      return "running";
+    case "failed":
+      return "failure";
+    case "canceled":
+    case "skipped":
+      return "cancelled";
+    default:
+      return "pending";
+  }
+}
+
 // ── API-Typen ──────────────────────────────────────────────────

 interface GitLabProject {
@@ -205,5 +270,29 @@ interface GitLabRelease {
 }

 interface GitLabMergeRequest {
+  iid: number;
+  title: string;
+  created_at: string | null;
+  web_url: string | null;
+  draft?: boolean;
+  labels?: string[];
+  author?: { username: string } | null;
+}
+
+interface GitLabIssue {
+  iid: number;
+  title: string;
+  created_at: string | null;
+  web_url: string | null;
+  labels?: string[];
+  author?: { username: string } | null;
+}
+
+interface GitLabPipeline {
  id: number;
+  name?: string | null;
+  status: string | null;
+  ref: string | null;
+  web_url: string | null;
+  updated_at: string | null;
 }
@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import { guessProvider } from "./meta";
+import { parseRepoUrl } from "./index";
+import { ACTIVITY_DAYS, bucketCommitActivity } from "./types";
+
+describe("parseRepoUrl", () => {
+  it("zerlegt eine gewoehnliche https-URL", () => {
+    expect(parseRepoUrl("https://github.com/vercel/swr")).toMatchObject({
+      host: "github.com",
+      owner: "vercel",
+      name: "swr",
+      guessedProvider: "GITHUB",
+    });
+  });
+
+  it("entfernt die Endung .git", () => {
+    expect(parseRepoUrl("https://github.com/vercel/swr.git")?.name).toBe("swr");
+  });
+
+  it("versteht SSH-Adressen", () => {
+    expect(parseRepoUrl("git@gitlab.com:gruppe/projekt.git")).toMatchObject({
+      host: "gitlab.com",
+      owner: "gruppe",
+      name: "projekt",
+      guessedProvider: "GITLAB",
+    });
+  });
+
+  it("behaelt verschachtelte GitLab-Gruppen", () => {
+    expect(parseRepoUrl("https://gitlab.com/gruppe/untergruppe/projekt")).toMatchObject({
+      owner: "gruppe/untergruppe",
+      name: "projekt",
+    });
+  });
+
+  it("schneidet GitLab-Oberflaechenpfade ab dem /-/ ab", () => {
+    expect(parseRepoUrl("https://gitlab.com/gruppe/projekt/-/tree/main")).toMatchObject({
+      owner: "gruppe",
+      name: "projekt",
+    });
+  });
+
+  it("kommt mit einer eigenen Gitea-Instanz zurecht", () => {
+    expect(parseRepoUrl("https://git.meine-firma.de/team/repo")).toMatchObject({
+      baseUrl: "https://git.meine-firma.de",
+      owner: "team",
+      name: "repo",
+      guessedProvider: "GITEA",
+    });
+  });
+
+  it("gibt null zurueck, wenn kein Repository erkennbar ist", () => {
+    expect(parseRepoUrl("https://github.com/nurbenutzer")).toBeNull();
+    expect(parseRepoUrl("")).toBeNull();
+    expect(parseRepoUrl("kein-url-artiger-text")).toBeNull();
+  });
+});
+
+describe("guessProvider", () => {
+  it("erkennt die grossen beiden am Hostnamen", () => {
+    expect(guessProvider("github.com")).toBe("GITHUB");
+    expect(guessProvider("gitlab.example.org")).toBe("GITLAB");
+  });
+
+  it("nimmt bei allem anderen Gitea an", () => {
+    expect(guessProvider("git.meine-firma.de")).toBe("GITEA");
+  });
+});
+
+describe("bucketCommitActivity", () => {
+  const dayMs = 24 * 60 * 60 * 1000;
+  const daysAgo = (days: number) => new Date(Date.now() - days * dayMs).toISOString();
+
+  it("liefert ohne Commits den vollen Zeitraum", () => {
+    expect(bucketCommitActivity([])).toHaveLength(ACTIVITY_DAYS);
+  });
+
+  it("sortiert den juengsten Commit ans Ende", () => {
+    const buckets = bucketCommitActivity([daysAgo(29), daysAgo(0)]);
+    expect(buckets).toHaveLength(ACTIVITY_DAYS);
+    expect(buckets[ACTIVITY_DAYS - 1]).toBe(1);
+  });
+
+  it("zaehlt mehrere Commits desselben Tages zusammen", () => {
+    const buckets = bucketCommitActivity([daysAgo(29), daysAgo(2), daysAgo(2), daysAgo(2)]);
+    expect(buckets[buckets.length - 3]).toBe(3);
+  });
+
+  it("kuerzt auf den belegten Zeitraum, statt Unbekanntes als Null zu zeigen", () => {
+    // Reicht die geholte Historie nur fuenf Tage zurueck, duerfen die
+    // 25 Tage davor nicht als "keine Commits" erscheinen.
+    const buckets = bucketCommitActivity([daysAgo(4), daysAgo(0)]);
+    expect(buckets).toHaveLength(5);
+    expect(buckets[0]).toBe(1);
+    expect(buckets[4]).toBe(1);
+  });
+
+  it("ignoriert unlesbare Werte", () => {
+    const buckets = bucketCommitActivity([null, "voelliger Unsinn"]);
+    expect(buckets).toHaveLength(ACTIVITY_DAYS);
+    expect(buckets.every((value) => value === 0)).toBe(true);
+  });
+
+  it("laesst aeltere Commits den vollen Zeitraum aufspannen", () => {
+    const buckets = bucketCommitActivity([daysAgo(100), daysAgo(1)]);
+    expect(buckets).toHaveLength(ACTIVITY_DAYS);
+    expect(buckets[ACTIVITY_DAYS - 2]).toBe(1);
+  });
+});
@@ -47,6 +47,29 @@ export interface ReleaseInfo {
  draft: boolean;
 }

+/** Ein offener Pull Request, Merge Request oder ein Issue. */
+export interface TicketInfo {
+  number: number;
+  title: string;
+  author: string | null;
+  createdAt: string | null;
+  url: string | null;
+  draft: boolean;
+  labels: string[];
+}
+
+/** Ergebnis des letzten CI-Laufs auf dem Default-Branch. */
+export type CiState = "success" | "failure" | "running" | "pending" | "cancelled";
+
+export interface CiInfo {
+  state: CiState;
+  /** Name des Workflows bzw. der Pipeline, falls die API ihn liefert. */
+  name: string | null;
+  branch: string | null;
+  url: string | null;
+  finishedAt: string | null;
+}
+
 export interface RepoOverview {
  fullName: string;
  description: string | null;
@@ -67,6 +90,53 @@ export interface RepoSnapshotData extends RepoOverview {
  commits: CommitInfo[];
  releases: ReleaseInfo[];
  languages: Record<string, number>;
+  pullRequests: TicketInfo[];
+  issues: TicketInfo[];
+  ci: CiInfo | null;
+  /** Commits je Tag der letzten 30 Tage, aeltester zuerst. */
+  commitActivity: number[];
+}
+
+/** Tage, ueber die die Commit-Aktivitaet gebildet wird. */
+export const ACTIVITY_DAYS = 30;
+
+/**
+ * Verteilt Commit-Zeitpunkte auf Tagesbuckets. Bewusst aus den ohnehin
+ * geholten Commits berechnet statt ueber eigene Statistik-Endpunkte: die
+ * gibt es nicht bei allen drei Systemen, und bei GitHub antworten sie beim
+ * ersten Aufruf mit 202 und ohne Daten.
+ *
+ * Wichtig fuer die Ehrlichkeit der Kurve: geholt wird nur eine Seite
+ * Commits. Liegt der aelteste davon noch innerhalb des Zeitraums, wissen wir
+ * ueber die Tage davor schlicht nichts – dort eine Null zu zeichnen waere
+ * falsch. Deshalb wird die Kurve auf den tatsaechlich belegten Zeitraum
+ * gekuerzt.
+ */
+export function bucketCommitActivity(dates: Array<string | null>): number[] {
+  const buckets = new Array<number>(ACTIVITY_DAYS).fill(0);
+  const now = Date.now();
+  const dayMs = 24 * 60 * 60 * 1000;
+
+  let oldestDaysAgo = -1;
+
+  for (const value of dates) {
+    if (!value) continue;
+    const time = Date.parse(value);
+    if (Number.isNaN(time)) continue;
+    const daysAgo = Math.floor((now - time) / dayMs);
+    if (daysAgo < 0) continue;
+    if (daysAgo > oldestDaysAgo) oldestDaysAgo = daysAgo;
+    if (daysAgo >= ACTIVITY_DAYS) continue;
+    buckets[ACTIVITY_DAYS - 1 - daysAgo] += 1;
+  }
+
+  // Reicht die Historie nicht bis an den Rand des Zeitraums, nur den
+  // belegten Ausschnitt zurueckgeben.
+  if (oldestDaysAgo >= 0 && oldestDaysAgo < ACTIVITY_DAYS - 1) {
+    return buckets.slice(ACTIVITY_DAYS - 1 - oldestDaysAgo);
+  }
+
+  return buckets;
 }

 export interface RepoListItem {
@@ -49,7 +49,10 @@ export const connectionSafeSelect = Prisma.validator<Prisma.GitConnectionSelect>
 export const projectListInclude = Prisma.validator<Prisma.ProjectInclude>()({
  connection: { select: connectionSafeSelect },
  snapshot: true,
-  _count: { select: { notes: true } },
+  _count: { select: { notes: true, tasks: true } },
+  // Nur die offenen Aufgaben zaehlen – fuer die Anzeige "3 von 8" auf der
+  // Karte, ohne die Aufgaben selbst mitzuladen.
+  tasks: { where: { status: "DONE" }, select: { id: true } },
 });

 export const projectDetailInclude = Prisma.validator<Prisma.ProjectInclude>()({
@@ -58,5 +61,8 @@ export const projectDetailInclude = Prisma.validator<Prisma.ProjectInclude>()({
  notes: {
    orderBy: [{ pinned: "desc" }, { updatedAt: "desc" }],
  },
-  _count: { select: { notes: true } },
+  tasks: {
+    orderBy: [{ status: "asc" }, { position: "asc" }],
+  },
+  _count: { select: { notes: true, tasks: true } },
 });
@@ -0,0 +1,101 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { BlockedHostError, assertAllowedUrl } from "./ssrf";
+
+/**
+ * Geprueft werden IP-Literale und die Formpruefung – beides kommt ohne
+ * Netzzugriff aus. Die Namensaufloesung deckt der Durchlauf gegen echte
+ * Instanzen ab.
+ */
+
+afterEach(() => {
+  delete process.env.GIT_ALLOW_LOOPBACK;
+  delete process.env.GIT_BLOCK_PRIVATE;
+  delete process.env.GIT_ALLOWED_HOSTS;
+});
+
+async function blockedReason(url: string): Promise<string> {
+  try {
+    await assertAllowedUrl(url);
+    return "NICHT BLOCKIERT";
+  } catch (error) {
+    if (error instanceof BlockedHostError) return error.message;
+    throw error;
+  }
+}
+
+describe("assertAllowedUrl – gesperrte Ziele", () => {
+  it("blockt Loopback in IPv4 und IPv6", async () => {
+    expect(await blockedReason("http://127.0.0.1:5432")).toMatch(/Loopback/);
+    expect(await blockedReason("http://[::1]:3000")).toMatch(/Loopback|aufgeloest/);
+  });
+
+  it("blockt den Metadaten-Endpunkt der Cloud-Anbieter", async () => {
+    expect(await blockedReason("http://169.254.169.254/latest/meta-data/")).toMatch(
+      /Link-Local|Metadaten/,
+    );
+  });
+
+  it("blockt die unspezifizierte Adresse", async () => {
+    expect(await blockedReason("http://0.0.0.0")).toMatch(/unspezifiziert/);
+  });
+
+  it("blockt Carrier-Grade-NAT und Multicast", async () => {
+    expect(await blockedReason("http://100.64.0.1")).toMatch(/Carrier/);
+    expect(await blockedReason("http://239.0.0.1")).toMatch(/Multicast|reserviert/);
+  });
+
+  it("blockt IPv4-gemappte IPv6-Adressen auf Loopback", async () => {
+    expect(await blockedReason("http://[::ffff:127.0.0.1]")).toMatch(/Loopback|aufgeloest/);
+  });
+});
+
+describe("assertAllowedUrl – Formpruefung", () => {
+  it("laesst nur http und https zu", async () => {
+    expect(await blockedReason("file:///etc/passwd")).toMatch(/Nur http/);
+    expect(await blockedReason("gopher://example.com")).toMatch(/Nur http/);
+  });
+
+  it("weist Zugangsdaten in der URL ab", async () => {
+    expect(await blockedReason("https://nutzer:geheim@8.8.8.8")).toMatch(/Zugangsdaten/);
+  });
+
+  it("weist unlesbare URLs ab", async () => {
+    expect(await blockedReason("kein-url-artiger-text")).toMatch(/Ungueltige URL/);
+  });
+});
+
+describe("assertAllowedUrl – erlaubte Ziele", () => {
+  it("laesst oeffentliche Adressen durch", async () => {
+    await expect(assertAllowedUrl("https://140.82.121.4")).resolves.toBeInstanceOf(URL);
+  });
+
+  it("laesst das private LAN standardmaessig zu", async () => {
+    await expect(assertAllowedUrl("http://192.168.1.10:3000")).resolves.toBeInstanceOf(URL);
+    await expect(assertAllowedUrl("http://10.0.0.5")).resolves.toBeInstanceOf(URL);
+    await expect(assertAllowedUrl("http://172.16.0.1")).resolves.toBeInstanceOf(URL);
+  });
+});
+
+describe("assertAllowedUrl – Schalter", () => {
+  it("GIT_ALLOW_LOOPBACK gibt Loopback frei", async () => {
+    process.env.GIT_ALLOW_LOOPBACK = "true";
+    await expect(assertAllowedUrl("http://127.0.0.1:3000")).resolves.toBeInstanceOf(URL);
+  });
+
+  it("GIT_BLOCK_PRIVATE sperrt das private Netz", async () => {
+    process.env.GIT_BLOCK_PRIVATE = "true";
+    expect(await blockedReason("http://192.168.1.10")).toMatch(/privates Netz/);
+  });
+
+  it("GIT_ALLOWED_HOSTS laesst ausschliesslich die genannten Hosts zu", async () => {
+    process.env.GIT_ALLOWED_HOSTS = "github.com";
+    await expect(assertAllowedUrl("https://github.com/x/y")).resolves.toBeInstanceOf(URL);
+    expect(await blockedReason("https://gitlab.com/x/y")).toMatch(/GIT_ALLOWED_HOSTS/);
+  });
+
+  it("eine ausdrueckliche Freigabe schlaegt die Bereichspruefung", async () => {
+    // Damit laesst sich eine Gitea auf demselben Rechner gezielt erlauben.
+    process.env.GIT_ALLOWED_HOSTS = "127.0.0.1";
+    await expect(assertAllowedUrl("http://127.0.0.1:3000")).resolves.toBeInstanceOf(URL);
+  });
+});
@@ -117,6 +117,14 @@ async function persistSnapshot(projectId: string, data: RepoSnapshotData) {
    commits: data.commits as unknown as object,
    releases: data.releases as unknown as object,
    languages: data.languages as unknown as object,
+    pullRequests: data.pullRequests as unknown as object,
+    issues: data.issues as unknown as object,
+    commitActivity: data.commitActivity as unknown as object,
+    ciState: data.ci?.state ?? null,
+    ciName: data.ci?.name ?? null,
+    ciBranch: data.ci?.branch ?? null,
+    ciUrl: data.ci?.url ?? null,
+    ciFinishedAt: data.ci?.finishedAt ? new Date(data.ci.finishedAt) : null,
    pushedAt: data.pushedAt ? new Date(data.pushedAt) : null,
    fetchedAt: new Date(),
  };
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { TASK_STATUS_META, TASK_STATUS_ORDER, progressFromTasks } from "./tasks";
+
+describe("progressFromTasks", () => {
+  it("rechnet den Anteil erledigter Aufgaben in Prozent um", () => {
+    expect(progressFromTasks(4, 1)).toBe(25);
+    expect(progressFromTasks(8, 3)).toBe(38);
+    expect(progressFromTasks(3, 3)).toBe(100);
+    expect(progressFromTasks(5, 0)).toBe(0);
+  });
+
+  it("gibt null zurueck, wenn es nichts zu rechnen gibt", () => {
+    // Ohne Aufgaben bleibt der von Hand gesetzte Wert stehen.
+    expect(progressFromTasks(0, 0)).toBeNull();
+    expect(progressFromTasks(-1, 0)).toBeNull();
+  });
+
+  it("rundet kaufmaennisch statt abzuschneiden", () => {
+    // 1/3 sind 33,33 % und 2/3 sind 66,67 %.
+    expect(progressFromTasks(3, 1)).toBe(33);
+    expect(progressFromTasks(3, 2)).toBe(67);
+  });
+});
+
+describe("Spaltenreihenfolge", () => {
+  it("fuehrt von offen nach erledigt", () => {
+    expect(TASK_STATUS_ORDER).toEqual(["TODO", "DOING", "BLOCKED", "DONE"]);
+  });
+
+  it("hat zu jeder Spalte eine Beschriftung und eine Farbe", () => {
+    for (const status of TASK_STATUS_ORDER) {
+      expect(TASK_STATUS_META[status].label).toBeTruthy();
+      expect(TASK_STATUS_META[status].color).toMatch(/^#[0-9a-f]{6}$/i);
+    }
+  });
+});
@@ -0,0 +1,86 @@
+import type { TaskStatus } from "@prisma/client";
+import { prisma } from "@/lib/db";
+
+/** Spaltenreihenfolge des Aufgabenbretts. */
+export const TASK_STATUS_ORDER: TaskStatus[] = ["TODO", "DOING", "BLOCKED", "DONE"];
+
+export const TASK_STATUS_META: Record<
+  TaskStatus,
+  { label: string; color: string; className: string }
+> = {
+  TODO: {
+    label: "Offen",
+    color: "#94a3b8",
+    className: "bg-slate-500/12 text-slate-300 ring-slate-400/25",
+  },
+  DOING: {
+    label: "In Arbeit",
+    color: "#a78bfa",
+    className: "bg-violet-500/12 text-violet-200 ring-violet-400/30",
+  },
+  BLOCKED: {
+    label: "Blockiert",
+    color: "#fb7185",
+    className: "bg-rose-500/12 text-rose-200 ring-rose-400/30",
+  },
+  DONE: {
+    label: "Erledigt",
+    color: "#34d399",
+    className: "bg-emerald-500/12 text-emerald-200 ring-emerald-400/30",
+  },
+};
+
+/**
+ * Berechnet den Fortschritt aus dem Verhaeltnis erledigter Aufgaben.
+ * Ohne Aufgaben gibt es nichts zu berechnen – dann bleibt der Wert, wie er ist.
+ */
+export function progressFromTasks(total: number, done: number): number | null {
+  if (total <= 0) return null;
+  return Math.round((done / total) * 100);
+}
+
+/**
+ * Schreibt den abgeleiteten Fortschritt, falls das Projekt es so eingestellt
+ * hat. Wird nach jeder Aenderung an Aufgaben aufgerufen.
+ */
+export async function refreshDerivedProgress(projectId: string): Promise<void> {
+  const project = await prisma.project.findUnique({
+    where: { id: projectId },
+    select: { progressFromTasks: true },
+  });
+  if (!project?.progressFromTasks) return;
+
+  const [total, done] = await Promise.all([
+    prisma.task.count({ where: { projectId } }),
+    prisma.task.count({ where: { projectId, status: "DONE" } }),
+  ]);
+
+  const value = progressFromTasks(total, done);
+  if (value === null) return;
+
+  await prisma.project.update({
+    where: { id: projectId },
+    data: { progress: value },
+  });
+}
+
+/** Naechste freie Position am Ende einer Spalte. */
+export async function nextPosition(
+  projectId: string,
+  status: TaskStatus,
+): Promise<number> {
+  const last = await prisma.task.findFirst({
+    where: { projectId, status },
+    orderBy: { position: "desc" },
+    select: { position: true },
+  });
+  return (last?.position ?? -1) + 1;
+}
+
+/** Prueft Existenz und Besitz in einem Zug. */
+export async function ownedProject(projectId: string, ownerId: string) {
+  return prisma.project.findFirst({
+    where: { id: projectId, ownerId },
+    select: { id: true },
+  });
+}
@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { formatNumber, parseTags, slugify, truncate } from "./utils";
+
+describe("slugify", () => {
+  it("macht aus einem Namen einen URL-tauglichen Slug", () => {
+    expect(slugify("Mein Projekt")).toBe("mein-projekt");
+  });
+
+  it("schreibt deutsche Umlaute aus", () => {
+    expect(slugify("Grün & Größe")).toBe("gruen-groesse");
+    expect(slugify("Straße")).toBe("strasse");
+  });
+
+  it("entfernt fuehrende und abschliessende Trennzeichen", () => {
+    expect(slugify("  ...Hallo Welt!!! ")).toBe("hallo-welt");
+  });
+
+  it("faellt bei reinen Sonderzeichen auf einen leeren Slug zurueck", () => {
+    // Die Aufrufer ersetzen das durch "projekt".
+    expect(slugify("!!!")).toBe("");
+  });
+
+  it("begrenzt die Laenge", () => {
+    expect(slugify("a".repeat(200)).length).toBeLessThanOrEqual(60);
+  });
+});
+
+describe("parseTags", () => {
+  it("trennt an Kommas, trimmt und schreibt klein", () => {
+    expect(parseTags(" Next.js , PRISMA ,dashboard ")).toEqual([
+      "next.js",
+      "prisma",
+      "dashboard",
+    ]);
+  });
+
+  it("entfernt Dubletten und Leereintraege", () => {
+    expect(parseTags("a,,a, b ,A")).toEqual(["a", "b"]);
+  });
+
+  it("begrenzt auf zwoelf Tags", () => {
+    const many = Array.from({ length: 20 }, (_, index) => `tag${index}`).join(",");
+    expect(parseTags(many)).toHaveLength(12);
+  });
+});
+
+describe("truncate", () => {
+  it("laesst kurze Texte unveraendert", () => {
+    expect(truncate("kurz", 10)).toBe("kurz");
+  });
+
+  it("kuerzt und haengt ein Auslassungszeichen an", () => {
+    const result = truncate("abcdefghij", 5);
+    expect(result).toHaveLength(5);
+    expect(result.endsWith("…")).toBe(true);
+  });
+});
+
+describe("formatNumber", () => {
+  it("gruppiert nach deutscher Schreibweise", () => {
+    // Das Trennzeichen kann je nach ICU-Version variieren.
+    expect(formatNumber(32437)).toMatch(/^32.437$/);
+  });
+});
@@ -23,10 +23,47 @@ export const projectCreateSchema = z.object({
  connectionId: z.preprocess(emptyToNull, z.string().trim().nullable().optional()),
  /** Am automatischen Abgleich teilnehmen. */
  autoSync: z.boolean().default(true),
+  /** Fortschritt aus dem Verhaeltnis erledigter Aufgaben berechnen. */
+  progressFromTasks: z.boolean().default(false),
 });

 export const projectUpdateSchema = projectCreateSchema.partial();

+// ── Aufgaben ─────────────────────────────────────────────────
+
+const TASK_STATUS = ["TODO", "DOING", "BLOCKED", "DONE"] as const;
+
+const dueDateField = z.preprocess(
+  emptyToNull,
+  z
+    .string()
+    .trim()
+    .refine((value) => !Number.isNaN(Date.parse(value)), "Kein gueltiges Datum")
+    .nullable()
+    .optional(),
+);
+
+export const taskCreateSchema = z.object({
+  title: z.string().trim().min(1, "Titel darf nicht leer sein").max(200),
+  description: z.preprocess(emptyToNull, z.string().trim().max(5000).nullable().optional()),
+  status: z.enum(TASK_STATUS).default("TODO"),
+  dueDate: dueDateField,
+  labels: z.array(z.string().trim().min(1).max(30)).max(8).default([]),
+});
+
+export const taskUpdateSchema = taskCreateSchema.partial();
+
+/**
+ * Neue Reihenfolge nach dem Ziehen. Uebergeben wird je betroffener Spalte
+ * die vollstaendige Liste der Aufgaben in ihrer neuen Reihenfolge – daraus
+ * ergeben sich Status und Position eindeutig.
+ */
+export const taskReorderSchema = z.object({
+  columns: z
+    .record(z.enum(TASK_STATUS), z.array(z.string().min(1)).max(500))
+    .refine((value) => Object.keys(value).length > 0, "Keine Spalte angegeben"),
+});
+
 export const noteCreateSchema = z.object({
  title: z.preprocess(emptyToNull, z.string().trim().max(160).nullable().optional()),
  content: z.string().trim().min(1, "Notiz darf nicht leer sein").max(20000),
@@ -1,5 +1,20 @@
-import type { GitProvider, Note, Project, ProjectStatus, RepoSnapshot } from "@prisma/client";
-import type { BranchInfo, CommitInfo, ReleaseInfo, TagInfo } from "@/lib/git/types";
+import type {
+  GitProvider,
+  Note,
+  Project,
+  ProjectStatus,
+  RepoSnapshot,
+  Task,
+  TaskStatus,
+} from "@prisma/client";
+import type {
+  BranchInfo,
+  CiInfo,
+  CommitInfo,
+  ReleaseInfo,
+  TagInfo,
+  TicketInfo,
+} from "@/lib/git/types";

 /** Verbindung ohne Geheimnisse – so wird sie an den Browser gegeben. */
 export interface ConnectionSafe {
@@ -23,14 +38,17 @@ export interface ConnectionWithCount extends ConnectionSafe {
 export interface ProjectListItem extends Project {
  connection: ConnectionSafe | null;
  snapshot: RepoSnapshot | null;
-  _count: { notes: number };
+  _count: { notes: number; tasks: number };
+  /** Nur die erledigten – siehe projectListInclude. */
+  tasks: { id: string }[];
 }

 export interface ProjectDetail extends Project {
  connection: ConnectionSafe | null;
  snapshot: RepoSnapshot | null;
  notes: Note[];
-  _count: { notes: number };
+  tasks: Task[];
+  _count: { notes: number; tasks: number };
 }

 export interface RepoListEntry {
@@ -44,7 +62,19 @@ export interface RepoListEntry {
  updatedAt: string | null;
 }

-export type { BranchInfo, CommitInfo, Note, ProjectStatus, ReleaseInfo, RepoSnapshot, TagInfo };
+export type {
+  BranchInfo,
+  CiInfo,
+  CommitInfo,
+  Note,
+  ProjectStatus,
+  ReleaseInfo,
+  RepoSnapshot,
+  TagInfo,
+  Task,
+  TaskStatus,
+  TicketInfo,
+};

 /** Prisma liefert Json als unknown – hier bequem in Arrays zurueckholen. */
 export function asArray<T>(value: unknown): T[] {
@@ -0,0 +1,16 @@
+import { defineConfig } from "vitest/config";
+import { fileURLToPath } from "node:url";
+
+export default defineConfig({
+  test: {
+    // Reine Logik, kein DOM und keine Datenbank – die Tests laufen in
+    // Millisekunden und brauchen weder Server noch Container.
+    environment: "node",
+    include: ["src/**/*.test.ts"],
+  },
+  resolve: {
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url)),
+    },
+  },
+});
Author	SHA1	Message	Date
florian.wildeandClaude Opus 5	e40a3bd62e	fix: Warnung beim Einlesen der Versionsnummer beseitigen Der benannte Import aus der package.json loeste in Webpack die Warnung "Should not import the named export 'version'" aus. Jetzt als Standardimport. Version auf 0.5.0 gehoben. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 09:29:50 +02:00
florian.wildeandClaude Opus 5	79c4bd1967	feat(export): Aufgaben in Export, Import und Sicherung aufnehmen Aufgaben gehen mit - JSON-Export, Import und Instanz-Sicherung. Beim Import wird die Position aus der Datei uebernommen, notfalls die Reihenfolge in ihr. Wie bei den Notizen werden Aufgaben beim Ersetzen ausgetauscht statt zusammengefuehrt, damit ein erneuter Import keine Dubletten erzeugt. Der Markdown-Export bekommt einen Abschnitt "Aufgaben", nach Spalten gegliedert und als Checkliste geschrieben - so bleibt der Stand auch ausserhalb von Nebula lesbar. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 09:29:50 +02:00
florian.wildeandClaude Opus 5	0212dad2bf	feat(ui): Aufgabenbrett auf der Projektseite Vier Spalten, Karten per Ziehen verschiebbar - zwischen den Spalten und innerhalb einer Spalte. Waehrend des Ziehens fuehrt der oertliche Zustand, danach wird die neue Ordnung als Ganzes gespeichert; scheitert das, springt das Brett auf den Serverstand zurueck. Details: - Gezogen wird am Griff links, damit ein Klick auf die Karte weiter den Dialog oeffnet. - Der Spaltenwechsel passiert schon beim Darueberziehen, nicht erst beim Ablegen - sonst wirkt das Brett traege. - Der Serverstand wird nur uebernommen, wenn gerade nicht gezogen wird, sonst spraenge die Karte mitten in der Bewegung zurueck. - Faelligkeiten faerben sich: ueberfaellig rot, heute gelb, demnaechst gedaempft. Ist "Fortschritt aus Aufgaben" eingeschaltet, wird der Regler gesperrt statt einen Wert anzubieten, der beim naechsten Aufgabenwechsel ueberschrieben wuerde - im Dialog wie im Kopfbereich. Die Projektkarte zeigt das Verhaeltnis als "3/8". Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 09:29:28 +02:00
florian.wildeandClaude Opus 5	72bcf824ce	feat(tasks): Aufgaben je Projekt mit Spalten und Reihenfolge Neues Modell Task: Titel, optionale Beschreibung, Spalte, Position, Faelligkeit und Labels. Vier Spalten - offen, in Arbeit, blockiert, erledigt. Anders als beim Projektbrett ist die Reihenfolge innerhalb einer Spalte hier bedeutsam und wird deshalb gespeichert. Der Reorder-Endpunkt nimmt je Spalte die vollstaendige Liste in ihrer neuen Reihenfolge entgegen und leitet Status und Position daraus ab. Das ist wiederholbar, kommt ohne Positionsrechnerei im Browser aus, und ein verlorener Aufruf laesst sich einfach erneut senden. Sicherheitsrelevant: der Endpunkt bekommt IDs aus dem Browser. Er aktualisiert ausschliesslich Aufgaben, die wirklich zu diesem Projekt gehoeren, und meldet uebergangene IDs zurueck - sonst liessen sich fremde Aufgaben ueber untergeschobene IDs verschieben. doneAt wird nur beim tatsaechlichen Wechsel nach "erledigt" gesetzt und beim Zurueckziehen geleert. Ein Umsortieren innerhalb der Spalte laesst das Datum in Ruhe. Der Fortschritt eines Projekts laesst sich wahlweise aus dem Anteil erledigter Aufgaben ableiten. Er wird nach jeder Aenderung neu berechnet und auch sofort beim Einschalten. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 09:29:28 +02:00
florian.wildeandClaude Opus 5	298da72b6d	docs: v0.3.0 und v0.4.0 dokumentieren, Roadmap fortschreiben FEATURES beschreibt Markdown, Volltextsuche, PR- und Issue-Listen, den CI-Status samt Herkunft je Git-System, die Aktivitaetskurve inklusive ihrer Grenze, das Kanban-Board und das Testfundament. ROADMAP: sieben Punkte wandern zu den erledigten. Ganz oben steht jetzt der Ausbau der Tests auf Datenbank und Browser - das Fundament steht, die Schicht darueber fehlt und ich pruefe weiterhin von Hand. Danach Benachrichtigungen, die von CI-Status und Abgleich nun profitieren wuerden. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:04:42 +02:00
florian.wildeandClaude Opus 5	92285b11fc	fix: Versionsnummer aus einer einzigen Quelle Die Fusszeile zeigte v0.2.0, die package.json stand auf 0.1.0 - beim Auth-Feature hatte ich nur die Anzeige hochgezaehlt. Jetzt kommt die Version aus der package.json, kann also nicht mehr auseinanderlaufen. Stand: 0.4.0. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:04:42 +02:00
florian.wildeandClaude Opus 5	e55dab6473	feat(ui): Kanban-Board mit Ziehen und Ablegen Dritte Ansicht neben Raster und Gruppierung: eine Spalte je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und erst danach gespeichert; scheitert das Speichern, springt die Karte zurueck. Details, die den Unterschied machen: - Gezogen wird am Griff links, nicht an der ganzen Karte - so bleibt der Titel ein normaler Link. - Das Ziehen startet erst nach sechs Pixeln Bewegung, sonst liesse sich die Karte nicht mehr anklicken. Auf Touchgeraeten nach kurzem Halten. - Die mitgezogene Karte haengt in einem DragOverlay am Cursor, das Original bleibt blass stehen - sonst wuerde die Spalte unter dem Finger springen. - Bestaetigt der Server die Verschiebung, wird die oertliche Ausnahme wieder entfernt, damit sie nicht veraltet. Die Reihenfolge innerhalb einer Spalte folgt der gewaehlten Sortierung. Frei sortieren hiesse, eine Position je Projekt zu speichern - bewusst nicht gebaut. Nachgewiesen im Browser: Karte aus "Idee" nach "Fertig" gezogen, Zielspalte hebt sich hervor und zeigt "Hier ablegen", danach steht das Projekt serverseitig auf DONE. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:04:42 +02:00
florian.wildeandClaude Opus 5	de8f13f242	test: Fundament mit Vitest fuer die reine Logik 51 Tests, unter einer Sekunde, ohne DOM, Datenbank oder laufenden Server. Abgedeckt sind die Stellen, an denen ein Fehler teuer waere: - Slug-Erzeugung mit Umlauten, Tag-Aufbereitung, Textkuerzung - URL-Zerlegung fuer https, SSH, verschachtelte GitLab-Gruppen und Oberflaechenpfade; Provider-Erkennung; Bildung der Aktivitaetskurve - SSRF-Sperrlisten: Loopback, Link-Local samt Metadaten-Endpunkt, CGNAT, Multicast, IPv4-gemappte IPv6-Adressen; Formpruefung; alle drei Umgebungsschalter - Passwoerter: scrypt-Rundlauf, unterschiedliches Salz je Hash, Ablageformat, Verhalten bei kaputten Hashes, Unicode-Normalisierung, Passwortregeln Bewusst ohne Datenbank- und Browsertests - die brauchen Infrastruktur und gehoeren in eine Pipeline. Steht als naechster Punkt in der ROADMAP. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:04:19 +02:00
florian.wildeandClaude Opus 5	03ce74faa2	feat(git): offene PRs und Issues, CI-Status und Commit-Aktivitaet Bisher standen nur Zahlen da. Jetzt kommen die Inhalte mit. Pull Requests und Issues: bis zu 50 offene je Liste, mit Nummer, Titel, Autor, Alter, Labels und Link. Bei GitHub und Gitea liefert der Issue-Endpunkt auch Pull Requests mit - die werden herausgefiltert. CI-Status des letzten Laufs auf dem Default-Branch: - GitHub ueber actions/runs; dort sind Lauf-Status und Ergebnis getrennt und werden auf einen Wert zusammengefuehrt - GitLab ueber pipelines - Gitea ueber den kombinierten Commit-Status. Das deckt Gitea Actions und externe Systeme wie Woodpecker gleichermassen ab - ein reiner Actions-Endpunkt existiert auf aelteren Instanzen nicht. Commit-Aktivitaet als Balkenreihe. Berechnet aus den ohnehin geholten Commits (jetzt 100 statt 15, angezeigt bleiben 15) statt ueber eigene Statistik-Endpunkte: die gibt es nicht bei allen drei Systemen, und bei GitHub antworten sie beim ersten Aufruf mit 202 und ohne Daten. Beim Testen gegen gitlab-runner fiel auf, dass alle 100 Commits in die letzten 30 Tage fielen - die frueheren Tage haetten faelschlich Null gezeigt, obwohl wir ueber sie nichts wissen. Die Kurve wird deshalb auf den tatsaechlich belegten Zeitraum gekuerzt. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:04:19 +02:00
florian.wildeandClaude Opus 5	4bb600bb06	feat(search): Volltextsuche ueber Notizen Die Suche im Board arbeitet auf den bereits geladenen Projekten und deckt Name, Kurzbeschreibung, Tags und Repo-Pfad ab. Notizen liegen dort nicht vor - sie mitzuladen wuerde die Seite unnoetig aufblaehen. Deshalb ein eigener Endpunkt, der Postgres mit seiner deutschen Textsuche arbeiten laesst. - websearch_to_tsquery versteht Eingaben wie "docker -compose" und wirft bei Unsinn keinen Fehler - ts_headline liefert den Ausschnitt gleich mit; die Hervorhebung kommt als [[…]] zurueck, damit die Oberflaeche kein HTML aus der Datenbank einbetten muss - deutsche Stammformen greifen: "Webhook" findet auch "Webhooks" - entprellt ab zwei Zeichen, laufende Abfragen werden abgebrochen Dazu ein GIN-Index auf dem Suchausdruck. Prisma kann Ausdrucksindizes im Schema nicht abbilden - nachgeprueft: "migrate diff" laesst ihn in Ruhe und schlaegt kein DROP vor. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-07-26 01:03:55 +02:00