test: Schnellsuche und Issue-Uebernahme abdecken, Version 0.9.0

Zwei neue Ende-zu-Ende-Tests: die Palette findet Projekt und Notiz und
oeffnet den Treffer mit Enter; die Uebernahme meldet ohne Repo-Stand einen
Hinweis statt still zu scheitern. Damit sind es 15.

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

FEATURES.md

@@ -117,6 +117,19 @@ Der Status ist **direkt auf der Projektkarte** umschaltbar, ohne den Detailberei
 - **Archiv** ist standardmäßig ausgeblendet und per Schalter einblendbar.
 - **Leerzustände** mit direktem Einstieg statt einer leeren Fläche.
 
+### Schnellsuche
+
+**`Strg+K`** (auf dem Mac `Cmd+K`) öffnet überall eine Palette:
+
+- **Projekte** nach Name, Kurzbeschreibung und Tags — ohne Eingabe stehen die letzten
+  gleich bereit
+- **Notizen** über dieselbe Volltextsuche wie im Board, entprellt ab zwei Zeichen
+- **Bereiche**: Dashboard, Git-Verbindungen, Mein Konto, Admin-Einstellungen
+
+Bedienung über Tastatur: Pfeile wählen, `Enter` öffnet, `Esc` schließt. Die Projektliste
+wird beim ersten Öffnen geholt und dann behalten — sie bei jedem Tastendruck neu zu laden
+wäre Verschwendung.
+
 ### Kanban
 
 Spalten je Status, Karten per Ziehen verschiebbar. Der Wechsel wird sofort angezeigt und
@@ -152,6 +165,19 @@ Blockiert · Erledigt**.
 - Erledigtes wird durchgestrichen; der Zeitpunkt wird festgehalten und beim Zurückziehen
   wieder gelöscht.
 
+### Aus Git-Issues übernehmen
+
+Im Git-Panel, Reiter *Issues*: ein Klick macht aus den offenen Issues Aufgaben — Titel,
+Labels und ein Link zurück ins Git-System.
+
+- Grundlage ist der **zuletzt geholte Stand**, hier wird nichts nachgeladen. Ein Klick
+  soll nicht ungefragt fremde APIs ansprechen; wer den neuesten Stand will, gleicht
+  vorher ab.
+- Die Issue-Nummer bleibt an der Aufgabe und ist je Projekt eindeutig. Ein zweiter Klick
+  legt deshalb **keine Dubletten** an, auch wenn die Aufgabe inzwischen verschoben oder
+  umbenannt wurde.
+- Ohne Repo-Stand meldet der Server das mit einem Hinweis statt still nichts zu tun.
+
 ### Fortschritt aus Aufgaben
 
 Pro Projekt umschaltbar. Ist es an, ergibt sich der Fortschritt aus dem Anteil erledigter
@@ -333,6 +359,7 @@ Einzurichten unter *Mein Konto → Benachrichtigungen*, pro Konto und beliebig v
 | ⚠️ **Abgleich fehlgeschlagen** | Das Git-System war nicht erreichbar oder hat abgelehnt |
 | 🔴 **CI rot** | Der letzte Lauf auf dem Default-Branch ist fehlgeschlagen |
 | 🏷️ **Neues Release** | Ein neuer Tag oder ein neues Release ist aufgetaucht |
+| 🕸️ **Projekt steht still** | Seit längerem kein Commit — Schwelle einstellbar, Vorgabe 60 Tage |
 
 ### Nur bei Änderung
 
@@ -348,6 +375,24 @@ Zwei Feinheiten:
 - Der Merkstand wird auch dann fortgeschrieben, wenn **kein** Ziel eingerichtet ist. Sonst
   käme beim ersten eingerichteten Ziel die ganze Vergangenheit hinterher.
 
+### Stillstand
+
+Der einzige Anlass, der an keinem Ereignis hängt — es passiert ja gerade nichts. Deshalb
+ein eigener Durchlauf, **höchstens einmal am Tag**, unabhängig vom automatischen Abgleich.
+Hört niemand auf diesen Anlass, läuft die Prüfung gar nicht erst.
+
+Maßstab ist ausschließlich der **letzte Commit** im verknüpften Repository. Das
+Änderungsdatum des Projekts taugt nicht: jeder Abgleich fasst es an und würde den
+Stillstand immer wieder zurücksetzen. Projekte **ohne Repository** bleiben deshalb außen
+vor, ebenso fertige und archivierte.
+
+Gemeldet wird je Projekt einmal. Erneut erst, wenn danach wieder ein Commit kam und es
+seitdem wieder still geworden ist — ein Projekt, das aufwacht und wieder einschläft, meldet
+sich also ein zweites Mal.
+
+Die Schwelle setzt ein Administrator unter *Admin-Einstellungen → Stillstand* (14 Tage bis
+ein Jahr). Eine Änderung wirkt sofort, nicht erst nach 24 Stunden.
+
 ### Zustellwege
 
 | Weg | Details |
@@ -466,6 +511,8 @@ Datenbank):
 | `auth/password` | scrypt-Rundlauf, unterschiedliches Salz, Ablageformat, Verhalten bei kaputten Hashes, Passwortregeln |
 | `tasks` | Berechnung des abgeleiteten Fortschritts, Spaltenreihenfolge |
 | `notify/pending` | Wann eine Benachrichtigung fällig ist: neuer Fehler ja, gleicher Fehler nein; CI-Wechsel nach rot; Release erst ab dem zweiten Abgleich |
+| `notify/stale` | Stillstandsschwelle, keine Zweitmeldung, aber erneute Meldung nach zwischenzeitlicher Aktivität |
+| `validation` | Dass jeder Anlass, den die Oberfläche anbietet, auch vom Schema akzeptiert wird — entstanden aus genau diesem Fehler |
 
 **`npm run test:e2e` — Ende-zu-Ende** (Playwright, 13 Stück, rund 20 Sekunden). Läuft
 gegen die gebaute Anwendung mit eigener Datenbank auf Port 3111 — also durch Middleware,

README.md

@@ -347,6 +347,7 @@ ausschließlich Daten des angemeldeten Kontos.
 | `POST` | `/api/projects/:id/sync` | Repo-Daten vom Git-System holen |
 | `GET` `POST` | `/api/projects/:id/tasks` | Aufgaben des Projekts |
 | `PATCH` | `/api/projects/:id/tasks/reorder` | Neue Reihenfolge nach dem Ziehen |
+| `POST` | `/api/projects/:id/tasks/from-issues` | Offene Issues als Aufgaben übernehmen |
 | `PATCH` `DELETE` | `/api/tasks/:id` | Aufgabe ändern / löschen |
 | `GET` `POST` | `/api/projects/:id/notes` | Notizen des Projekts |
 | `PATCH` `DELETE` | `/api/notes/:id` | Notiz ändern / löschen |

ROADMAP.md

@@ -11,13 +11,7 @@ Was bereits steht, listet [FEATURES.md](FEATURES.md).
 
 ## 1 · Als Nächstes empfohlen
 
-### 1.1 Stillstehende Projekte melden `S`
+### 1.1 Webhooks statt Polling `M`
-
-Die Benachrichtigungen decken Fehler und Releases ab. Was fehlt, ist der
-sanfte Stups: „Seit 60 Tagen kein Commit". Braucht einen eigenen Durchlauf,
-weil es kein Ereignis gibt, an dem es hängt — der Zeitgeber ist da.
-
-### 1.2 Webhooks statt Polling `M`
 
 Ein Push aktualisiert den Snapshot sofort, statt bis zum nächsten Durchlauf
 zu warten. Braucht einen öffentlich erreichbaren Endpunkt mit
@@ -69,12 +63,10 @@ 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 |
 | Wiederkehrende Aufgaben | `M` | Etwa „jeden Montag Abhängigkeiten prüfen" |
-| Aufgaben aus Git-Issues übernehmen | `M` | Offene Issues als Aufgaben einhängen |
 | Projektvorlagen | `S` | Neues Projekt mit vorgefüllten Tags und Notizen |
 | Hell/Dunkel umschaltbar | `M` | Aktuell nur dunkel |
 | Eigenes Logo und Farbe | `S` | Ergänzt `APP_NAME` |
@@ -117,6 +109,8 @@ Damit klar ist, was **nicht** kommt und warum:
 | **v0.5.0** Aufgabenbrett je Projekt mit sortierbaren Spalten, Fortschritt aus Aufgaben | ✓ |
 | **v0.6.0** Ende-zu-Ende-Tests mit Playwright, CI-Pipeline für Gitea Actions | ✓ |
 | **v0.7.0** Benachrichtigungen über ntfy, Webhook und E-Mail | ✓ |
+| **v0.8.0** Stillstehende Projekte melden, Schwelle im Adminbereich | ✓ |
+| **v0.9.0** Schnellsuche per `Strg+K`, Aufgaben aus Git-Issues | ✓ |
 
 Zur Entscheidung beim Export: Git-Tokens gehen **nicht** mit. Die Verbindung wird nur
 beschrieben, das Token ist nach dem Import neu zu hinterlegen. Snapshots bleiben

e2e/api.spec.ts

@@ -184,6 +184,20 @@ test("Aufgaben: Reihenfolge, abgeleiteter Fortschritt, fremde IDs", async ({ req
   expect(unveraendert.status).toBe("TODO");
 });
 
+test("Issues als Aufgaben uebernehmen, ohne Dubletten", async ({ request }) => {
+  await login(request, ADMIN);
+
+  const projekt = (
+    await (await request.post("/api/projects", { data: { name: "Issue-Projekt" } })).json()
+  ).project;
+
+  // Ohne Repo-Stand gibt es nichts zu uebernehmen – und das sagt der Server auch.
+  const ohneStand = await request.post(`/api/projects/${projekt.id}/tasks/from-issues`, {
+    data: {},
+  });
+  expect(ohneStand.status()).toBe(409);
+});
+
 test("Export enthaelt keine Geheimnisse, Import beachtet die Strategie", async ({ request }) => {
   await login(request, ADMIN);
 

e2e/ui.spec.ts

@@ -98,6 +98,27 @@ test("Volltextsuche findet Notizen", async ({ page }) => {
   await expect(page.getByText("Treffer in Notizen")).toBeVisible();
 });
 
+test("Schnellsuche findet Projekt und Notiz", async ({ page }) => {
+  await page.keyboard.press("Control+k");
+  await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
+
+  // Ohne Eingabe stehen Projekte und Bereiche bereit.
+  await expect(page.getByRole("dialog").getByText("Oberflaechentest")).toBeVisible();
+
+  await page.getByPlaceholder(/Projekt, Notiz oder Bereich/).fill("Zaunkoenig");
+  await expect(page.getByRole("dialog").getByText(/in Oberflaechentest/)).toBeVisible();
+
+  // Enter springt zum ersten Treffer.
+  await page.keyboard.press("Enter");
+  await expect(page.getByRole("heading", { name: "Oberflaechentest" })).toBeVisible();
+
+  // Escape schliesst wieder.
+  await page.keyboard.press("Control+k");
+  await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  await expect(page.getByRole("dialog", { name: "Schnellsuche" })).toBeHidden();
+});
+
 test("Abmelden fuehrt zurueck zur Anmeldung", async ({ page }) => {
   await page.getByRole("button", { name: /Benutzermenue/ }).click();
   await page.getByRole("menuitem", { name: "Abmelden" }).click();

package.json

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

prisma/migrations/20260726160000_stale_projects/migration.sql

@@ -0,0 +1,9 @@
+-- AlterEnum
+ALTER TYPE "NotificationEvent" ADD VALUE 'PROJECT_STALE';
+
+-- AlterTable
+ALTER TABLE "AppSettings" ADD COLUMN     "lastStaleCheckAt" TIMESTAMP(3),
+ADD COLUMN     "staleAfterDays" INTEGER NOT NULL DEFAULT 60;
+
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN     "notifiedStaleAt" TIMESTAMP(3);

prisma/migrations/20260726180000_task_source_issue/migration.sql

@@ -0,0 +1,6 @@
+-- AlterTable
+ALTER TABLE "Task" ADD COLUMN     "sourceIssue" INTEGER,
+ADD COLUMN     "sourceUrl" TEXT;
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Task_projectId_sourceIssue_key" ON "Task"("projectId", "sourceIssue");

prisma/schema.prisma

@@ -48,6 +48,8 @@ enum NotificationEvent {
   CI_FAILED
   /// Im Repository ist ein neuer Tag oder ein neues Release aufgetaucht.
   NEW_RELEASE
+  /// Seit laengerem kein Commit mehr – der sanfte Stups.
+  PROJECT_STALE
 }
 
 /// Spalten des Aufgabenbretts innerhalb eines Projekts.
@@ -181,6 +183,12 @@ model AppSettings {
   /// Kurzbericht des letzten Durchlaufs: { synced, failed, skipped, ms }
   lastAutoSyncReport Json?
 
+  // ── Stillstand ─────────────────────────────────────────────
+  /// Ab wie vielen Tagen ohne Commit ein Projekt als stillstehend gilt.
+  staleAfterDays   Int       @default(60)
+  /// Die Pruefung laeuft hoechstens einmal am Tag.
+  lastStaleCheckAt DateTime?
+
   updatedAt DateTime @updatedAt
 }
 
@@ -273,6 +281,9 @@ model Project {
   notifiedSyncError String?
   notifiedCiState   String?
   notifiedRelease   String?
+  /// Wann zuletzt wegen Stillstands gemeldet wurde. Erneut gemeldet wird
+  /// erst, wenn danach wieder ein Commit kam und es dann wieder still wurde.
+  notifiedStaleAt   DateTime?
 
   notes    Note[]
   tasks    Task[]
@@ -336,9 +347,17 @@ model Task {
   /// Zeitpunkt, zu dem die Aufgabe nach DONE gewandert ist.
   doneAt      DateTime?
 
+  /// Stammt die Aufgabe aus einem Git-Issue? Nummer und Link merken, damit
+  /// dasselbe Issue nicht zweimal uebernommen wird.
+  sourceIssue Int?
+  sourceUrl   String?
+
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
+  /// Verhindert Dubletten beim erneuten Uebernehmen. Mehrere Aufgaben ohne
+  /// Herkunft sind erlaubt: NULL gilt in Postgres als verschieden.
+  @@unique([projectId, sourceIssue])
   @@index([projectId, status, position])
 }
 

src/app/admin/page.tsx

@@ -19,7 +19,7 @@ export async function generateMetadata(): Promise<Metadata> {
 export default async function AdminPage() {
   const admin = await requireAdminPage();
 
-  const [settings, users, eligible] = await Promise.all([
+  const [settings, users, eligible, staleListeners] = await Promise.all([
     getAppSettings(),
     prisma.user.findMany({
       select: userSafeSelect,
@@ -36,6 +36,9 @@ export default async function AdminPage() {
         ],
       },
     }),
+    prisma.notificationTarget.count({
+      where: { isActive: true, events: { has: "PROJECT_STALE" } },
+    }),
   ]);
 
   const data: AdminData = {
@@ -54,6 +57,11 @@ export default async function AdminPage() {
       lastReport: (settings.lastAutoSyncReport as AutoSyncReport | null) ?? null,
       eligible,
     },
+    stale: {
+      afterDays: settings.staleAfterDays,
+      lastCheckAt: settings.lastStaleCheckAt,
+      listeners: staleListeners,
+    },
   };
 
   return (

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

@@ -37,6 +37,7 @@ export async function PATCH(request: Request) {
     autoSyncIntervalMinutes,
     autoSyncActiveOnly,
     autoSyncBatchSize,
+    staleAfterDays,
   } = parsed.data;
 
   // Der Wechsel in den Einzelbetrieb wuerde weitere Konten aussperren –
@@ -57,6 +58,11 @@ export async function PATCH(request: Request) {
     ...(autoSyncIntervalMinutes !== undefined ? { autoSyncIntervalMinutes } : {}),
     ...(autoSyncActiveOnly !== undefined ? { autoSyncActiveOnly } : {}),
     ...(autoSyncBatchSize !== undefined ? { autoSyncBatchSize } : {}),
+    // Neue Schwelle: die Pruefung soll beim naechsten Tick greifen, nicht
+    // erst in 24 Stunden.
+    ...(staleAfterDays !== undefined
+      ? { staleAfterDays, lastStaleCheckAt: null }
+      : {}),
   };
 
   const settings = await prisma.appSettings.upsert({

src/app/api/projects/[id]/tasks/from-issues/route.ts

@@ -0,0 +1,107 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { requireUserApi } from "@/lib/auth/guard";
+import { prisma } from "@/lib/db";
+import { jsonError, readJsonBody } from "@/lib/security/request";
+import { nextPosition, ownedProject, refreshDerivedProgress } from "@/lib/tasks";
+import { asArray, type TicketInfo } from "@/types";
+import { formatZodError } from "@/lib/validation";
+
+export const dynamic = "force-dynamic";
+
+type Params = { params: Promise<{ id: string }> };
+
+const schema = z.object({
+  /** Leer heisst: alle offenen Issues aus dem Snapshot. */
+  numbers: z.array(z.number().int()).max(200).optional(),
+});
+
+/**
+ * Uebernimmt offene Issues des verknuepften Repositories als Aufgaben.
+ *
+ * Grundlage ist der zuletzt geholte Snapshot – hier wird nichts nachgeladen,
+ * damit ein Klick nicht ungefragt fremde APIs anspricht. Wer den neuesten
+ * Stand will, gleicht vorher ab.
+ *
+ * Bereits uebernommene Issues werden uebersprungen: die Nummer steht an der
+ * Aufgabe und ist je Projekt eindeutig. Ein zweiter Aufruf legt also keine
+ * Dubletten an, auch wenn die Aufgabe inzwischen verschoben oder umbenannt
+ * wurde.
+ */
+export async function POST(request: Request, { params }: Params) {
+  const auth = await requireUserApi();
+  if (!auth.ok) return auth.response;
+
+  const { id } = await params;
+  if (!(await ownedProject(id, auth.user.id))) {
+    return jsonError("Projekt nicht gefunden", 404);
+  }
+
+  const body = await readJsonBody(request);
+  if (!body.ok) return body.response;
+
+  const parsed = schema.safeParse(body.data ?? {});
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "Validierung fehlgeschlagen", fields: formatZodError(parsed.error) },
+      { status: 422 },
+    );
+  }
+
+  const snapshot = await prisma.repoSnapshot.findUnique({ where: { projectId: id } });
+  if (!snapshot) {
+    return jsonError(
+      "Noch kein Repo-Stand vorhanden. Bitte zuerst synchronisieren.",
+      409,
+    );
+  }
+
+  const alle = asArray<TicketInfo>(snapshot.issues);
+  const gewuenscht = parsed.data.numbers;
+  const auswahl = gewuenscht?.length
+    ? alle.filter((issue) => gewuenscht.includes(issue.number))
+    : alle;
+
+  if (auswahl.length === 0) {
+    return NextResponse.json({ created: 0, skipped: 0, tasks: [] });
+  }
+
+  const vorhanden = await prisma.task.findMany({
+    where: { projectId: id, sourceIssue: { in: auswahl.map((issue) => issue.number) } },
+    select: { sourceIssue: true },
+  });
+  const bekannt = new Set(vorhanden.map((task) => task.sourceIssue));
+
+  const neu = auswahl.filter((issue) => !bekannt.has(issue.number));
+  let position = await nextPosition(id, "TODO");
+
+  const angelegt = [];
+  for (const issue of neu) {
+    angelegt.push(
+      await prisma.task.create({
+        data: {
+          projectId: id,
+          title: issue.title.slice(0, 200),
+          // Der Link ist das Wichtigste – der Text steht im Git-System.
+          description: issue.url ? `[Issue #${issue.number}](${issue.url})` : null,
+          status: "TODO",
+          position: position++,
+          labels: issue.labels.slice(0, 8),
+          sourceIssue: issue.number,
+          sourceUrl: issue.url,
+        },
+      }),
+    );
+  }
+
+  if (angelegt.length > 0) {
+    await refreshDerivedProgress(id);
+    await prisma.project.update({ where: { id }, data: { updatedAt: new Date() } });
+  }
+
+  return NextResponse.json({
+    created: angelegt.length,
+    skipped: auswahl.length - angelegt.length,
+    tasks: angelegt,
+  });
+}

src/app/layout.tsx

@@ -1,4 +1,5 @@
 import type { Metadata, Viewport } from "next";
+import { CommandPalette } from "@/components/CommandPalette";
 import { TopNav } from "@/components/TopNav";
 import { getSessionUser } from "@/lib/auth/session";
 import { APP_NAME, APP_TAGLINE, APP_VERSION } from "@/lib/config";
@@ -45,6 +46,9 @@ export default async function RootLayout({
 
         <TopNav user={user} appName={APP_NAME} tagline={APP_TAGLINE} />
 
+        {/* Nur fuer Angemeldete – auf der Anmeldeseite gibt es nichts zu suchen. */}
+        {user ? <CommandPalette isAdmin={user.role === "ADMIN"} /> : null}
+
         <main className="mx-auto w-full max-w-[1400px] px-4 pb-24 pt-6 sm:px-6 lg:px-8">
           {children}
         </main>

src/components/CommandPalette.tsx

@@ -0,0 +1,380 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useRouter } from "next/navigation";
+import {
+  Bell,
+  CornerDownLeft,
+  GitBranch,
+  LayoutDashboard,
+  Loader2,
+  NotebookPen,
+  Plus,
+  Search,
+  Settings,
+  UserRound,
+} from "lucide-react";
+import type { ProjectStatus } from "@prisma/client";
+import { statusOf } from "@/lib/status";
+import { cn } from "@/lib/utils";
+
+/**
+ * Schnellsuche, zu erreichen mit Strg+K beziehungsweise Cmd+K.
+ *
+ * Springt zu einem Projekt, zu einer Notiz oder direkt in einen Bereich.
+ * Die Projektliste wird beim ersten Oeffnen geholt und dann behalten – sie
+ * bei jedem Tastendruck neu zu laden waere Verschwendung, und veraltet ist
+ * sie hoechstens um die Dauer einer Sitzung.
+ */
+
+interface ProjectHit {
+  id: string;
+  name: string;
+  slug: string;
+  summary: string | null;
+  status: ProjectStatus;
+  tags: string[];
+}
+
+interface NoteHit {
+  projectId: string;
+  noteId: string;
+  title: string | null;
+  snippet: string;
+}
+
+interface Action {
+  id: string;
+  label: string;
+  hint: string;
+  icon: typeof LayoutDashboard;
+  href: string;
+  adminOnly?: boolean;
+}
+
+const ACTIONS: Action[] = [
+  { id: "dashboard", label: "Dashboard", hint: "Alle Projekte", icon: LayoutDashboard, href: "/" },
+  {
+    id: "connections",
+    label: "Git-Verbindungen",
+    hint: "GitHub, GitLab, Gitea",
+    icon: GitBranch,
+    href: "/connections",
+  },
+  { id: "account", label: "Mein Konto", hint: "Profil, Passkeys", icon: UserRound, href: "/account" },
+  {
+    id: "notify",
+    label: "Benachrichtigungen",
+    hint: "Ziele verwalten",
+    icon: Bell,
+    href: "/account",
+  },
+  {
+    id: "admin",
+    label: "Admin-Einstellungen",
+    hint: "Betriebsart, Abgleich, Konten",
+    icon: Settings,
+    href: "/admin",
+    adminOnly: true,
+  },
+];
+
+type Entry =
+  | { kind: "action"; key: string; action: Action }
+  | { kind: "project"; key: string; project: ProjectHit }
+  | { kind: "note"; key: string; note: NoteHit; projectName: string };
+
+export function CommandPalette({ isAdmin }: { isAdmin: boolean }) {
+  const router = useRouter();
+  const [mounted, setMounted] = useState(false);
+  const [open, setOpen] = useState(false);
+  const [query, setQuery] = useState("");
+  const [projects, setProjects] = useState<ProjectHit[] | null>(null);
+  const [notes, setNotes] = useState<NoteHit[]>([]);
+  const [active, setActive] = useState(0);
+  const [loading, setLoading] = useState(false);
+  const listRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => setMounted(true), []);
+
+  // Strg+K oeffnet, Escape schliesst. In Eingabefeldern nicht stoeren –
+  // ausser beim Kuerzel selbst, das soll ueberall greifen.
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
+        event.preventDefault();
+        setOpen((value) => !value);
+      } else if (event.key === "Escape") {
+        setOpen(false);
+      }
+    }
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, []);
+
+  // Projektliste beim ersten Oeffnen holen.
+  useEffect(() => {
+    if (!open || projects !== null) return;
+    setLoading(true);
+    fetch("/api/projects")
+      .then((response) => (response.ok ? response.json() : { projects: [] }))
+      .then((body) => setProjects(body.projects ?? []))
+      .catch(() => setProjects([]))
+      .finally(() => setLoading(false));
+  }, [open, projects]);
+
+  // Notizen sucht der Server – entprellt, wie im Board.
+  useEffect(() => {
+    if (!open) return;
+    const needle = query.trim();
+    if (needle.length < 2) {
+      setNotes([]);
+      return;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(async () => {
+      try {
+        const response = await fetch(`/api/search?q=${encodeURIComponent(needle)}`, {
+          signal: controller.signal,
+        });
+        if (!response.ok) return;
+        const body = (await response.json()) as { hits: NoteHit[] };
+        setNotes(body.hits ?? []);
+      } catch {
+        // Abbruch beim Weitertippen ist der Normalfall.
+      }
+    }, 250);
+    return () => {
+      clearTimeout(timer);
+      controller.abort();
+    };
+  }, [open, query]);
+
+  useEffect(() => {
+    if (!open) {
+      setQuery("");
+      setNotes([]);
+      setActive(0);
+    }
+  }, [open]);
+
+  const entries = useMemo<Entry[]>(() => {
+    const needle = query.toLowerCase().trim();
+    const result: Entry[] = [];
+
+    const passendeAktionen = ACTIONS.filter(
+      (action) =>
+        (!action.adminOnly || isAdmin) &&
+        (!needle ||
+          action.label.toLowerCase().includes(needle) ||
+          action.hint.toLowerCase().includes(needle)),
+    );
+
+    const passendeProjekte = (projects ?? []).filter(
+      (project) =>
+        !needle ||
+        project.name.toLowerCase().includes(needle) ||
+        (project.summary ?? "").toLowerCase().includes(needle) ||
+        project.tags.some((tag) => tag.includes(needle)),
+    );
+
+    // Bei leerer Eingabe stehen die Projekte oben – danach sucht man
+    // normalerweise.
+    if (!needle) {
+      for (const project of passendeProjekte.slice(0, 6)) {
+        result.push({ kind: "project", key: `p-${project.id}`, project });
+      }
+      for (const action of passendeAktionen) {
+        result.push({ kind: "action", key: `a-${action.id}`, action });
+      }
+      return result;
+    }
+
+    for (const project of passendeProjekte.slice(0, 8)) {
+      result.push({ kind: "project", key: `p-${project.id}`, project });
+    }
+    for (const hit of notes.slice(0, 5)) {
+      result.push({
+        kind: "note",
+        key: `n-${hit.noteId}`,
+        note: hit,
+        projectName:
+          (projects ?? []).find((project) => project.id === hit.projectId)?.name ?? "Projekt",
+      });
+    }
+    for (const action of passendeAktionen) {
+      result.push({ kind: "action", key: `a-${action.id}`, action });
+    }
+    return result;
+  }, [query, projects, notes, isAdmin]);
+
+  useEffect(() => {
+    setActive((current) => Math.min(current, Math.max(0, entries.length - 1)));
+  }, [entries.length]);
+
+  const go = useCallback(
+    (entry: Entry) => {
+      setOpen(false);
+      if (entry.kind === "action") router.push(entry.action.href);
+      else if (entry.kind === "project") router.push(`/projects/${entry.project.id}`);
+      else router.push(`/projects/${entry.note.projectId}`);
+    },
+    [router],
+  );
+
+  function onInputKey(event: React.KeyboardEvent) {
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      setActive((current) => (current + 1) % Math.max(1, entries.length));
+    } else if (event.key === "ArrowUp") {
+      event.preventDefault();
+      setActive((current) => (current - 1 + entries.length) % Math.max(1, entries.length));
+    } else if (event.key === "Enter") {
+      event.preventDefault();
+      const entry = entries[active];
+      if (entry) go(entry);
+    }
+  }
+
+  // Ausgewaehlten Eintrag im Blick behalten.
+  useEffect(() => {
+    listRef.current
+      ?.querySelector<HTMLElement>(`[data-index="${active}"]`)
+      ?.scrollIntoView({ block: "nearest" });
+  }, [active]);
+
+  if (!mounted || !open) return null;
+
+  return createPortal(
+    <div className="fixed inset-0 z-[130] flex items-start justify-center p-4 pt-[12vh]">
+      <button
+        type="button"
+        aria-label="Schnellsuche schliessen"
+        onClick={() => setOpen(false)}
+        className="fixed inset-0 cursor-default bg-[#03040c]/80 backdrop-blur-sm"
+      />
+
+      <div
+        role="dialog"
+        aria-modal="true"
+        aria-label="Schnellsuche"
+        className="popover fade-up relative z-10 w-full max-w-xl overflow-hidden rounded-2xl"
+      >
+        <div className="flex items-center gap-3 border-b border-white/8 px-4 py-3">
+          <Search className="h-4 w-4 shrink-0 text-slate-500" />
+          <input
+            autoFocus
+            value={query}
+            onChange={(event) => setQuery(event.target.value)}
+            onKeyDown={onInputKey}
+            placeholder="Projekt, Notiz oder Bereich…"
+            className="w-full bg-transparent text-sm text-slate-100 outline-none placeholder:text-slate-600"
+          />
+          {loading ? <Loader2 className="h-3.5 w-3.5 animate-spin text-slate-600" /> : null}
+        </div>
+
+        <div ref={listRef} className="max-h-[22rem] overflow-y-auto p-1.5">
+          {entries.length === 0 ? (
+            <p className="px-3 py-8 text-center text-sm text-slate-500">
+              {loading ? "Lade…" : "Nichts gefunden."}
+            </p>
+          ) : (
+            entries.map((entry, index) => (
+              <button
+                key={entry.key}
+                type="button"
+                data-index={index}
+                onMouseMove={() => setActive(index)}
+                onClick={() => go(entry)}
+                className={cn(
+                  "flex w-full items-start gap-3 rounded-lg px-3 py-2 text-left transition-colors",
+                  index === active ? "bg-white/8" : "hover:bg-white/5",
+                )}
+              >
+                {entry.kind === "action" ? (
+                  <>
+                    <entry.action.icon className="mt-0.5 h-4 w-4 shrink-0 text-slate-500" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.action.label}
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.action.hint}
+                      </span>
+                    </span>
+                  </>
+                ) : entry.kind === "project" ? (
+                  <>
+                    <span
+                      className="mt-1.5 h-2 w-2 shrink-0 rounded-full"
+                      style={{ backgroundColor: statusOf(entry.project.status).color }}
+                    />
+                    <span className="min-w-0 flex-1">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.project.name}
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.project.summary ?? statusOf(entry.project.status).label}
+                      </span>
+                    </span>
+                    <span className="mt-0.5 shrink-0 text-[10px] uppercase tracking-wider text-slate-600">
+                      {statusOf(entry.project.status).short}
+                    </span>
+                  </>
+                ) : (
+                  <>
+                    <NotebookPen className="mt-0.5 h-4 w-4 shrink-0 text-violet-300/70" />
+                    <span className="min-w-0">
+                      <span className="block truncate text-sm text-slate-200">
+                        {entry.note.title ?? "Notiz"}
+                        <span className="ml-1.5 text-[11px] text-slate-500">
+                          in {entry.projectName}
+                        </span>
+                      </span>
+                      <span className="block truncate text-[11px] text-slate-500">
+                        {entry.note.snippet.replace(/\[\[|\]\]/g, "")}
+                      </span>
+                    </span>
+                  </>
+                )}
+              </button>
+            ))
+          )}
+        </div>
+
+        <div className="flex items-center gap-4 border-t border-white/6 px-4 py-2 text-[10px] text-slate-600">
+          <span className="inline-flex items-center gap-1">
+            <Kbd>↑</Kbd>
+            <Kbd>↓</Kbd>
+            waehlen
+          </span>
+          <span className="inline-flex items-center gap-1">
+            <Kbd>
+              <CornerDownLeft className="h-2.5 w-2.5" />
+            </Kbd>
+            oeffnen
+          </span>
+          <span className="inline-flex items-center gap-1">
+            <Kbd>Esc</Kbd>
+            schliessen
+          </span>
+          <span className="ml-auto inline-flex items-center gap-1">
+            <Plus className="h-2.5 w-2.5" />
+            <Kbd>Strg</Kbd>
+            <Kbd>K</Kbd>
+          </span>
+        </div>
+      </div>
+    </div>,
+    document.body,
+  );
+}
+
+function Kbd({ children }: { children: React.ReactNode }) {
+  return (
+    <kbd className="inline-flex min-w-[1.2rem] items-center justify-center rounded border border-white/12 bg-white/5 px-1 py-0.5 font-sans text-[10px] text-slate-400">
+      {children}
+    </kbd>
+  );
+}

src/components/GitPanel.tsx

@@ -12,6 +12,7 @@ import {
   GitMerge,
   GitPullRequest,
   HardDrive,
+  ListPlus,
   Loader2,
   Lock,
   Package,
@@ -48,8 +49,36 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
   const router = useRouter();
   const [tab, setTab] = useState<TabKey>("pulls");
   const [syncing, setSyncing] = useState(false);
+  const [importing, setImporting] = useState(false);
   const [message, setMessage] = useState<{ ok: boolean; text: string } | null>(null);
 
+  /** Offene Issues als Aufgaben anlegen – ohne erneuten Abruf beim Provider. */
+  async function importIssues() {
+    setImporting(true);
+    setMessage(null);
+    try {
+      const response = await fetch(`/api/projects/${project.id}/tasks/from-issues`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: "{}",
+      });
+      const body = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(body.error ?? "Uebernahme fehlgeschlagen.");
+      setMessage({
+        ok: true,
+        text:
+          body.created === 0
+            ? `Nichts Neues – alle ${body.skipped} Issues sind bereits als Aufgabe vorhanden.`
+            : `${body.created} Aufgabe(n) angelegt${body.skipped ? `, ${body.skipped} uebersprungen` : ""}.`,
+      });
+      router.refresh();
+    } catch (caught) {
+      setMessage({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
+    } finally {
+      setImporting(false);
+    }
+  }
+
   const snapshot = project.snapshot;
   const branches = asArray<BranchInfo>(snapshot?.branches);
   const tags = asArray<TagInfo>(snapshot?.tags);
@@ -329,7 +358,30 @@ export function GitPanel({ project }: { project: ProjectDetail }) {
                 />
               ) : null}
               {tab === "issues" ? (
-                <TicketList tickets={issues} empty="Keine offenen Issues." icon={CircleDot} />
+                <>
+                  {issues.length > 0 ? (
+                    <div className="flex flex-wrap items-center justify-between gap-2 border-b border-white/6 bg-white/2 px-4 py-2">
+                      <p className="text-[11px] text-slate-500">
+                        Aus offenen Issues Aufgaben machen. Bereits uebernommene werden
+                        uebersprungen.
+                      </p>
+                      <button
+                        type="button"
+                        className="btn btn-ghost px-2.5 py-1 text-[11px]"
+                        onClick={importIssues}
+                        disabled={importing}
+                      >
+                        {importing ? (
+                          <Loader2 className="h-3 w-3 animate-spin" />
+                        ) : (
+                          <ListPlus className="h-3 w-3" />
+                        )}
+                        Als Aufgaben uebernehmen
+                      </button>
+                    </div>
+                  ) : null}
+                  <TicketList tickets={issues} empty="Keine offenen Issues." icon={CircleDot} />
+                </>
               ) : null}
               {tab === "branches" ? <BranchList branches={branches} /> : null}
               {tab === "tags" ? <TagList tags={tags} /> : null}

src/components/admin/AdminManager.tsx

@@ -9,6 +9,7 @@ import {
   Download,
   Fingerprint,
   FolderGit2,
+  Hourglass,
   Loader2,
   Lock,
   Plus,
@@ -67,6 +68,12 @@ export interface AdminData {
     /** Projekte mit Repository, die grundsaetzlich in Frage kommen. */
     eligible: number;
   };
+  stale: {
+    afterDays: number;
+    lastCheckAt: string | Date | null;
+    /** Wie viele Konten ueberhaupt auf Stillstand hoeren. */
+    listeners: number;
+  };
 }
 
 type Notice = { ok: boolean; text: string } | null;
@@ -187,6 +194,7 @@ export function AdminManager({ data }: { data: AdminData }) {
       </section>
 
       <AutoSyncSection data={data.autoSync} />
+      <StaleSection data={data.stale} />
 
       {/* ── Instanz ─────────────────────────────────────── */}
       <section className="glass p-5">
@@ -574,6 +582,124 @@ function AutoSyncSection({ data }: { data: AdminData["autoSync"] }) {
   );
 }
 
+const STALE_OPTIONS = [14, 30, 60, 90, 180, 365];
+
+function StaleSection({ data }: { data: AdminData["stale"] }) {
+  const router = useRouter();
+  const [days, setDays] = useState(data.afterDays);
+  const [busy, setBusy] = useState(false);
+  const [notice, setNotice] = useState<Notice>(null);
+
+  async function save(value: number) {
+    setBusy(true);
+    setNotice(null);
+    try {
+      const response = await fetch("/api/admin/settings", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ staleAfterDays: value }),
+      });
+      const body = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(body.error ?? "Speichern fehlgeschlagen.");
+      setNotice({ ok: true, text: "Gespeichert." });
+      router.refresh();
+    } catch (caught) {
+      setDays(data.afterDays);
+      setNotice({ ok: false, text: caught instanceof Error ? caught.message : String(caught) });
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <section className="glass p-5">
+      <div className="mb-4 flex items-start gap-3">
+        <span className="grid h-9 w-9 shrink-0 place-items-center rounded-xl bg-amber-500/12 text-amber-300">
+          <Hourglass className="h-4 w-4" />
+        </span>
+        <div>
+          <h2 className="text-sm font-semibold uppercase tracking-wider text-slate-200">
+            Stillstand
+          </h2>
+          <p className="mt-1 max-w-xl text-sm text-slate-400">
+            Ab wann ein Projekt als eingeschlafen gilt. Massstab ist der letzte Commit im
+            verknuepften Repository – das Aenderungsdatum taugt nicht, weil jeder Abgleich
+            es anfasst. Projekte ohne Repository bleiben aussen vor, ebenso fertige und
+            archivierte.
+          </p>
+        </div>
+      </div>
+
+      <div className="grid gap-4 sm:grid-cols-2">
+        <div>
+          <label className="field-label" htmlFor="stale-days">
+            Schwelle
+          </label>
+          <select
+            id="stale-days"
+            className="field"
+            value={days}
+            disabled={busy}
+            onChange={(event) => {
+              const value = Number(event.target.value);
+              setDays(value);
+              void save(value);
+            }}
+          >
+            {STALE_OPTIONS.map((value) => (
+              <option key={value} value={value}>
+                nach {value} Tagen ohne Commit
+              </option>
+            ))}
+          </select>
+        </div>
+
+        <dl className="grid grid-cols-2 gap-3">
+          <div className="glass-soft px-3 py-2.5">
+            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
+              Letzte Pruefung
+            </dt>
+            <dd className="mt-1 text-sm text-slate-200" suppressHydrationWarning>
+              {data.lastCheckAt ? formatRelative(data.lastCheckAt) : "noch keine"}
+            </dd>
+          </div>
+          <div className="glass-soft px-3 py-2.5">
+            <dt className="text-[11px] uppercase tracking-wider text-slate-500">
+              Empfaenger
+            </dt>
+            <dd className="mt-1 text-sm tabular-nums text-slate-200">{data.listeners}</dd>
+          </div>
+        </dl>
+      </div>
+
+      {data.listeners === 0 ? (
+        <p className="mt-3 text-[11px] text-slate-600">
+          Niemand hoert derzeit auf diesen Anlass – die Pruefung laeuft dann gar nicht
+          erst. Einzurichten unter „Mein Konto → Benachrichtigungen“.
+        </p>
+      ) : (
+        <p className="mt-3 text-[11px] text-slate-600">
+          Die Pruefung laeuft hoechstens einmal am Tag. Je Projekt wird einmal gemeldet;
+          erneut erst, wenn danach wieder ein Commit kam und es wieder still wurde.
+        </p>
+      )}
+
+      {notice ? (
+        <p
+          className={cn(
+            "mt-3 rounded-lg border px-3 py-2 text-sm",
+            notice.ok
+              ? "border-emerald-500/30 bg-emerald-500/10 text-emerald-200"
+              : "border-rose-500/30 bg-rose-500/10 text-rose-200",
+          )}
+        >
+          {notice.text}
+        </p>
+      ) : null}
+    </section>
+  );
+}
+
 function ModeCard({
   active,
   disabled,

src/lib/notify/stale.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { daysSince, isStaleDue } from "./stale";
+
+/**
+ * Die Entscheidung, wann ein Projekt als eingeschlafen gilt – und vor allem,
+ * wann es *nicht* erneut gemeldet wird.
+ */
+
+const TAG = 86_400_000;
+const jetzt = new Date("2026-07-26T12:00:00Z");
+const vorTagen = (tage: number) => new Date(jetzt.getTime() - tage * TAG);
+/** Schwelle: 60 Tage. */
+const cutoff = vorTagen(60);
+
+describe("isStaleDue", () => {
+  it("meldet ein Projekt, dessen letzter Commit laenger zurueckliegt", () => {
+    expect(isStaleDue({ notifiedStaleAt: null }, vorTagen(90), cutoff)).toBe(true);
+  });
+
+  it("meldet nichts innerhalb der Frist", () => {
+    expect(isStaleDue({ notifiedStaleAt: null }, vorTagen(30), cutoff)).toBe(false);
+  });
+
+  it("meldet nichts genau an der Schwelle", () => {
+    expect(isStaleDue({ notifiedStaleAt: null }, cutoff, cutoff)).toBe(false);
+  });
+
+  it("meldet nichts ohne bekannten letzten Commit", () => {
+    // Ein Projekt ohne Repository oder ohne Snapshot laesst sich nicht
+    // beurteilen – lieber schweigen als raten.
+    expect(isStaleDue({ notifiedStaleAt: null }, null, cutoff)).toBe(false);
+  });
+
+  it("meldet dasselbe Projekt kein zweites Mal", () => {
+    expect(isStaleDue({ notifiedStaleAt: vorTagen(5) }, vorTagen(90), cutoff)).toBe(false);
+  });
+
+  it("meldet erneut, wenn zwischendurch gearbeitet wurde und es wieder still ist", () => {
+    // Gemeldet vor 200 Tagen, danach ein Commit vor 90 Tagen, seitdem Ruhe.
+    expect(isStaleDue({ notifiedStaleAt: vorTagen(200) }, vorTagen(90), cutoff)).toBe(true);
+  });
+
+  it("meldet nicht erneut, wenn der Commit vor der letzten Meldung lag", () => {
+    expect(isStaleDue({ notifiedStaleAt: vorTagen(10) }, vorTagen(90), cutoff)).toBe(false);
+  });
+});
+
+describe("daysSince", () => {
+  it("zaehlt volle Tage", () => {
+    expect(daysSince(vorTagen(60), jetzt)).toBe(60);
+    expect(daysSince(vorTagen(1), jetzt)).toBe(1);
+  });
+
+  it("rundet angebrochene Tage ab", () => {
+    expect(daysSince(new Date(jetzt.getTime() - 1.9 * TAG), jetzt)).toBe(1);
+  });
+
+  it("liefert null fuer soeben", () => {
+    expect(daysSince(jetzt, jetzt)).toBe(0);
+  });
+});

src/lib/notify/stale.ts

@@ -0,0 +1,128 @@
+import type { Project, RepoSnapshot } from "@prisma/client";
+import { APP_URL } from "@/lib/config";
+import { prisma } from "@/lib/db";
+import { statusOf } from "@/lib/status";
+import { deliver } from "./channels";
+import { EVENT_META, type NotificationMessage } from "./types";
+
+/**
+ * Meldet Projekte, in denen laenger nichts passiert ist.
+ *
+ * Anders als die uebrigen Anlaesse haengt dieser an keinem Ereignis – es
+ * passiert ja gerade nichts. Deshalb ein eigener Durchlauf, hoechstens
+ * einmal am Tag.
+ *
+ * Massstab ist ausschliesslich der letzte Commit im verknuepften
+ * Repository. Das Aenderungsdatum des Projekts taugt nicht: jeder Abgleich
+ * fasst es an und wuerde den Stillstand immer wieder zuruecksetzen.
+ * Projekte ohne Repository bleiben folglich aussen vor.
+ */
+
+export interface StaleReport {
+  at: string;
+  checked: number;
+  stale: number;
+  notified: number;
+  thresholdDays: number;
+}
+
+/** Entscheidet, ob ein Projekt jetzt zu melden ist. */
+export function isStaleDue(
+  project: Pick<Project, "notifiedStaleAt">,
+  lastCommitAt: Date | null,
+  cutoff: Date,
+): boolean {
+  // Ohne bekannten letzten Commit gibt es nichts zu beurteilen.
+  if (!lastCommitAt) return false;
+  // Noch innerhalb der Frist.
+  if (lastCommitAt >= cutoff) return false;
+  // Noch nie gemeldet: jetzt.
+  if (!project.notifiedStaleAt) return true;
+  // Schon gemeldet – erneut nur, wenn danach wieder ein Commit kam und es
+  // seitdem wieder still geworden ist.
+  return lastCommitAt > project.notifiedStaleAt;
+}
+
+/** Wie viele volle Tage seit dem letzten Commit vergangen sind. */
+export function daysSince(date: Date, now: Date = new Date()): number {
+  return Math.floor((now.getTime() - date.getTime()) / 86_400_000);
+}
+
+function message(
+  project: Project,
+  snapshot: RepoSnapshot | null,
+  tage: number,
+): NotificationMessage {
+  return {
+    event: "PROJECT_STALE",
+    title: `${EVENT_META.PROJECT_STALE.emoji} ${project.name}: seit ${tage} Tagen kein Commit`,
+    body:
+      `Der letzte Commit liegt ${tage} Tage zurueck. ` +
+      `Status: ${statusOf(project.status).label}. Vielleicht abschliessen oder archivieren?`,
+    priority: "normal",
+    url: snapshot?.htmlUrl ?? `${APP_URL}/projects/${project.id}`,
+    project: { id: project.id, name: project.name, slug: project.slug },
+    at: new Date().toISOString(),
+  };
+}
+
+/**
+ * Ein Durchlauf. Meldet je Projekt hoechstens einmal und schreibt den
+ * Merkstand fort – auch dann, wenn niemand zuhoert.
+ */
+export async function runStaleCheck(thresholdDays: number): Promise<StaleReport> {
+  const now = new Date();
+  const cutoff = new Date(now.getTime() - thresholdDays * 86_400_000);
+
+  const kandidaten = await prisma.project.findMany({
+    where: {
+      // Fertige und archivierte Projekte duerfen ruhen.
+      status: { notIn: ["DONE", "ARCHIVED"] },
+      ownerId: { not: null },
+      snapshot: { isNot: null },
+    },
+    include: { snapshot: true },
+  });
+
+  const faellig = kandidaten.filter((project) =>
+    isStaleDue(project, project.snapshot?.lastCommitAt ?? null, cutoff),
+  );
+
+  let zugestellt = 0;
+
+  for (const project of faellig) {
+    const lastCommitAt = project.snapshot?.lastCommitAt;
+    if (!lastCommitAt || !project.ownerId) continue;
+
+    const ziele = await prisma.notificationTarget.findMany({
+      where: { userId: project.ownerId, isActive: true, events: { has: "PROJECT_STALE" } },
+    });
+
+    for (const ziel of ziele) {
+      const ergebnis = await deliver(
+        ziel,
+        message(project, project.snapshot, daysSince(lastCommitAt, now)),
+      );
+      zugestellt += 1;
+      await prisma.notificationTarget.update({
+        where: { id: ziel.id },
+        data: { lastSentAt: now, lastOk: ergebnis.ok, lastMessage: ergebnis.message },
+      });
+    }
+
+    // Auch ohne Ziel vermerken, sonst kaeme beim ersten eingerichteten Ziel
+    // die gesamte Vergangenheit hinterher.
+    await prisma.project.update({
+      where: { id: project.id },
+      data: { notifiedStaleAt: now },
+    });
+  }
+
+  return {
+    at: now.toISOString(),
+    checked: kandidaten.length,
+    stale: faellig.length,
+    notified: zugestellt,
+    thresholdDays,
+  };
+}

src/lib/notify/types.ts

@@ -5,6 +5,7 @@ export const NOTIFICATION_EVENTS: NotificationEvent[] = [
   "SYNC_FAILED",
   "CI_FAILED",
   "NEW_RELEASE",
+  "PROJECT_STALE",
 ];
 
 export const EVENT_META: Record<
@@ -26,6 +27,11 @@ export const EVENT_META: Record<
     description: "Im Repository ist ein neuer Tag oder ein Release aufgetaucht.",
     emoji: "🏷️",
   },
+  PROJECT_STALE: {
+    label: "Projekt steht still",
+    description: "Seit laengerem kein Commit mehr. Die Schwelle setzt ein Administrator.",
+    emoji: "🕸️",
+  },
 };
 
 /** Eine fertig formulierte Nachricht, unabhaengig vom Zustellweg. */

src/lib/sync/scheduler.ts

@@ -1,6 +1,7 @@
 import type { Prisma } from "@prisma/client";
 import { getAppSettings } from "@/lib/auth/settings";
 import { prisma } from "@/lib/db";
+import { runStaleCheck } from "@/lib/notify/stale";
 import { syncProject } from "@/lib/sync";
 
 /**
@@ -20,6 +21,8 @@ import { syncProject } from "@/lib/sync";
  */
 
 const TICK_MS = 60_000;
+/** Stillstand aendert sich langsam – einmal am Tag genuegt. */
+const STALE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 /** Kleine Verschnaufpause zwischen zwei Projekten. */
 const PAUSE_MS = 400;
 /** Hoechstens so lange wird nach Fehlschlaegen zurueckgehalten. */
@@ -64,18 +67,54 @@ export function startAutoSyncScheduler() {
 async function tick() {
   try {
     const settings = await getAppSettings();
-    if (!settings.autoSyncEnabled) return;
 
-    const intervalMs = Math.max(5, settings.autoSyncIntervalMinutes) * 60_000;
+    if (settings.autoSyncEnabled) {
-    const last = settings.lastAutoSyncAt?.getTime() ?? 0;
+      const intervalMs = Math.max(5, settings.autoSyncIntervalMinutes) * 60_000;
-    if (Date.now() - last < intervalMs) return;
+      const last = settings.lastAutoSyncAt?.getTime() ?? 0;
+      if (Date.now() - last >= intervalMs) {
+        await runAutoSyncPass("zeitplan");
+      }
+    }
 
-    await runAutoSyncPass("zeitplan");
+    // Unabhaengig vom Abgleich: der Stillstand ergibt sich aus dem
+    // gespeicherten Stand, dafuer muss nichts geholt werden.
+    await maybeCheckStale();
   } catch (error) {
     console.error("[nebula] Automatischer Abgleich fehlgeschlagen:", error);
   }
 }
 
+/**
+ * Stillstandspruefung, hoechstens einmal am Tag. Laeuft nur, wenn ueberhaupt
+ * jemand darauf hoert – sonst waere es reine Datenbanklast.
+ */
+async function maybeCheckStale() {
+  const settings = await getAppSettings();
+  const last = settings.lastStaleCheckAt?.getTime() ?? 0;
+  if (Date.now() - last < STALE_CHECK_INTERVAL_MS) return;
+
+  const zuhoerer = await prisma.notificationTarget.count({
+    where: { isActive: true, events: { has: "PROJECT_STALE" } },
+  });
+
+  // Zeitstempel auch ohne Zuhoerer setzen, damit nicht jede Minute gezaehlt
+  // wird.
+  await prisma.appSettings.update({
+    where: { id: "singleton" },
+    data: { lastStaleCheckAt: new Date() },
+  });
+
+  if (zuhoerer === 0) return;
+
+  const report = await runStaleCheck(Math.max(1, settings.staleAfterDays));
+  if (report.stale > 0) {
+    console.log(
+      `[nebula] Stillstand: ${report.stale} von ${report.checked} Projekten ` +
+        `ueber ${report.thresholdDays} Tage ohne Commit, ${report.notified} Meldungen.`,
+    );
+  }
+}
+
 /**
  * Ein Durchlauf. Laeuft nie zweimal gleichzeitig – ein zweiter Aufruf
  * waehrend eines laufenden Durchlaufs bekommt null zurueck.

src/lib/validation.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { NOTIFICATION_EVENTS } from "@/lib/notify/types";
+import { notificationTargetCreateSchema } from "./validation";
+
+/**
+ * Dieser Test entstand aus einem Fehler: beim Ergaenzen eines neuen
+ * Anlasses war das Zod-Schema nicht mitgezogen worden, die API lehnte ihn
+ * mit 422 ab. Die Liste steht an zwei Stellen – hier wird geprueft, dass
+ * sie zusammenpassen.
+ */
+
+const basis = {
+  name: "Handy",
+  channel: "NTFY" as const,
+  target: "https://ntfy.sh/mein-thema",
+};
+
+describe("notificationTargetCreateSchema", () => {
+  it("kennt jeden Anlass, den die Oberflaeche anbietet", () => {
+    for (const event of NOTIFICATION_EVENTS) {
+      const ergebnis = notificationTargetCreateSchema.safeParse({
+        ...basis,
+        events: [event],
+      });
+      expect(ergebnis.success, `Anlass ${event} wird abgelehnt`).toBe(true);
+    }
+  });
+
+  it("verlangt mindestens einen Anlass", () => {
+    expect(notificationTargetCreateSchema.safeParse({ ...basis, events: [] }).success).toBe(
+      false,
+    );
+  });
+
+  it("weist unbekannte Anlaesse ab", () => {
+    expect(
+      notificationTargetCreateSchema.safeParse({ ...basis, events: ["WAS_AUCH_IMMER"] })
+        .success,
+    ).toBe(false);
+  });
+
+  it("verlangt bei E-Mail eine Adresse, keine URL", () => {
+    const alsUrl = notificationTargetCreateSchema.safeParse({
+      name: "Post",
+      channel: "EMAIL",
+      target: "https://example.com",
+      events: ["SYNC_FAILED"],
+    });
+    expect(alsUrl.success).toBe(false);
+
+    const alsAdresse = notificationTargetCreateSchema.safeParse({
+      name: "Post",
+      channel: "EMAIL",
+      target: "ich@example.com",
+      events: ["SYNC_FAILED"],
+    });
+    expect(alsAdresse.success).toBe(true);
+  });
+
+  it("verlangt bei Webhook und ntfy eine http-URL", () => {
+    for (const channel of ["WEBHOOK", "NTFY"] as const) {
+      expect(
+        notificationTargetCreateSchema.safeParse({
+          name: "X",
+          channel,
+          target: "ich@example.com",
+          events: ["SYNC_FAILED"],
+        }).success,
+      ).toBe(false);
+    }
+  });
+});

src/lib/validation.ts

@@ -146,6 +146,8 @@ export const profileUpdateSchema = z.object({
 export const adminSettingsSchema = z.object({
   mode: z.enum(["SINGLE_USER", "MULTI_USER"]).optional(),
   allowRegistration: z.boolean().optional(),
+  /** Ab wie vielen Tagen ohne Commit ein Projekt als stillstehend gilt. */
+  staleAfterDays: z.coerce.number().int().min(7).max(365).optional(),
   autoSyncEnabled: z.boolean().optional(),
   /** Untergrenze 5 Minuten – haeufiger waere den Git-APIs gegenueber unfair. */
   autoSyncIntervalMinutes: z.coerce.number().int().min(5).max(10080).optional(),
@@ -173,7 +175,7 @@ export const adminUserUpdateSchema = z.object({
 // ── Benachrichtigungen ───────────────────────────────────────
 
 const CHANNELS = ["WEBHOOK", "NTFY", "EMAIL"] as const;
-const EVENTS = ["SYNC_FAILED", "CI_FAILED", "NEW_RELEASE"] as const;
+const EVENTS = ["SYNC_FAILED", "CI_FAILED", "NEW_RELEASE", "PROJECT_STALE"] as const;
 
 export const notificationTargetCreateSchema = z
   .object({