feat(notifications): täglicher Lauf über SMTP und Apprise

- Kanäle SMTP (HTML-Mail mit Logos als CID-Anhang) und Apprise, beide
  blockierenden Bibliotheken laufen in einem Thread
- Vier Anlässe: Fälligkeiten im Vorlauf, Kündigungsfristen in drei Stufen,
  überschrittene Budgets je Monat, Vertragsverlängerungen im Folgemonat
- APScheduler im Anwendungsprozess, täglich 07:00 Europe/Berlin, räumt zugleich
  abgelaufene Sitzungen auf
- Duplikatsschutz über den Zieltag statt den Versandtag; fehlgeschlagener
  Versand wird beim nächsten Lauf erneut versucht
- Endpunkte für Regeln, Protokoll, Testversand und sofortigen Lauf
- Einstellungsseite mit Einrichtungsstand, Regelpflege und Protokoll
- 25 neue Backend-Tests (260 gesamt), 9 neue Frontend-Tests (74 gesamt)

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014e7t8UpmoVNMtWivY5LiSH

CHANGELOG.md

@@ -96,6 +96,21 @@ die Versionierung folgt [Semantic Versioning](https://semver.org/lang/de/).
   Serienpaar aus (bei Deuteranopie nicht unterscheidbar) und bleibt den
   Vorzeichen im Text vorbehalten.
 
+- Benachrichtigungen über SMTP (HTML-Mail mit eingebetteten Firmenlogos) und
+  Apprise, gesteuert über Regeln je Anlass und Kanal.
+- Vier Anlässe: bald fällige Posten, Kündigungsfristen (30, 14 und 7 Tage vor
+  dem Termin), überschrittene Budgets und anstehende Vertragsverlängerungen.
+- APScheduler-Job täglich um 07:00 `Europe/Berlin`, der zugleich abgelaufene
+  Sitzungen aufräumt; verpasste Läufe werden einmal nachgeholt.
+- Duplikatsschutz über `(rule_id, ref_type, ref_id, Zieltag)`. Maßgeblich ist der
+  Zieltag des Ereignisses, nicht der Versandtag – ein zweiter Lauf am selben oder
+  am nächsten Tag erzeugt keine zweite Nachricht. Ein fehlgeschlagener Versand
+  wird beim nächsten Lauf erneut versucht.
+- `POST /api/notifications/test` verschickt eine Testnachricht über beide Kanäle,
+  `POST /api/notifications/run` führt einen Lauf sofort aus.
+- Benachrichtigungen sind in den Einstellungen pflegbar, samt Einrichtungsstand
+  der Kanäle und Versandprotokoll.
+
 ### Geändert
 
 - `SECRET_KEY` muss mindestens 32 Zeichen lang sein (Vorgabe von HS256); in

README.md

@@ -83,6 +83,22 @@ vollständige, kommentierte Liste. Die wichtigsten:
 | `COOKIE_SECURE` | `true` | Hinter HTTPS `true`, für lokales HTTP `false` |
 | `SCHEDULER_ENABLED` | `true` | Täglicher Benachrichtigungslauf um 07:00 |
 
+## Benachrichtigungen
+
+Ein Job läuft täglich um 07:00 Uhr (`Europe/Berlin`) im Anwendungsprozess – ohne
+Redis, ohne Celery. Er prüft vier Anlässe: bald fällige Posten, Kündigungsfristen
+30, 14 und 7 Tage vor dem Termin, überschrittene Budgets und Vertragsverlängerungen
+im kommenden Monat.
+
+Der Duplikatsschutz hängt am **Zieltag des Ereignisses**, nicht am Versandtag:
+Eine Fälligkeit am 15.03. wird genau einmal gemeldet, unabhängig davon, an
+welchem Tag des Vorlaufs der Job läuft. Ein fehlgeschlagener Versand gilt als
+offen und wird beim nächsten Lauf erneut versucht.
+
+Als Kanäle stehen SMTP (HTML-Mail mit eingebetteten Firmenlogos) und Apprise zur
+Verfügung. Über *Einstellungen → Benachrichtigungen* lassen sich Regeln pflegen,
+eine Testnachricht verschicken und das Versandprotokoll einsehen.
+
 ## Diagramme
 
 Die Serienfarben stammen aus einer Palette, die gegen die hellen und dunklen

backend/app/api/router.py

@@ -16,6 +16,7 @@ from app.api.routes import (
     logos,
     me,
     merchants,
+    notifications,
     occurrences,
     recurrences,
     reports,
@@ -45,5 +46,6 @@ protected.include_router(budgets.templates)
 protected.include_router(savings_goals.router)
 protected.include_router(reports.router)
 protected.include_router(export.router)
+protected.include_router(notifications.router)
 
 api_router.include_router(protected)

backend/app/api/routes/notifications.py

@@ -0,0 +1,176 @@
+"""Benachrichtigungsregeln, Versandprotokoll und Testversand."""
+
+from datetime import date
+
+from fastapi import APIRouter, Query, status
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+
+from app.api.deps import DbSession
+from app.core.config import settings
+from app.core.errors import ConflictError
+from app.models import NotificationLog, NotificationRule
+from app.models.enums import NotificationChannel, NotificationStatus
+from app.scheduler import next_run_time
+from app.schemas.common import ErrorResponse, MessageResponse
+from app.schemas.notification import (
+    ChannelStatusOut,
+    NotificationLogOut,
+    NotificationRuleCreate,
+    NotificationRuleOut,
+    NotificationRuleUpdate,
+    NotificationSettingsOut,
+    RunResponse,
+    TestResultOut,
+    TestSendRequest,
+    TestSendResponse,
+)
+from app.services.channels import get_channel
+from app.services.crud import apply_updates, get_or_404
+from app.services.notifications import run_all, send_test
+
+router = APIRouter(prefix="/notifications", tags=["notifications"])
+
+NOT_FOUND = {status.HTTP_404_NOT_FOUND: {"model": ErrorResponse}}
+
+CHANNEL_HINTS = {
+    NotificationChannel.SMTP: "SMTP_HOST und SMTP_FROM setzen.",
+    NotificationChannel.APPRISE: "APPRISE_URLS setzen, komma-separiert.",
+}
+
+
+@router.get(
+    "/settings",
+    response_model=NotificationSettingsOut,
+    summary="Einrichtungsstand",
+    description="Zeigt, welche Kanäle einsatzbereit sind und wann der nächste Lauf ansteht.",
+)
+async def read_settings() -> NotificationSettingsOut:
+    kanaele = []
+    for art, hinweis in CHANNEL_HINTS.items():
+        eingerichtet = get_channel(art).is_configured()
+        kanaele.append(
+            ChannelStatusOut(
+                channel=art,
+                configured=eingerichtet,
+                detail="Einsatzbereit." if eingerichtet else hinweis,
+            )
+        )
+
+    return NotificationSettingsOut(
+        enabled=settings.notifications_enabled,
+        scheduler_enabled=settings.scheduler_enabled,
+        run_at=f"{settings.notification_hour:02d}:{settings.notification_minute:02d}",
+        timezone=settings.timezone,
+        next_run_at=next_run_time(),
+        channels=kanaele,
+    )
+
+
+@router.get("/rules", response_model=list[NotificationRuleOut], summary="Regeln auflisten")
+async def list_rules(session: DbSession) -> list[NotificationRule]:
+    stmt = select(NotificationRule).order_by(NotificationRule.type, NotificationRule.channel)
+    return list((await session.execute(stmt)).scalars().all())
+
+
+@router.post(
+    "/rules",
+    response_model=NotificationRuleOut,
+    status_code=status.HTTP_201_CREATED,
+    summary="Regel anlegen",
+)
+async def create_rule(payload: NotificationRuleCreate, session: DbSession) -> NotificationRule:
+    regel = NotificationRule(**payload.model_dump())
+    session.add(regel)
+    try:
+        await session.commit()
+    except IntegrityError as exc:
+        await session.rollback()
+        raise ConflictError("Diese Regel existiert bereits.") from exc
+    await session.refresh(regel)
+    return regel
+
+
+@router.patch(
+    "/rules/{rule_id}",
+    response_model=NotificationRuleOut,
+    responses=NOT_FOUND,
+    summary="Regel ändern",
+)
+async def update_rule(
+    rule_id: int, payload: NotificationRuleUpdate, session: DbSession
+) -> NotificationRule:
+    regel = await get_or_404(session, NotificationRule, rule_id)
+    apply_updates(regel, payload)
+    await session.commit()
+    await session.refresh(regel)
+    return regel
+
+
+@router.delete(
+    "/rules/{rule_id}",
+    response_model=MessageResponse,
+    responses=NOT_FOUND,
+    summary="Regel löschen",
+    description="Entfernt die Regel samt ihrem Versandprotokoll.",
+)
+async def delete_rule(rule_id: int, session: DbSession) -> MessageResponse:
+    regel = await get_or_404(session, NotificationRule, rule_id)
+    await session.delete(regel)
+    await session.commit()
+    return MessageResponse(detail="Regel gelöscht.")
+
+
+@router.get(
+    "/log",
+    response_model=list[NotificationLogOut],
+    summary="Versandprotokoll",
+    description="Neueste Einträge zuerst.",
+)
+async def read_log(
+    session: DbSession,
+    rule_id: int | None = Query(default=None),
+    status_filter: NotificationStatus | None = Query(default=None, alias="status"),
+    limit: int = Query(default=100, ge=1, le=500),
+) -> list[NotificationLog]:
+    stmt = select(NotificationLog).order_by(NotificationLog.sent_at.desc()).limit(limit)
+    if rule_id is not None:
+        stmt = stmt.where(NotificationLog.rule_id == rule_id)
+    if status_filter is not None:
+        stmt = stmt.where(NotificationLog.status == status_filter)
+    return list((await session.execute(stmt)).scalars().all())
+
+
+@router.post(
+    "/test",
+    response_model=TestSendResponse,
+    summary="Testnachricht senden",
+    description="Verschickt eine Testnachricht über beide Kanäle. Nicht eingerichtete "
+    "Kanäle werden gemeldet, gelten aber nicht als Fehler.",
+)
+async def send_test_notification(payload: TestSendRequest | None = None) -> TestSendResponse:
+    ergebnisse = await send_test(payload.target if payload else None)
+    return TestSendResponse(
+        results=[TestResultOut.model_validate(eintrag) for eintrag in ergebnisse],
+        any_sent=any(eintrag.sent for eintrag in ergebnisse),
+    )
+
+
+@router.post(
+    "/run",
+    response_model=RunResponse,
+    summary="Lauf sofort ausführen",
+    description="Führt alle aktiven Regeln aus, ohne auf den Zeitplan zu warten. "
+    "Bereits gemeldete Ereignisse werden dabei übersprungen.",
+)
+async def run_now(
+    session: DbSession,
+    as_of: date | None = Query(default=None, description="Stichtag; Vorgabe ist heute."),
+) -> RunResponse:
+    ergebnis = await run_all(session, as_of)
+    return RunResponse(
+        checked=ergebnis.checked,
+        sent=ergebnis.sent,
+        skipped=ergebnis.skipped,
+        failed=ergebnis.failed,
+    )

backend/app/main.py

@@ -11,6 +11,7 @@ from app.api.router import api_router
 from app.core.config import settings
 from app.core.errors import register_exception_handlers
 from app.db.session import SessionLocal, engine
+from app.scheduler import shutdown_scheduler, start_scheduler
 from app.services.auth import ensure_admin_user, purge_expired_refresh_tokens
 
 logging.basicConfig(
@@ -25,8 +26,10 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
     """Start- und Stopplogik der Anwendung."""
     settings.logo_storage_dir.mkdir(parents=True, exist_ok=True)
     await _bootstrap()
+    start_scheduler()
     logger.info("moneyfy %s gestartet (%s)", settings.app_version, settings.environment)
     yield
+    shutdown_scheduler()
     await engine.dispose()
     logger.info("moneyfy wird beendet")
 

backend/app/scheduler.py

@@ -0,0 +1,93 @@
+"""Zeitgesteuerte Aufgaben.
+
+APScheduler läuft im selben Prozess wie die Anwendung – kein Redis, kein Celery.
+Der tägliche Lauf prüft die Benachrichtigungsregeln und räumt abgelaufene
+Sitzungen auf.
+"""
+
+import logging
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from app.core.clock import tz
+from app.core.config import settings
+from app.db.session import SessionLocal
+from app.services.auth import purge_expired_refresh_tokens
+from app.services.notifications import run_all
+
+logger = logging.getLogger(__name__)
+
+DAILY_JOB_ID = "moneyfy-daily"
+
+_scheduler: AsyncIOScheduler | None = None
+
+
+async def daily_job() -> None:
+    """Täglicher Lauf. Fehler werden protokolliert, beenden den Scheduler aber nicht."""
+    try:
+        async with SessionLocal() as session:
+            await run_all(session)
+
+            entfernt = await purge_expired_refresh_tokens(session)
+            await session.commit()
+            if entfernt:
+                logger.info("%d abgelaufene Sitzungen entfernt.", entfernt)
+    except Exception:
+        logger.exception("Der tägliche Lauf ist fehlgeschlagen.")
+
+
+def start_scheduler() -> AsyncIOScheduler | None:
+    """Startet den Scheduler, sofern er eingeschaltet ist."""
+    global _scheduler
+
+    if not settings.scheduler_enabled:
+        logger.info("Scheduler ist abgeschaltet (SCHEDULER_ENABLED=false).")
+        return None
+    if _scheduler is not None:
+        return _scheduler
+
+    _scheduler = AsyncIOScheduler(timezone=tz())
+    _scheduler.add_job(
+        daily_job,
+        CronTrigger(
+            hour=settings.notification_hour,
+            minute=settings.notification_minute,
+            timezone=tz(),
+        ),
+        id=DAILY_JOB_ID,
+        name="Benachrichtigungen und Aufräumen",
+        # Verpasste Läufe (etwa nach einem Neustart) einmal nachholen.
+        misfire_grace_time=3600,
+        coalesce=True,
+        max_instances=1,
+        replace_existing=True,
+    )
+    _scheduler.start()
+
+    logger.info(
+        "Scheduler gestartet – täglicher Lauf um %02d:%02d %s.",
+        settings.notification_hour,
+        settings.notification_minute,
+        settings.timezone,
+    )
+    return _scheduler
+
+
+def shutdown_scheduler() -> None:
+    """Hält den Scheduler beim Beenden der Anwendung an."""
+    global _scheduler
+
+    if _scheduler is None:
+        return
+    _scheduler.shutdown(wait=False)
+    _scheduler = None
+    logger.info("Scheduler beendet.")
+
+
+def next_run_time():
+    """Nächster geplanter Lauf, für die Anzeige in den Einstellungen."""
+    if _scheduler is None:
+        return None
+    job = _scheduler.get_job(DAILY_JOB_ID)
+    return job.next_run_time if job else None

backend/app/schemas/notification.py

@@ -0,0 +1,113 @@
+"""Schemata für Benachrichtigungsregeln, Protokoll und Testversand."""
+
+from datetime import date, datetime
+
+from pydantic import Field
+
+from app.models.enums import (
+    NotificationChannel,
+    NotificationStatus,
+    NotificationType,
+)
+from app.schemas.common import ApiModel, InputModel
+
+TYPE_HINTS = {
+    "due_soon": "Fälligkeiten innerhalb der Vorlaufzeit.",
+    "notice_deadline": "Kündigungsfristen, die in 30, 14 oder 7 Tagen ablaufen.",
+    "budget_exceeded": "Überschrittene Budgets, einmal je Monat und Kategorie.",
+    "contract_renewal": "Verträge, die sich im kommenden Monat verlängern.",
+}
+
+
+class NotificationRuleCreate(InputModel):
+    type: NotificationType = Field(
+        description="; ".join(f"{k}: {v}" for k, v in TYPE_HINTS.items())
+    )
+    channel: NotificationChannel
+    lead_days: int = Field(
+        default=7, ge=0, le=365, description="Vorlauf in Tagen; nur für `due_soon` maßgeblich."
+    )
+    target: str | None = Field(
+        default=None,
+        description="Mailadresse bzw. Apprise-URL. Ohne Angabe gelten SMTP_FROM "
+        "beziehungsweise APPRISE_URLS.",
+    )
+    is_active: bool = True
+
+
+class NotificationRuleUpdate(InputModel):
+    lead_days: int | None = Field(default=None, ge=0, le=365)
+    channel: NotificationChannel | None = None
+    target: str | None = None
+    is_active: bool | None = None
+
+
+class NotificationRuleOut(ApiModel):
+    id: int
+    type: NotificationType
+    channel: NotificationChannel
+    lead_days: int
+    target: str | None
+    is_active: bool
+    created_at: datetime
+
+
+class NotificationLogOut(ApiModel):
+    """Ein Eintrag des Versandprotokolls."""
+
+    id: int
+    rule_id: int
+    ref_type: str
+    ref_id: str
+    dedupe_day: date = Field(
+        description="Zieltag des Ereignisses – Grundlage des Duplikatsschutzes."
+    )
+    sent_at: datetime
+    status: NotificationStatus
+    error: str | None
+
+
+class ChannelStatusOut(ApiModel):
+    """Einrichtungsstand eines Kanals."""
+
+    channel: NotificationChannel
+    configured: bool
+    detail: str
+
+
+class NotificationSettingsOut(ApiModel):
+    """Überblick über Kanäle und Zeitplan."""
+
+    enabled: bool
+    scheduler_enabled: bool
+    run_at: str = Field(description="Uhrzeit des täglichen Laufs, etwa '07:00'.")
+    timezone: str
+    next_run_at: datetime | None
+    channels: list[ChannelStatusOut]
+
+
+class TestSendRequest(InputModel):
+    target: str | None = Field(
+        default=None, description="Abweichendes Ziel; ohne Angabe gelten die Einstellungen."
+    )
+
+
+class TestResultOut(ApiModel):
+    channel: NotificationChannel
+    configured: bool
+    sent: bool
+    error: str | None = None
+
+
+class TestSendResponse(ApiModel):
+    results: list[TestResultOut]
+    any_sent: bool = Field(description="True, wenn mindestens ein Kanal zugestellt hat.")
+
+
+class RunResponse(ApiModel):
+    """Ergebnis eines manuell ausgelösten Laufs."""
+
+    checked: int
+    sent: int
+    skipped: int = Field(description="Bereits gemeldete Ereignisse.")
+    failed: int

backend/app/services/channels.py

@@ -0,0 +1,196 @@
+"""Versandkanäle für Benachrichtigungen: SMTP und Apprise.
+
+Beide Bibliotheken arbeiten blockierend; die Aufrufe laufen deshalb in einem
+Thread, damit der Scheduler-Job den Event-Loop nicht anhält. Ein Kanal wirft
+`ChannelError`, wenn der Versand fehlschlägt – der Aufrufer protokolliert das.
+"""
+
+import asyncio
+import logging
+import smtplib
+from dataclasses import dataclass, field
+from email.message import EmailMessage
+from email.utils import make_msgid
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from app.core.config import settings
+from app.models.enums import NotificationChannel
+
+logger = logging.getLogger(__name__)
+
+SMTP_TIMEOUT_SECONDS = 20
+
+
+class ChannelError(RuntimeError):
+    """Der Versand über einen Kanal ist fehlgeschlagen."""
+
+
+@dataclass(frozen=True, slots=True)
+class Attachment:
+    """Ein eingebettetes Bild, das per Content-ID in der HTML-Mail steckt."""
+
+    cid: str
+    """Ohne spitze Klammern – im HTML als `cid:<wert>` referenziert."""
+    path: Path
+    mime: str
+
+
+@dataclass(slots=True)
+class Notification:
+    """Eine fertig formulierte Nachricht."""
+
+    subject: str
+    text: str
+    html: str | None = None
+    attachments: list[Attachment] = field(default_factory=list)
+
+
+@runtime_checkable
+class Channel(Protocol):
+    """Ein Weg, auf dem eine Nachricht den Nutzer erreicht."""
+
+    kind: NotificationChannel
+
+    def is_configured(self) -> bool:
+        """False, wenn die nötigen Einstellungen fehlen – der Kanal wird übersprungen."""
+        ...
+
+    async def send(self, notification: Notification, target: str | None = None) -> None: ...
+
+
+# --- SMTP ----------------------------------------------------------------------
+
+
+class SmtpChannel:
+    """Mailversand über einen SMTP-Server."""
+
+    kind = NotificationChannel.SMTP
+
+    def is_configured(self) -> bool:
+        return bool(settings.smtp_host and settings.smtp_from)
+
+    async def send(self, notification: Notification, target: str | None = None) -> None:
+        if not self.is_configured():
+            raise ChannelError("SMTP ist nicht konfiguriert (SMTP_HOST und SMTP_FROM fehlen).")
+
+        empfaenger = target or settings.smtp_from
+        if not empfaenger:
+            raise ChannelError("Kein Empfänger angegeben.")
+
+        nachricht = self._build(notification, empfaenger)
+        try:
+            await asyncio.to_thread(self._deliver, nachricht)
+        except ChannelError:
+            raise
+        except Exception as exc:
+            raise ChannelError(f"Mailversand fehlgeschlagen: {exc}") from exc
+
+    def _build(self, notification: Notification, empfaenger: str) -> EmailMessage:
+        """Baut eine Mail mit Text- und HTML-Teil sowie eingebetteten Logos."""
+        nachricht = EmailMessage()
+        nachricht["Subject"] = notification.subject
+        nachricht["From"] = settings.smtp_from or ""
+        nachricht["To"] = empfaenger
+        nachricht.set_content(notification.text)
+
+        if notification.html is None:
+            return nachricht
+
+        html = notification.html
+        anhaenge: list[tuple[Attachment, str]] = []
+        for anhang in notification.attachments:
+            # Für jedes Bild eine echte Message-ID erzeugen und im HTML einsetzen.
+            message_id = make_msgid()
+            html = html.replace(f"cid:{anhang.cid}", f"cid:{message_id[1:-1]}")
+            anhaenge.append((anhang, message_id))
+
+        nachricht.add_alternative(html, subtype="html")
+        html_teil = nachricht.get_payload()[-1]
+
+        for anhang, message_id in anhaenge:
+            try:
+                inhalt = anhang.path.read_bytes()
+            except OSError:
+                logger.debug("Anhang %s konnte nicht gelesen werden.", anhang.path)
+                continue
+            haupttyp, _, untertyp = anhang.mime.partition("/")
+            html_teil.add_related(inhalt, maintype=haupttyp, subtype=untertyp, cid=message_id)
+
+        return nachricht
+
+    def _deliver(self, nachricht: EmailMessage) -> None:
+        """Blockierender Teil des Versands."""
+        host = settings.smtp_host or ""
+        port = settings.smtp_port
+
+        if settings.smtp_use_ssl:
+            verbindung = smtplib.SMTP_SSL(host, port, timeout=SMTP_TIMEOUT_SECONDS)
+        else:
+            verbindung = smtplib.SMTP(host, port, timeout=SMTP_TIMEOUT_SECONDS)
+
+        with verbindung as server:
+            if settings.smtp_use_tls and not settings.smtp_use_ssl:
+                server.starttls()
+            if settings.smtp_user and settings.smtp_password:
+                server.login(settings.smtp_user, settings.smtp_password)
+            server.send_message(nachricht)
+
+
+# --- Apprise -------------------------------------------------------------------
+
+
+class AppriseChannel:
+    """Versand über Apprise – deckt ntfy, Gotify, Matrix, Discord und viele mehr ab."""
+
+    kind = NotificationChannel.APPRISE
+
+    def is_configured(self) -> bool:
+        return bool(settings.apprise_url_list)
+
+    async def send(self, notification: Notification, target: str | None = None) -> None:
+        # Eine Regel kann ein eigenes Ziel vorgeben, sonst gelten die globalen URLs.
+        ziele = [target] if target else settings.apprise_url_list
+        if not ziele:
+            raise ChannelError("Apprise ist nicht konfiguriert (APPRISE_URLS fehlt).")
+
+        try:
+            erfolg = await asyncio.to_thread(self._deliver, notification, ziele)
+        except Exception as exc:
+            raise ChannelError(f"Apprise-Versand fehlgeschlagen: {exc}") from exc
+
+        if not erfolg:
+            raise ChannelError("Apprise konnte die Nachricht an kein Ziel zustellen.")
+
+    def _deliver(self, notification: Notification, ziele: list[str]) -> bool:
+        import apprise
+
+        sammlung = apprise.Apprise()
+        for ziel in ziele:
+            if not sammlung.add(ziel):
+                logger.warning("Apprise-Ziel konnte nicht gelesen werden: %s", ziel)
+
+        if len(sammlung) == 0:
+            raise ChannelError("Kein gültiges Apprise-Ziel.")
+
+        return bool(sammlung.notify(title=notification.subject, body=notification.text))
+
+
+# --- Registrierung -------------------------------------------------------------
+
+_CHANNELS: dict[NotificationChannel, Channel] = {
+    NotificationChannel.SMTP: SmtpChannel(),
+    NotificationChannel.APPRISE: AppriseChannel(),
+}
+
+
+def get_channel(kind: NotificationChannel) -> Channel:
+    kanal = _CHANNELS.get(kind)
+    if kanal is None:  # pragma: no cover - alle Enum-Werte sind registriert
+        raise ChannelError(f"Unbekannter Kanal: {kind}")
+    return kanal
+
+
+def configured_channels() -> list[Channel]:
+    """Alle Kanäle, die tatsächlich einsatzbereit sind."""
+    return [kanal for kanal in _CHANNELS.values() if kanal.is_configured()]

backend/app/services/notifications.py

@@ -0,0 +1,533 @@
+"""Benachrichtigungen: Ereignisse sammeln, Duplikate ausschließen, versenden.
+
+Der Duplikatsschutz hängt nicht am Versandtag, sondern am Zieltag des Ereignisses:
+Eine Fälligkeit am 15.03. wird genau einmal gemeldet, egal an welchem Tag des
+Vorlaufs der Job läuft. Ein zweiter Lauf am selben Tag erzeugt daher ebenso wenig
+eine zweite Nachricht wie ein Lauf am Folgetag.
+"""
+
+import logging
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from decimal import Decimal
+from html import escape
+from pathlib import Path
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.clock import add_months, month_end, month_start, today, utcnow
+from app.core.config import settings
+from app.models import LogoAsset, Merchant, NotificationLog, NotificationRule
+from app.models.enums import (
+    EntryKind,
+    NotificationChannel,
+    NotificationStatus,
+    NotificationType,
+)
+from app.services.channels import Attachment, ChannelError, Notification, get_channel
+from app.services.occurrences import load_recurrences
+from app.services.recurrence import contract_term
+from app.services.reports import budget_status, flows
+
+logger = logging.getLogger(__name__)
+
+ZERO = Decimal("0.00")
+
+# Vorlaufstufen für Kündigungsfristen gemäß Fachspezifikation.
+NOTICE_STAGES = (30, 14, 7)
+
+REF_OCCURRENCE = "occurrence"
+REF_RECURRENCE = "recurrence"
+REF_BUDGET = "budget"
+
+TYPE_LABELS: dict[NotificationType, str] = {
+    NotificationType.DUE_SOON: "Bald fällig",
+    NotificationType.NOTICE_DEADLINE: "Kündigungsfrist läuft ab",
+    NotificationType.BUDGET_EXCEEDED: "Budget überschritten",
+    NotificationType.CONTRACT_RENEWAL: "Vertrag verlängert sich",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    """Ein meldenswertes Ereignis."""
+
+    ref_type: str
+    ref_id: str
+    """Stabiler Schlüssel innerhalb des ref_type."""
+    dedupe_day: date
+    """Zieltag des Ereignisses – nicht der Versandtag."""
+    headline: str
+    detail: str
+    amount: Decimal | None = None
+    merchant_id: int | None = None
+    on: date | None = None
+
+
+@dataclass(slots=True)
+class RunResult:
+    """Ergebnis eines Laufs."""
+
+    checked: int = 0
+    sent: int = 0
+    skipped: int = 0
+    failed: int = 0
+    by_rule: dict[int, int] = field(default_factory=dict)
+
+
+# --- Ereignisse sammeln --------------------------------------------------------
+
+
+def _money(amount: Decimal | None) -> str:
+    if amount is None:
+        return ""
+    return f"{amount:,.2f} €".replace(",", "#").replace(".", ",").replace("#", ".")
+
+
+def _day(value: date) -> str:
+    return value.strftime("%d.%m.%Y")
+
+
+async def collect_due_soon(
+    session: AsyncSession, rule: NotificationRule, as_of: date
+) -> list[Event]:
+    """Fälligkeiten innerhalb des Vorlaufs."""
+    ende = as_of + timedelta(days=max(rule.lead_days, 0))
+
+    ereignisse: list[Event] = []
+    for eintrag in await flows(session, as_of, ende):
+        # Einmalige Buchungen sind bereits erfasst und brauchen keine Erinnerung.
+        if eintrag.source != "recurrence" or eintrag.recurrence_id is None:
+            continue
+        if eintrag.is_confirmed:
+            continue
+
+        richtung = "Einkunft" if eintrag.kind is EntryKind.INCOME else "Zahlung"
+        ereignisse.append(
+            Event(
+                ref_type=REF_OCCURRENCE,
+                ref_id=f"{eintrag.recurrence_id}:{eintrag.occurrence_date}",
+                dedupe_day=eintrag.on,
+                headline=eintrag.title,
+                detail=f"{richtung} am {_day(eintrag.on)} über {_money(eintrag.amount)}",
+                amount=eintrag.amount,
+                merchant_id=eintrag.merchant_id,
+                on=eintrag.on,
+            )
+        )
+    return ereignisse
+
+
+async def collect_notice_deadlines(
+    session: AsyncSession, rule: NotificationRule, as_of: date
+) -> list[Event]:
+    """Kündigungsfristen, die in 30, 14 oder 7 Tagen ablaufen.
+
+    Jede Stufe wird einmal gemeldet; der Schlüssel enthält deshalb die Stufe.
+    """
+    # Aufsteigend, damit die *engste* zutreffende Stufe gewinnt: bei 14 Resttagen
+    # ist es die 14er-Stufe, nicht erneut die 30er.
+    stufen = sorted({*NOTICE_STAGES, rule.lead_days} - {0})
+
+    ereignisse: list[Event] = []
+    for recurrence in await load_recurrences(session):
+        if recurrence.contract_cancelled_at is not None:
+            continue
+        laufzeit = contract_term(recurrence, as_of)
+        if laufzeit is None or laufzeit.notice_deadline is None:
+            continue
+
+        verbleibend = (laufzeit.notice_deadline - as_of).days
+        if verbleibend < 0:
+            continue
+
+        # Die erste Stufe, die der Termin gerade erreicht oder unterschritten hat.
+        stufe = next((wert for wert in stufen if verbleibend <= wert), None)
+        if stufe is None:
+            continue
+
+        ereignisse.append(
+            Event(
+                ref_type=REF_RECURRENCE,
+                ref_id=f"{recurrence.id}:{stufe}",
+                dedupe_day=laufzeit.notice_deadline,
+                headline=recurrence.title,
+                detail=(
+                    f"Kündigung bis {_day(laufzeit.notice_deadline)} möglich "
+                    f"(noch {verbleibend} Tage), Laufzeit endet am {_day(laufzeit.term_end)}"
+                ),
+                amount=recurrence.amount,
+                merchant_id=recurrence.merchant_id,
+                on=laufzeit.notice_deadline,
+            )
+        )
+    return ereignisse
+
+
+async def collect_budget_exceeded(
+    session: AsyncSession, rule: NotificationRule, as_of: date
+) -> list[Event]:
+    """Überschrittene Budgets – höchstens einmal je Monat und Kategorie."""
+    monat = month_start(as_of)
+
+    return [
+        Event(
+            ref_type=REF_BUDGET,
+            ref_id=str(eintrag.category_id),
+            dedupe_day=monat,
+            headline=eintrag.category_name,
+            detail=(
+                f"{_money(eintrag.spent)} von {_money(eintrag.available)} verbraucht "
+                f"({round(float(eintrag.ratio) * 100)} %), "
+                f"{_money(abs(eintrag.remaining))} zu viel"
+            ),
+            amount=eintrag.spent,
+            on=month_end(monat),
+        )
+        for eintrag in await budget_status(session, monat)
+        if eintrag.state == "exceeded"
+    ]
+
+
+async def collect_contract_renewals(
+    session: AsyncSession, rule: NotificationRule, as_of: date
+) -> list[Event]:
+    """Verträge, die sich im kommenden Monat automatisch verlängern."""
+    fenster_ende = month_end(add_months(as_of, 1))
+
+    ereignisse: list[Event] = []
+    for recurrence in await load_recurrences(session):
+        if recurrence.contract_cancelled_at is not None:
+            continue
+        laufzeit = contract_term(recurrence, as_of)
+        if laufzeit is None or laufzeit.renews_on is None:
+            continue
+        if not as_of <= laufzeit.renews_on <= fenster_ende:
+            continue
+
+        verlaengerung = recurrence.contract_auto_renew_months
+        ereignisse.append(
+            Event(
+                ref_type=REF_RECURRENCE,
+                ref_id=str(recurrence.id),
+                dedupe_day=laufzeit.renews_on,
+                headline=recurrence.title,
+                detail=(
+                    f"Verlängert sich am {_day(laufzeit.renews_on)}"
+                    + (f" um {verlaengerung} Monate" if verlaengerung else "")
+                ),
+                amount=recurrence.amount,
+                merchant_id=recurrence.merchant_id,
+                on=laufzeit.renews_on,
+            )
+        )
+    return ereignisse
+
+
+COLLECTORS = {
+    NotificationType.DUE_SOON: collect_due_soon,
+    NotificationType.NOTICE_DEADLINE: collect_notice_deadlines,
+    NotificationType.BUDGET_EXCEEDED: collect_budget_exceeded,
+    NotificationType.CONTRACT_RENEWAL: collect_contract_renewals,
+}
+
+
+# --- Nachricht bauen -----------------------------------------------------------
+
+
+async def _logo_attachments(session: AsyncSession, events: list[Event]) -> dict[int, Attachment]:
+    """Lädt die Logodateien der beteiligten Firmen für den Mailanhang."""
+    firmen_ids = {ereignis.merchant_id for ereignis in events if ereignis.merchant_id}
+    if not firmen_ids:
+        return {}
+
+    stmt = (
+        select(Merchant, LogoAsset)
+        .join(LogoAsset, LogoAsset.id == Merchant.logo_asset_id)
+        .where(Merchant.id.in_(firmen_ids))
+    )
+
+    anhaenge: dict[int, Attachment] = {}
+    for merchant, asset in (await session.execute(stmt)).all():
+        pfad = Path(settings.logo_storage_dir) / asset.file_path
+        if not pfad.exists():
+            continue
+        anhaenge[merchant.id] = Attachment(cid=f"logo-{merchant.id}", path=pfad, mime=asset.mime)
+    return anhaenge
+
+
+def build_notification(
+    rule_type: NotificationType,
+    events: list[Event],
+    attachments: dict[int, Attachment],
+) -> Notification:
+    """Formuliert aus den Ereignissen eine Nachricht in Text und HTML."""
+    ueberschrift = TYPE_LABELS[rule_type]
+    betreff = (
+        f"moneyfy: {ueberschrift}"
+        if len(events) == 1
+        else f"moneyfy: {ueberschrift} ({len(events)})"
+    )
+
+    text_zeilen = [ueberschrift, ""]
+    for ereignis in events:
+        text_zeilen.append(f"• {ereignis.headline}: {ereignis.detail}")
+    text_zeilen.extend(["", settings.public_base_url])
+
+    zeilen_html: list[str] = []
+    for ereignis in events:
+        anhang = attachments.get(ereignis.merchant_id or -1)
+        bild = (
+            f'<img src="cid:{anhang.cid}" alt="" width="28" height="28" '
+            'style="border-radius:6px;vertical-align:middle;margin-right:10px">'
+            if anhang
+            else ""
+        )
+        zeilen_html.append(
+            '<tr><td style="padding:10px 0;border-bottom:1px solid #e2e8f0">'
+            f"{bild}"
+            f'<strong style="color:#0f172a">{escape(ereignis.headline)}</strong><br>'
+            f'<span style="color:#475569;font-size:14px">{escape(ereignis.detail)}</span>'
+            "</td></tr>"
+        )
+
+    html = f"""<!doctype html>
+<html lang="de"><body style="margin:0;padding:24px;background:#f8fafc;
+  font-family:system-ui,-apple-system,'Segoe UI',Roboto,sans-serif">
+  <div style="max-width:560px;margin:0 auto;background:#ffffff;border-radius:14px;
+    border:1px solid #e2e8f0;padding:24px">
+    <h1 style="margin:0 0 4px;font-size:18px;color:#0f172a">{escape(ueberschrift)}</h1>
+    <p style="margin:0 0 16px;font-size:13px;color:#64748b">
+      {len(events)} {"Eintrag" if len(events) == 1 else "Einträge"}
+    </p>
+    <table style="width:100%;border-collapse:collapse">{"".join(zeilen_html)}</table>
+    <p style="margin:20px 0 0;font-size:13px">
+      <a href="{escape(settings.public_base_url)}" style="color:#16a34a">In moneyfy öffnen</a>
+    </p>
+  </div>
+</body></html>"""
+
+    beteiligte = {
+        ereignis.merchant_id for ereignis in events if ereignis.merchant_id in attachments
+    }
+    return Notification(
+        subject=betreff,
+        text="\n".join(text_zeilen),
+        html=html,
+        attachments=[attachments[firma_id] for firma_id in beteiligte if firma_id],
+    )
+
+
+# --- Versand und Protokoll -----------------------------------------------------
+
+
+async def _existing_log(
+    session: AsyncSession, rule_id: int, event: Event
+) -> NotificationLog | None:
+    stmt = select(NotificationLog).where(
+        NotificationLog.rule_id == rule_id,
+        NotificationLog.ref_type == event.ref_type,
+        NotificationLog.ref_id == event.ref_id,
+        NotificationLog.dedupe_day == event.dedupe_day,
+    )
+    return (await session.execute(stmt)).scalar_one_or_none()
+
+
+async def pending_events(
+    session: AsyncSession, rule: NotificationRule, as_of: date
+) -> tuple[list[Event], list[Event], dict[str, NotificationLog]]:
+    """Trennt neue Ereignisse von bereits gemeldeten.
+
+    Ein zuvor fehlgeschlagener Versand gilt als offen und wird erneut versucht;
+    der vorhandene Protokolleintrag wird dabei aktualisiert statt neu angelegt.
+    """
+    sammler = COLLECTORS[rule.type]
+    alle = await sammler(session, rule, as_of)
+
+    offen: list[Event] = []
+    erledigt: list[Event] = []
+    vorhandene: dict[str, NotificationLog] = {}
+
+    for ereignis in alle:
+        eintrag = await _existing_log(session, rule.id, ereignis)
+        if eintrag is None:
+            offen.append(ereignis)
+            continue
+        if eintrag.status is NotificationStatus.FAILED:
+            offen.append(ereignis)
+            vorhandene[f"{ereignis.ref_type}:{ereignis.ref_id}"] = eintrag
+            continue
+        erledigt.append(ereignis)
+
+    return offen, erledigt, vorhandene
+
+
+async def _record(
+    session: AsyncSession,
+    rule: NotificationRule,
+    events: list[Event],
+    existing: dict[str, NotificationLog],
+    status: NotificationStatus,
+    error: str | None,
+) -> None:
+    """Schreibt das Versandprotokoll für alle Ereignisse einer Nachricht."""
+    zeitpunkt = utcnow()
+    for ereignis in events:
+        schluessel = f"{ereignis.ref_type}:{ereignis.ref_id}"
+        eintrag = existing.get(schluessel)
+        if eintrag is not None:
+            eintrag.status = status
+            eintrag.error = error
+            eintrag.sent_at = zeitpunkt
+            continue
+
+        session.add(
+            NotificationLog(
+                rule_id=rule.id,
+                ref_type=ereignis.ref_type,
+                ref_id=ereignis.ref_id,
+                dedupe_day=ereignis.dedupe_day,
+                sent_at=zeitpunkt,
+                status=status,
+                error=error,
+            )
+        )
+    await session.flush()
+
+
+async def run_rule(
+    session: AsyncSession, rule: NotificationRule, as_of: date | None = None
+) -> tuple[int, int, int]:
+    """Führt eine Regel aus. Liefert (geprüft, versendet, übersprungen)."""
+    stichtag = as_of or today()
+    offen, erledigt, vorhandene = await pending_events(session, rule, stichtag)
+
+    if not offen:
+        return len(offen) + len(erledigt), 0, len(erledigt)
+
+    anhaenge = await _logo_attachments(session, offen)
+    nachricht = build_notification(rule.type, offen, anhaenge)
+
+    try:
+        await get_channel(rule.channel).send(nachricht, rule.target)
+    except ChannelError as fehler:
+        logger.warning("Regel %s konnte nicht zugestellt werden: %s", rule.id, fehler)
+        await _record(session, rule, offen, vorhandene, NotificationStatus.FAILED, str(fehler))
+        return len(offen) + len(erledigt), 0, len(erledigt)
+
+    await _record(session, rule, offen, vorhandene, NotificationStatus.SENT, None)
+    return len(offen) + len(erledigt), len(offen), len(erledigt)
+
+
+async def run_all(session: AsyncSession, as_of: date | None = None) -> RunResult:
+    """Führt alle aktiven Regeln aus – der tägliche Lauf des Schedulers."""
+    if not settings.notifications_enabled:
+        logger.info("Benachrichtigungen sind abgeschaltet.")
+        return RunResult()
+
+    stichtag = as_of or today()
+    stmt = select(NotificationRule).where(NotificationRule.is_active.is_(True))
+    regeln = list((await session.execute(stmt)).scalars())
+
+    ergebnis = RunResult()
+    for regel in regeln:
+        try:
+            geprueft, versendet, uebersprungen = await run_rule(session, regel, stichtag)
+        except Exception:
+            # Eine fehlerhafte Regel darf die übrigen nicht verhindern.
+            logger.exception("Regel %s ist fehlgeschlagen.", regel.id)
+            ergebnis.failed += 1
+            continue
+
+        ergebnis.checked += geprueft
+        ergebnis.sent += versendet
+        ergebnis.skipped += uebersprungen
+        if versendet:
+            ergebnis.by_rule[regel.id] = versendet
+
+    await session.commit()
+    logger.info(
+        "Benachrichtigungslauf: %d geprüft, %d versendet, %d übersprungen, %d fehlerhaft.",
+        ergebnis.checked,
+        ergebnis.sent,
+        ergebnis.skipped,
+        ergebnis.failed,
+    )
+    return ergebnis
+
+
+# --- Testversand ---------------------------------------------------------------
+
+
+def test_notification() -> Notification:
+    """Eine kurze Nachricht, mit der sich die Einrichtung prüfen lässt."""
+    zeitpunkt = utcnow().astimezone().strftime("%d.%m.%Y um %H:%M Uhr")
+    return Notification(
+        subject="moneyfy: Testnachricht",
+        text=(
+            "Das ist eine Testnachricht von moneyfy.\n"
+            f"Gesendet am {zeitpunkt}.\n\n"
+            "Wenn du sie liest, ist der Kanal richtig eingerichtet.\n\n"
+            f"{settings.public_base_url}"
+        ),
+        html=f"""<!doctype html>
+<html lang="de"><body style="margin:0;padding:24px;background:#f8fafc;
+  font-family:system-ui,-apple-system,'Segoe UI',Roboto,sans-serif">
+  <div style="max-width:560px;margin:0 auto;background:#ffffff;border-radius:14px;
+    border:1px solid #e2e8f0;padding:24px">
+    <h1 style="margin:0 0 8px;font-size:18px;color:#0f172a">Testnachricht</h1>
+    <p style="margin:0;font-size:14px;color:#475569">
+      Wenn du das liest, ist der Kanal richtig eingerichtet.<br>
+      Gesendet am {zeitpunkt}.
+    </p>
+    <p style="margin:20px 0 0;font-size:13px">
+      <a href="{escape(settings.public_base_url)}" style="color:#16a34a">moneyfy öffnen</a>
+    </p>
+  </div>
+</body></html>""",
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class TestResult:
+    """Ergebnis eines Testversands je Kanal."""
+
+    channel: NotificationChannel
+    configured: bool
+    sent: bool
+    error: str | None = None
+
+
+async def send_test(target: str | None = None) -> list[TestResult]:
+    """Verschickt eine Testnachricht über beide Kanäle.
+
+    Nicht eingerichtete Kanäle werden gemeldet, aber nicht als Fehler gewertet.
+    """
+    nachricht = test_notification()
+
+    ergebnisse: list[TestResult] = []
+    for art in (NotificationChannel.SMTP, NotificationChannel.APPRISE):
+        kanal = get_channel(art)
+        if not kanal.is_configured():
+            ergebnisse.append(TestResult(channel=art, configured=False, sent=False))
+            continue
+        try:
+            await kanal.send(nachricht, target)
+        except ChannelError as fehler:
+            ergebnisse.append(
+                TestResult(channel=art, configured=True, sent=False, error=str(fehler))
+            )
+            continue
+        ergebnisse.append(TestResult(channel=art, configured=True, sent=True))
+
+    return ergebnisse
+
+
+def group_by_type(events: list[Event]) -> dict[str, list[Event]]:
+    """Hilfsfunktion für Vorschauen in der Oberfläche."""
+    gruppen: dict[str, list[Event]] = defaultdict(list)
+    for ereignis in events:
+        gruppen[ereignis.ref_type].append(ereignis)
+    return dict(gruppen)

backend/tests/test_notifications.py

@@ -0,0 +1,544 @@
+"""Tests der Benachrichtigungen: Ereignisse, Duplikatsschutz und Versand."""
+
+import smtplib
+from datetime import date, timedelta
+from email.message import EmailMessage
+from typing import ClassVar
+
+import pytest
+from httpx import AsyncClient
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import settings
+from app.models import NotificationLog, NotificationRule
+from app.models.enums import NotificationChannel, NotificationStatus, NotificationType
+from app.services import notifications as service
+from app.services.channels import AppriseChannel, ChannelError, SmtpChannel
+
+
+def text_of(nachricht: EmailMessage) -> str:
+    """Der reine Textteil einer mehrteiligen Mail."""
+    teil = nachricht.get_body(preferencelist=("plain",))
+    assert teil is not None, "Die Mail hat keinen Textteil."
+    return teil.get_content()
+
+
+# --- Doppel für die Kanäle ------------------------------------------------------
+
+
+class FakeSmtp:
+    """Ersetzt `smtplib.SMTP` und merkt sich die versendeten Nachrichten."""
+
+    versendet: ClassVar[list[EmailMessage]] = []
+    fehler: ClassVar[Exception | None] = None
+
+    def __init__(self, host: str, port: int, timeout: int = 0) -> None:
+        self.host = host
+        self.port = port
+
+    def __enter__(self) -> "FakeSmtp":
+        return self
+
+    def __exit__(self, *_args: object) -> None:
+        return None
+
+    def starttls(self) -> None:
+        return None
+
+    def login(self, user: str, password: str) -> None:
+        return None
+
+    def send_message(self, nachricht: EmailMessage) -> None:
+        if FakeSmtp.fehler is not None:
+            raise FakeSmtp.fehler
+        FakeSmtp.versendet.append(nachricht)
+
+
+class FakeApprise:
+    """Ersetzt `apprise.Apprise`."""
+
+    versendet: ClassVar[list[tuple[str, str]]] = []
+    erfolg: ClassVar[bool] = True
+
+    def __init__(self) -> None:
+        self.ziele: list[str] = []
+
+    def add(self, ziel: str) -> bool:
+        self.ziele.append(ziel)
+        return True
+
+    def __len__(self) -> int:
+        return len(self.ziele)
+
+    def notify(self, title: str, body: str) -> bool:
+        if FakeApprise.erfolg:
+            FakeApprise.versendet.append((title, body))
+        return FakeApprise.erfolg
+
+
+@pytest.fixture
+def smtp(monkeypatch: pytest.MonkeyPatch) -> type[FakeSmtp]:
+    """Richtet SMTP ein und fängt den Versand ab."""
+    FakeSmtp.versendet = []
+    FakeSmtp.fehler = None
+    monkeypatch.setattr(smtplib, "SMTP", FakeSmtp)
+    monkeypatch.setattr(settings, "smtp_host", "mail.example.org")
+    monkeypatch.setattr(settings, "smtp_from", "moneyfy@example.org")
+    monkeypatch.setattr(settings, "smtp_use_tls", False)
+    monkeypatch.setattr(settings, "smtp_use_ssl", False)
+    return FakeSmtp
+
+
+@pytest.fixture
+def apprise(monkeypatch: pytest.MonkeyPatch) -> type[FakeApprise]:
+    """Richtet Apprise ein und fängt den Versand ab."""
+    import apprise as apprise_modul
+
+    FakeApprise.versendet = []
+    FakeApprise.erfolg = True
+    monkeypatch.setattr(apprise_modul, "Apprise", FakeApprise)
+    monkeypatch.setattr(settings, "apprise_urls", "ntfy://example.org/moneyfy")
+    return FakeApprise
+
+
+async def regel(
+    session: AsyncSession,
+    typ: NotificationType,
+    *,
+    kanal: NotificationChannel = NotificationChannel.SMTP,
+    lead_days: int = 7,
+    target: str | None = None,
+) -> NotificationRule:
+    eintrag = NotificationRule(
+        type=typ, channel=kanal, lead_days=lead_days, target=target, is_active=True
+    )
+    session.add(eintrag)
+    await session.flush()
+    return eintrag
+
+
+async def abo(client: AsyncClient, seeded: dict, **overrides) -> dict:
+    payload = {
+        "kind": "expense",
+        "title": "Netflix",
+        "category_id": seeded["streaming"],
+        "account_id": seeded["account_id"],
+        "amount": "13.99",
+        "rrule": "FREQ=MONTHLY;BYMONTHDAY=15",
+        "dtstart": "2026-01-15",
+        "business_day_shift": "none",
+    }
+    payload.update(overrides)
+    antwort = await client.post("/api/recurrences", json=payload)
+    assert antwort.status_code == 201, antwort.text
+    return antwort.json()
+
+
+# --- Kanäle ---------------------------------------------------------------------
+
+
+async def test_smtp_baut_eine_mail_mit_text_und_html(smtp: type[FakeSmtp]) -> None:
+    await SmtpChannel().send(service.test_notification(), "jemand@example.org")
+
+    assert len(smtp.versendet) == 1
+    nachricht = smtp.versendet[0]
+    assert nachricht["To"] == "jemand@example.org"
+    assert nachricht["From"] == "moneyfy@example.org"
+    assert nachricht["Subject"] == "moneyfy: Testnachricht"
+    # Text und HTML liegen als Alternativen nebeneinander.
+    typen = {teil.get_content_type() for teil in nachricht.walk()}
+    assert "text/plain" in typen
+    assert "text/html" in typen
+
+
+async def test_smtp_ohne_konfiguration_meldet_das(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(settings, "smtp_host", None)
+
+    assert SmtpChannel().is_configured() is False
+    with pytest.raises(ChannelError, match="nicht konfiguriert"):
+        await SmtpChannel().send(service.test_notification())
+
+
+async def test_smtp_reicht_serverfehler_als_channelerror_durch(
+    smtp: type[FakeSmtp],
+) -> None:
+    smtp.fehler = smtplib.SMTPRecipientsRefused({})
+
+    with pytest.raises(ChannelError, match="Mailversand fehlgeschlagen"):
+        await SmtpChannel().send(service.test_notification(), "jemand@example.org")
+
+
+async def test_apprise_versendet_titel_und_text(apprise: type[FakeApprise]) -> None:
+    await AppriseChannel().send(service.test_notification())
+
+    assert len(apprise.versendet) == 1
+    titel, text = apprise.versendet[0]
+    assert titel == "moneyfy: Testnachricht"
+    assert "Testnachricht von moneyfy" in text
+
+
+async def test_apprise_ohne_ziel_meldet_das(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(settings, "apprise_urls", None)
+
+    assert AppriseChannel().is_configured() is False
+    with pytest.raises(ChannelError, match="nicht konfiguriert"):
+        await AppriseChannel().send(service.test_notification())
+
+
+async def test_apprise_meldet_fehlgeschlagene_zustellung(
+    apprise: type[FakeApprise],
+) -> None:
+    apprise.erfolg = False
+
+    with pytest.raises(ChannelError, match="kein Ziel"):
+        await AppriseChannel().send(service.test_notification())
+
+
+# --- Testversand ----------------------------------------------------------------
+
+
+async def test_testversand_ueber_beide_kanaele(
+    auth_client: AsyncClient, smtp: type[FakeSmtp], apprise: type[FakeApprise]
+) -> None:
+    """Akzeptanzkriterium: der Testversand erreicht beide Kanäle."""
+    antwort = await auth_client.post("/api/notifications/test", json={})
+
+    assert antwort.status_code == 200
+    body = antwort.json()
+    assert body["any_sent"] is True
+
+    nach_kanal = {eintrag["channel"]: eintrag for eintrag in body["results"]}
+    assert nach_kanal["smtp"] == {
+        "channel": "smtp",
+        "configured": True,
+        "sent": True,
+        "error": None,
+    }
+    assert nach_kanal["apprise"]["sent"] is True
+
+    assert len(smtp.versendet) == 1
+    assert len(apprise.versendet) == 1
+
+
+async def test_testversand_meldet_nicht_eingerichtete_kanaele(
+    auth_client: AsyncClient, smtp: type[FakeSmtp], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(settings, "apprise_urls", None)
+
+    body = (await auth_client.post("/api/notifications/test", json={})).json()
+
+    nach_kanal = {eintrag["channel"]: eintrag for eintrag in body["results"]}
+    assert nach_kanal["smtp"]["sent"] is True
+    assert nach_kanal["apprise"]["configured"] is False
+    assert nach_kanal["apprise"]["sent"] is False
+    # Ein fehlender Kanal ist kein Fehler.
+    assert body["any_sent"] is True
+
+
+async def test_einrichtungsstand_wird_gemeldet(
+    auth_client: AsyncClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(settings, "smtp_host", None)
+    monkeypatch.setattr(settings, "apprise_urls", None)
+
+    body = (await auth_client.get("/api/notifications/settings")).json()
+
+    assert body["run_at"] == "07:00"
+    assert body["timezone"] == "Europe/Berlin"
+    nach_kanal = {eintrag["channel"]: eintrag for eintrag in body["channels"]}
+    assert nach_kanal["smtp"]["configured"] is False
+    assert "SMTP_HOST" in nach_kanal["smtp"]["detail"]
+
+
+# --- Duplikatsschutz ------------------------------------------------------------
+
+
+async def test_zweiter_lauf_am_selben_tag_sendet_nicht_erneut(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    """Akzeptanzkriterium: kein Doppelversand beim zweiten Lauf."""
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    erster = await service.run_all(session, date(2026, 3, 10))
+    zweiter = await service.run_all(session, date(2026, 3, 10))
+
+    assert erster.sent == 1
+    assert zweiter.sent == 0
+    assert zweiter.skipped == 1
+    assert len(smtp.versendet) == 1
+
+
+async def test_auch_ein_spaeterer_lauf_im_vorlauf_sendet_nicht_erneut(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    """Der Schlüssel ist der Zieltag, nicht der Versandtag."""
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    await service.run_all(session, date(2026, 3, 10))
+    await service.run_all(session, date(2026, 3, 11))
+    await service.run_all(session, date(2026, 3, 12))
+
+    assert len(smtp.versendet) == 1
+
+
+async def test_naechster_monat_wird_wieder_gemeldet(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    await service.run_all(session, date(2026, 3, 10))
+    await service.run_all(session, date(2026, 4, 10))
+
+    assert len(smtp.versendet) == 2
+
+
+async def test_protokoll_haelt_den_zieltag_fest(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    await service.run_all(session, date(2026, 3, 10))
+
+    eintraege = (await session.execute(select(NotificationLog))).scalars().all()
+    assert len(eintraege) == 1
+    assert eintraege[0].status is NotificationStatus.SENT
+    assert eintraege[0].dedupe_day == date(2026, 3, 15)
+    assert eintraege[0].ref_type == "occurrence"
+
+
+async def test_fehlgeschlagener_versand_wird_erneut_versucht(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    """Ein Fehlschlag darf nicht dazu führen, dass die Meldung verloren geht."""
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    smtp.fehler = smtplib.SMTPServerDisconnected("Server weg")
+    erster = await service.run_all(session, date(2026, 3, 10))
+    assert erster.sent == 0
+
+    eintrag = (await session.execute(select(NotificationLog))).scalar_one()
+    assert eintrag.status is NotificationStatus.FAILED
+    assert eintrag.error
+
+    smtp.fehler = None
+    zweiter = await service.run_all(session, date(2026, 3, 11))
+
+    assert zweiter.sent == 1
+    assert len(smtp.versendet) == 1
+    # Der vorhandene Eintrag wird aktualisiert, kein zweiter angelegt.
+    eintraege = (await session.execute(select(NotificationLog))).scalars().all()
+    assert len(eintraege) == 1
+    assert eintraege[0].status is NotificationStatus.SENT
+    assert eintraege[0].error is None
+
+
+# --- Ereignisarten --------------------------------------------------------------
+
+
+async def test_faelligkeiten_ausserhalb_des_vorlaufs_bleiben_still(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=3)
+
+    ergebnis = await service.run_all(session, date(2026, 3, 1))
+
+    assert ergebnis.sent == 0
+    assert smtp.versendet == []
+
+
+async def test_bestaetigte_faelligkeit_wird_nicht_gemeldet(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    posten = await abo(
+        auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15"
+    )
+    await auth_client.post(
+        "/api/occurrences/confirm",
+        json={"recurrence_id": posten["id"], "occurrence_date": "2026-03-15"},
+    )
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    ergebnis = await service.run_all(session, date(2026, 3, 10))
+
+    assert ergebnis.sent == 0
+
+
+async def test_kuendigungsfrist_meldet_sich_in_drei_stufen(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    """30, 14 und 7 Tage vor dem Termin – je einmal."""
+    await abo(
+        auth_client,
+        seeded,
+        title="Handyvertrag",
+        rrule="FREQ=MONTHLY;BYMONTHDAY=1",
+        dtstart="2026-01-01",
+        contract_start="2026-01-01",
+        contract_min_term_months=24,
+        contract_notice_period_days=90,
+    )
+    await regel(session, NotificationType.NOTICE_DEADLINE, lead_days=30)
+
+    # Laufzeitende 31.12.2027, Frist also am 02.10.2027.
+    frist = date(2027, 10, 2)
+    for versatz in (30, 14, 7):
+        await service.run_all(session, frist - timedelta(days=versatz))
+    # Ein weiterer Lauf innerhalb derselben Stufe meldet nichts Neues.
+    await service.run_all(session, frist - timedelta(days=6))
+
+    assert len(smtp.versendet) == 3
+    assert all("Handyvertrag" in text_of(nachricht) for nachricht in smtp.versendet)
+
+
+async def test_gekuendigter_vertrag_meldet_keine_frist(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    posten = await abo(
+        auth_client,
+        seeded,
+        title="Handyvertrag",
+        rrule="FREQ=MONTHLY;BYMONTHDAY=1",
+        dtstart="2026-01-01",
+        contract_start="2026-01-01",
+        contract_min_term_months=24,
+        contract_notice_period_days=90,
+    )
+    await auth_client.post(f"/api/recurrences/{posten['id']}/cancel")
+    await regel(session, NotificationType.NOTICE_DEADLINE)
+
+    ergebnis = await service.run_all(session, date(2027, 9, 15))
+
+    assert ergebnis.sent == 0
+
+
+async def test_ueberschrittenes_budget_meldet_sich_einmal_im_monat(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await auth_client.post(
+        "/api/budgets",
+        json={
+            "category_id": seeded["lebensmittel"],
+            "period_month": "2026-03-01",
+            "limit_amount": "100.00",
+        },
+    )
+    await auth_client.post(
+        "/api/transactions",
+        json={
+            "kind": "expense",
+            "title": "Großeinkauf",
+            "category_id": seeded["lebensmittel"],
+            "account_id": seeded["account_id"],
+            "amount": "150.00",
+            "booking_date": "2026-03-05",
+        },
+    )
+    await regel(session, NotificationType.BUDGET_EXCEEDED)
+
+    erster = await service.run_all(session, date(2026, 3, 10))
+    zweiter = await service.run_all(session, date(2026, 3, 20))
+
+    assert erster.sent == 1
+    assert zweiter.sent == 0
+    assert "Lebensmittel" in text_of(smtp.versendet[0])
+
+
+async def test_vertragsverlaengerung_im_kommenden_monat(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(
+        auth_client,
+        seeded,
+        title="Zeitschrift",
+        rrule="FREQ=MONTHLY;BYMONTHDAY=1",
+        dtstart="2026-01-01",
+        contract_start="2026-01-01",
+        contract_min_term_months=12,
+        contract_auto_renew_months=12,
+    )
+    await regel(session, NotificationType.CONTRACT_RENEWAL)
+
+    # Verlängerung am 01.01.2027; ein Lauf im Dezember trifft das Fenster.
+    ergebnis = await service.run_all(session, date(2026, 12, 5))
+
+    assert ergebnis.sent == 1
+    assert "Zeitschrift" in text_of(smtp.versendet[0])
+
+
+async def test_abgeschaltete_regel_laeuft_nicht(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    eintrag = await regel(session, NotificationType.DUE_SOON, lead_days=7)
+    eintrag.is_active = False
+    await session.flush()
+
+    ergebnis = await service.run_all(session, date(2026, 3, 10))
+
+    assert ergebnis.sent == 0
+    assert smtp.versendet == []
+
+
+async def test_abgeschaltete_benachrichtigungen(
+    session: AsyncSession, monkeypatch: pytest.MonkeyPatch, smtp: type[FakeSmtp]
+) -> None:
+    monkeypatch.setattr(settings, "notifications_enabled", False)
+
+    ergebnis = await service.run_all(session, date(2026, 3, 10))
+
+    assert ergebnis.checked == 0
+    assert smtp.versendet == []
+
+
+# --- Regeln über die API --------------------------------------------------------
+
+
+async def test_regeln_pflegen(auth_client: AsyncClient) -> None:
+    angelegt = await auth_client.post(
+        "/api/notifications/rules",
+        json={"type": "due_soon", "channel": "apprise", "lead_days": 5},
+    )
+    assert angelegt.status_code == 201
+    eintrag = angelegt.json()
+    assert eintrag["lead_days"] == 5
+
+    geaendert = await auth_client.patch(
+        f"/api/notifications/rules/{eintrag['id']}", json={"lead_days": 10, "is_active": False}
+    )
+    assert geaendert.json()["lead_days"] == 10
+    assert geaendert.json()["is_active"] is False
+
+    liste = (await auth_client.get("/api/notifications/rules")).json()
+    assert any(regel["id"] == eintrag["id"] for regel in liste)
+
+    assert (
+        await auth_client.delete(f"/api/notifications/rules/{eintrag['id']}")
+    ).status_code == 200
+
+
+async def test_lauf_ueber_die_api(
+    auth_client: AsyncClient, session: AsyncSession, seeded: dict, smtp: type[FakeSmtp]
+) -> None:
+    await abo(auth_client, seeded, rrule="FREQ=MONTHLY;BYMONTHDAY=15", dtstart="2026-03-15")
+    await regel(session, NotificationType.DUE_SOON, lead_days=7)
+
+    antwort = await auth_client.post("/api/notifications/run", params={"as_of": "2026-03-10"})
+
+    assert antwort.status_code == 200
+    assert antwort.json()["sent"] == 1
+
+    protokoll = (await auth_client.get("/api/notifications/log")).json()
+    assert len(protokoll) == 1
+    assert protokoll[0]["status"] == "sent"
+
+
+async def test_benachrichtigungen_verlangen_anmeldung(client: AsyncClient) -> None:
+    assert (await client.get("/api/notifications/rules")).status_code == 401
+    assert (await client.post("/api/notifications/test", json={})).status_code == 401

frontend/src/components/NotificationSettings.test.tsx

@@ -0,0 +1,214 @@
+/** Tests der Benachrichtigungs-Einstellungen. */
+
+import { screen, waitFor, within } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { NotificationSettings } from "@/components/NotificationSettings";
+import { renderWithProviders } from "@/test/utils";
+import type { NotificationRule, NotificationSettings as Einstellungen } from "@/types/api";
+
+const EINSTELLUNGEN: Einstellungen = {
+  enabled: true,
+  scheduler_enabled: true,
+  run_at: "07:00",
+  timezone: "Europe/Berlin",
+  next_run_at: "2026-03-11T07:00:00+01:00",
+  channels: [
+    { channel: "smtp", configured: true, detail: "Einsatzbereit." },
+    { channel: "apprise", configured: false, detail: "APPRISE_URLS setzen, komma-separiert." },
+  ],
+};
+
+const REGEL: NotificationRule = {
+  id: 1,
+  type: "due_soon",
+  channel: "smtp",
+  lead_days: 3,
+  target: null,
+  is_active: true,
+  created_at: "2026-03-01T10:00:00+01:00",
+};
+
+function mockApi(
+  overrides: {
+    rules?: NotificationRule[];
+    /** "sent" liefert Erfolg, "failed" einen Fehler, "unconfigured" gar keinen Kanal. */
+    test?: "sent" | "failed" | "unconfigured";
+  } = {},
+) {
+  const anfragen: { url: string; method: string; body: unknown }[] = [];
+
+  const json = (daten: unknown, status = 200) =>
+    new Response(JSON.stringify(daten), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (eingabe: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof eingabe === "string" ? eingabe : eingabe.toString();
+      const methode = init?.method ?? "GET";
+      anfragen.push({
+        url,
+        method: methode,
+        body: typeof init?.body === "string" ? JSON.parse(init.body) : null,
+      });
+
+      if (url.includes("/notifications/settings")) return json(EINSTELLUNGEN);
+      if (url.includes("/notifications/log")) return json([]);
+      if (url.includes("/notifications/test")) {
+        const modus = overrides.test ?? "sent";
+        const smtp =
+          modus === "sent"
+            ? { channel: "smtp", configured: true, sent: true, error: null }
+            : modus === "failed"
+              ? { channel: "smtp", configured: true, sent: false, error: "Server weg" }
+              : { channel: "smtp", configured: false, sent: false, error: null };
+        return json({
+          results: [smtp, { channel: "apprise", configured: false, sent: false, error: null }],
+          any_sent: modus === "sent",
+        });
+      }
+      if (url.includes("/notifications/run")) {
+        return json({ checked: 4, sent: 2, skipped: 2, failed: 0 });
+      }
+      if (url.includes("/notifications/rules")) {
+        if (methode === "POST") return json({ ...REGEL, id: 9 }, 201);
+        return json(overrides.rules ?? [REGEL]);
+      }
+      return json({});
+    }),
+  );
+
+  return anfragen;
+}
+
+describe("Benachrichtigungs-Einstellungen", () => {
+  beforeEach(() => {
+    mockApi();
+  });
+
+  it("zeigt Zeitplan und Einrichtungsstand der Kanäle", async () => {
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => {
+      expect(screen.getByText(/Täglicher Lauf um 07:00 Uhr/)).toBeInTheDocument();
+    });
+    // "E-Mail" steht sowohl auf der Kanalkarte als auch als Abzeichen an der Regel.
+    expect(screen.getAllByText("E-Mail").length).toBeGreaterThan(0);
+    expect(screen.getByText("Einsatzbereit.")).toBeInTheDocument();
+    // Der nicht eingerichtete Kanal nennt die fehlende Variable.
+    expect(screen.getByText(/APPRISE_URLS setzen/)).toBeInTheDocument();
+  });
+
+  it("listet Regeln mit Anlass, Kanal und Vorlauf", async () => {
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Bald fällig")).toBeInTheDocument());
+    expect(screen.getByText("3 Tage Vorlauf")).toBeInTheDocument();
+    expect(screen.getByText(/Meldet Fälligkeiten innerhalb der Vorlaufzeit/)).toBeInTheDocument();
+  });
+
+  it("meldet einen leeren Regelsatz verständlich", async () => {
+    mockApi({ rules: [] });
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Keine Regeln")).toBeInTheDocument());
+    expect(screen.getByText(/verschickt moneyfy nichts/)).toBeInTheDocument();
+  });
+
+  it("löst den Testversand aus", async () => {
+    const anfragen = mockApi();
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Zeitplan")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /Testnachricht/ }));
+
+    await waitFor(() => {
+      expect(anfragen.some((eintrag) => eintrag.url.includes("/notifications/test"))).toBe(true);
+    });
+    // Der Erfolg wird sichtbar zurückgemeldet.
+    expect(await screen.findByText(/Testnachricht versendet über E-Mail/)).toBeInTheDocument();
+  });
+
+  it("meldet einen fehlgeschlagenen Testversand mit Ursache", async () => {
+    mockApi({ test: "failed" });
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Zeitplan")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /Testnachricht/ }));
+
+    expect(await screen.findByText(/Testversand ist fehlgeschlagen/)).toBeInTheDocument();
+    expect(screen.getByText("Server weg")).toBeInTheDocument();
+  });
+
+  it("weist auf fehlende Kanäle hin, statt einen Fehler zu melden", async () => {
+    mockApi({ test: "unconfigured" });
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Zeitplan")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /Testnachricht/ }));
+
+    expect(await screen.findByText(/Kein Kanal eingerichtet/)).toBeInTheDocument();
+  });
+
+  it("startet einen Lauf und meldet das Ergebnis", async () => {
+    const anfragen = mockApi();
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Zeitplan")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /Jetzt prüfen/ }));
+
+    await waitFor(() => {
+      expect(anfragen.some((eintrag) => eintrag.url.includes("/notifications/run"))).toBe(true);
+    });
+    expect(await screen.findByText(/2 Benachrichtigungen versendet/)).toBeInTheDocument();
+    expect(screen.getByText(/4 geprüft, 2 bereits gemeldet/)).toBeInTheDocument();
+  });
+
+  it("legt eine Regel über das Formular an", async () => {
+    const anfragen = mockApi();
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Regeln")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /^Regel$/ }));
+
+    const dialog = await screen.findByRole("dialog", { name: "Neue Regel" });
+    await nutzer.selectOptions(within(dialog).getByLabelText(/Anlass/), "notice_deadline");
+    await nutzer.selectOptions(within(dialog).getByLabelText(/Kanal/), "apprise");
+    await nutzer.click(within(dialog).getByRole("button", { name: "Speichern" }));
+
+    await waitFor(() => {
+      const angelegt = anfragen.find(
+        (eintrag) => eintrag.method === "POST" && eintrag.url.includes("/notifications/rules"),
+      );
+      expect(angelegt?.body).toMatchObject({
+        type: "notice_deadline",
+        channel: "apprise",
+        is_active: true,
+      });
+    });
+  });
+
+  it("blendet den Vorlauf nur bei Fälligkeiten ein", async () => {
+    const nutzer = userEvent.setup();
+    renderWithProviders(<NotificationSettings />);
+
+    await waitFor(() => expect(screen.getByText("Regeln")).toBeInTheDocument());
+    await nutzer.click(screen.getByRole("button", { name: /^Regel$/ }));
+
+    const dialog = await screen.findByRole("dialog", { name: "Neue Regel" });
+    expect(within(dialog).getByLabelText(/Vorlauf in Tagen/)).toBeInTheDocument();
+
+    // Für ein Budget gibt es keinen Vorlauf.
+    await nutzer.selectOptions(within(dialog).getByLabelText(/Anlass/), "budget_exceeded");
+    expect(within(dialog).queryByLabelText(/Vorlauf in Tagen/)).not.toBeInTheDocument();
+  });
+});

frontend/src/components/NotificationSettings.tsx

@@ -0,0 +1,390 @@
+/** Einstellungen der Benachrichtigungen: Kanäle, Regeln, Testversand, Protokoll. */
+
+import { type FormEvent, useState } from "react";
+
+import {
+  BellRing,
+  CheckCircle2,
+  Play,
+  Plus,
+  Send,
+  Trash2,
+  XCircle,
+} from "lucide-react";
+
+import { Button } from "@/components/ui/Button";
+import { Badge, ConfirmDialog, EmptyState, Skeleton } from "@/components/ui/Feedback";
+import { Checkbox, Field, Input, Select } from "@/components/ui/Field";
+import { Modal } from "@/components/ui/Modal";
+import {
+  useDeleteNotificationRule,
+  useNotificationLog,
+  useNotificationRules,
+  useNotificationSettings,
+  useRunNotifications,
+  useSaveNotificationRule,
+  useSendTestNotification,
+} from "@/hooks/useNotifications";
+import { formatDate } from "@/lib/format";
+import type { NotificationChannel, NotificationRule, NotificationType } from "@/types/api";
+
+const TYP_NAMEN: Record<NotificationType, string> = {
+  due_soon: "Bald fällig",
+  notice_deadline: "Kündigungsfrist",
+  budget_exceeded: "Budget überschritten",
+  contract_renewal: "Vertragsverlängerung",
+};
+
+const TYP_HINWEISE: Record<NotificationType, string> = {
+  due_soon: "Meldet Fälligkeiten innerhalb der Vorlaufzeit.",
+  notice_deadline: "Meldet 30, 14 und 7 Tage vor dem letzten Kündigungstermin.",
+  budget_exceeded: "Meldet überschrittene Budgets, einmal je Monat und Kategorie.",
+  contract_renewal: "Meldet Verträge, die sich im kommenden Monat verlängern.",
+};
+
+const KANAL_NAMEN: Record<NotificationChannel, string> = {
+  smtp: "E-Mail",
+  apprise: "Apprise",
+};
+
+export function NotificationSettings() {
+  const [formularOffen, setFormularOffen] = useState(false);
+  const [bearbeiten, setBearbeiten] = useState<NotificationRule | null>(null);
+  const [loeschen, setLoeschen] = useState<NotificationRule | null>(null);
+
+  const { data: einstellungen, isLoading } = useNotificationSettings();
+  const { data: regeln = [] } = useNotificationRules();
+  const { data: protokoll = [] } = useNotificationLog(25);
+  const entfernen = useDeleteNotificationRule();
+  const testen = useSendTestNotification();
+  const laufStarten = useRunNotifications();
+
+  if (isLoading || !einstellungen) return <Skeleton className="h-64 w-full" />;
+
+  return (
+    <div className="space-y-4">
+      <section className="card p-4">
+        <div className="flex flex-wrap items-start justify-between gap-3">
+          <div>
+            <h2 className="flex items-center gap-2 text-sm font-semibold text-ink">
+              <BellRing aria-hidden className="h-4 w-4" />
+              Zeitplan
+            </h2>
+            <p className="mt-0.5 text-xs text-muted">
+              {einstellungen.scheduler_enabled
+                ? `Täglicher Lauf um ${einstellungen.run_at} Uhr (${einstellungen.timezone}).`
+                : "Der Scheduler ist abgeschaltet (SCHEDULER_ENABLED=false)."}
+              {einstellungen.next_run_at &&
+                ` Nächster Lauf am ${formatDate(einstellungen.next_run_at.slice(0, 10))}.`}
+            </p>
+          </div>
+          <div className="flex gap-2">
+            <Button onClick={() => testen.mutate(undefined)} loading={testen.isPending}>
+              <Send aria-hidden className="h-4 w-4" />
+              Testnachricht
+            </Button>
+            <Button onClick={() => laufStarten.mutate()} loading={laufStarten.isPending}>
+              <Play aria-hidden className="h-4 w-4" />
+              Jetzt prüfen
+            </Button>
+          </div>
+        </div>
+
+        <ul className="mt-3 grid gap-2 sm:grid-cols-2">
+          {einstellungen.channels.map((kanal) => (
+            <li
+              key={kanal.channel}
+              className="flex items-start gap-2 rounded-lg border border-line bg-raised p-3"
+            >
+              {kanal.configured ? (
+                <CheckCircle2 aria-hidden className="mt-0.5 h-4 w-4 shrink-0 text-positive" />
+              ) : (
+                <XCircle aria-hidden className="mt-0.5 h-4 w-4 shrink-0 text-faint" />
+              )}
+              <div className="min-w-0">
+                <p className="text-sm font-medium text-ink">{KANAL_NAMEN[kanal.channel]}</p>
+                <p className="text-xs text-muted">{kanal.detail}</p>
+              </div>
+            </li>
+          ))}
+        </ul>
+      </section>
+
+      <section>
+        <div className="mb-2 flex items-center justify-between">
+          <h2 className="text-sm font-semibold text-ink">Regeln</h2>
+          <Button
+            size="sm"
+            onClick={() => {
+              setBearbeiten(null);
+              setFormularOffen(true);
+            }}
+          >
+            <Plus aria-hidden className="h-3.5 w-3.5" />
+            Regel
+          </Button>
+        </div>
+
+        {regeln.length === 0 ? (
+          <EmptyState
+            icon={BellRing}
+            title="Keine Regeln"
+            description="Ohne Regel verschickt moneyfy nichts. Lege fest, worüber du informiert werden willst."
+          />
+        ) : (
+          <ul className="divide-y divide-line rounded-card border border-line">
+            {regeln.map((regel) => (
+              <li key={regel.id} className="group flex items-center gap-3 px-3 py-2.5">
+                <div className="min-w-0 flex-1">
+                  <div className="flex flex-wrap items-center gap-1.5">
+                    <span className="text-sm font-medium text-ink">{TYP_NAMEN[regel.type]}</span>
+                    <Badge>{KANAL_NAMEN[regel.channel]}</Badge>
+                    {regel.type === "due_soon" && (
+                      <Badge tone="accent">{regel.lead_days} Tage Vorlauf</Badge>
+                    )}
+                    {!regel.is_active && <Badge tone="warning">Inaktiv</Badge>}
+                  </div>
+                  <p className="truncate text-xs text-faint">
+                    {TYP_HINWEISE[regel.type]}
+                    {regel.target && ` An: ${regel.target}`}
+                  </p>
+                </div>
+
+                <div className="flex shrink-0 gap-1">
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    onClick={() => {
+                      setBearbeiten(regel);
+                      setFormularOffen(true);
+                    }}
+                  >
+                    Ändern
+                  </Button>
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    onClick={() => setLoeschen(regel)}
+                    aria-label={`Regel ${TYP_NAMEN[regel.type]} löschen`}
+                  >
+                    <Trash2 aria-hidden className="h-3.5 w-3.5" />
+                  </Button>
+                </div>
+              </li>
+            ))}
+          </ul>
+        )}
+      </section>
+
+      {protokoll.length > 0 && (
+        <section>
+          <h2 className="mb-2 text-sm font-semibold text-ink">Versandprotokoll</h2>
+          <div className="overflow-x-auto rounded-card border border-line">
+            <table className="w-full text-xs">
+              <caption className="sr-only">Zuletzt versendete Benachrichtigungen</caption>
+              <thead className="border-b border-line text-left text-muted">
+                <tr>
+                  <th scope="col" className="px-3 py-2 font-medium">
+                    Gesendet
+                  </th>
+                  <th scope="col" className="px-3 py-2 font-medium">
+                    Bezug
+                  </th>
+                  <th scope="col" className="px-3 py-2 font-medium">
+                    Zieltag
+                  </th>
+                  <th scope="col" className="px-3 py-2 font-medium">
+                    Status
+                  </th>
+                </tr>
+              </thead>
+              <tbody className="divide-y divide-line">
+                {protokoll.map((eintrag) => (
+                  <tr key={eintrag.id}>
+                    <td className="whitespace-nowrap px-3 py-1.5 tabular text-muted">
+                      {formatDate(eintrag.sent_at.slice(0, 10))}
+                    </td>
+                    <td className="px-3 py-1.5 text-muted">
+                      {eintrag.ref_type} {eintrag.ref_id}
+                    </td>
+                    <td className="whitespace-nowrap px-3 py-1.5 tabular text-muted">
+                      {formatDate(eintrag.dedupe_day)}
+                    </td>
+                    <td className="px-3 py-1.5">
+                      {eintrag.status === "sent" ? (
+                        <Badge tone="positive">zugestellt</Badge>
+                      ) : (
+                        <Badge tone="negative" className="max-w-xs truncate">
+                          {eintrag.error ?? "fehlgeschlagen"}
+                        </Badge>
+                      )}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </section>
+      )}
+
+      <RuleDialog
+        rule={bearbeiten}
+        open={formularOffen}
+        onClose={() => {
+          setFormularOffen(false);
+          setBearbeiten(null);
+        }}
+      />
+
+      <ConfirmDialog
+        open={loeschen !== null}
+        title="Regel löschen"
+        description="Die Regel wird samt ihrem Versandprotokoll entfernt."
+        loading={entfernen.isPending}
+        onCancel={() => setLoeschen(null)}
+        onConfirm={() => {
+          if (loeschen) entfernen.mutate(loeschen.id, { onSuccess: () => setLoeschen(null) });
+        }}
+      />
+    </div>
+  );
+}
+
+function RuleDialog({
+  rule,
+  open,
+  onClose,
+}: {
+  rule: NotificationRule | null;
+  open: boolean;
+  onClose: () => void;
+}) {
+  const speichern = useSaveNotificationRule();
+  const [typ, setTyp] = useState<NotificationType>("due_soon");
+  const [kanal, setKanal] = useState<NotificationChannel>("smtp");
+  const [vorlauf, setVorlauf] = useState(7);
+  const [ziel, setZiel] = useState("");
+  const [aktiv, setAktiv] = useState(true);
+  const [initialisiert, setInitialisiert] = useState<number | null | undefined>(undefined);
+
+  if (open && initialisiert !== (rule?.id ?? null)) {
+    setTyp(rule?.type ?? "due_soon");
+    setKanal(rule?.channel ?? "smtp");
+    setVorlauf(rule?.lead_days ?? 7);
+    setZiel(rule?.target ?? "");
+    setAktiv(rule?.is_active ?? true);
+    setInitialisiert(rule?.id ?? null);
+  }
+
+  function absenden(ereignis: FormEvent) {
+    ereignis.preventDefault();
+    speichern.mutate(
+      {
+        id: rule?.id,
+        daten: rule
+          ? { channel: kanal, lead_days: vorlauf, target: ziel.trim() || null, is_active: aktiv }
+          : {
+              type: typ,
+              channel: kanal,
+              lead_days: vorlauf,
+              target: ziel.trim() || null,
+              is_active: aktiv,
+            },
+      },
+      {
+        onSuccess: () => {
+          setInitialisiert(undefined);
+          onClose();
+        },
+      },
+    );
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      size="sm"
+      title={rule ? "Regel ändern" : "Neue Regel"}
+      footer={
+        <>
+          <Button onClick={onClose}>Abbrechen</Button>
+          <Button variant="primary" onClick={absenden} loading={speichern.isPending}>
+            Speichern
+          </Button>
+        </>
+      }
+    >
+      <form onSubmit={absenden} className="space-y-3">
+        <Field label="Anlass" required hint={TYP_HINWEISE[typ]}>
+          {(id) => (
+            <Select
+              id={id}
+              value={typ}
+              disabled={rule !== null}
+              onChange={(ereignis) => setTyp(ereignis.target.value as NotificationType)}
+            >
+              {(Object.keys(TYP_NAMEN) as NotificationType[]).map((wert) => (
+                <option key={wert} value={wert}>
+                  {TYP_NAMEN[wert]}
+                </option>
+              ))}
+            </Select>
+          )}
+        </Field>
+
+        <Field label="Kanal" required>
+          {(id) => (
+            <Select
+              id={id}
+              value={kanal}
+              onChange={(ereignis) => setKanal(ereignis.target.value as NotificationChannel)}
+            >
+              <option value="smtp">E-Mail</option>
+              <option value="apprise">Apprise</option>
+            </Select>
+          )}
+        </Field>
+
+        {typ === "due_soon" && (
+          <Field label="Vorlauf in Tagen" hint="Wie früh vor der Fälligkeit gemeldet wird.">
+            {(id) => (
+              <Input
+                id={id}
+                type="number"
+                min={0}
+                max={365}
+                value={vorlauf}
+                onChange={(ereignis) => setVorlauf(Number(ereignis.target.value))}
+              />
+            )}
+          </Field>
+        )}
+
+        <Field
+          label="Ziel"
+          hint={
+            kanal === "smtp"
+              ? "Mailadresse; leer lassen für SMTP_FROM."
+              : "Apprise-URL; leer lassen für APPRISE_URLS."
+          }
+        >
+          {(id) => (
+            <Input
+              id={id}
+              value={ziel}
+              placeholder={kanal === "smtp" ? "ich@example.org" : "ntfy://host/topic"}
+              onChange={(ereignis) => setZiel(ereignis.target.value)}
+            />
+          )}
+        </Field>
+
+        <Checkbox
+          label="Aktiv"
+          checked={aktiv}
+          onChange={(ereignis) => setAktiv(ereignis.target.checked)}
+        />
+      </form>
+    </Modal>
+  );
+}

frontend/src/hooks/useNotifications.ts

@@ -0,0 +1,121 @@
+/** Benachrichtigungsregeln, Protokoll und Testversand. */
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+import { api } from "@/lib/api";
+import { toast } from "@/store/toast";
+import type {
+  MessageResponse,
+  NotificationLogEntry,
+  NotificationRule,
+  NotificationRuleInput,
+  NotificationRunResult,
+  NotificationSettings,
+  TestSendResponse,
+} from "@/types/api";
+
+const KANAL_NAMEN = { smtp: "E-Mail", apprise: "Apprise" } as const;
+
+export function useNotificationSettings() {
+  return useQuery({
+    queryKey: ["notifications", "settings"],
+    queryFn: () => api.get<NotificationSettings>("/notifications/settings"),
+  });
+}
+
+export function useNotificationRules() {
+  return useQuery({
+    queryKey: ["notifications", "rules"],
+    queryFn: () => api.get<NotificationRule[]>("/notifications/rules"),
+  });
+}
+
+export function useNotificationLog(limit = 50) {
+  return useQuery({
+    queryKey: ["notifications", "log", limit],
+    queryFn: () => api.get<NotificationLogEntry[]>("/notifications/log", { limit }),
+  });
+}
+
+export function useSaveNotificationRule() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      id,
+      daten,
+    }: {
+      id?: number;
+      daten: NotificationRuleInput | Partial<NotificationRuleInput>;
+    }) =>
+      id
+        ? api.patch<NotificationRule>(`/notifications/rules/${id}`, daten)
+        : api.post<NotificationRule>("/notifications/rules", daten),
+    onSuccess: (_regel, variablen) => {
+      void client.invalidateQueries({ queryKey: ["notifications"] });
+      toast.success(variablen.id ? "Regel gespeichert." : "Regel angelegt.");
+    },
+  });
+}
+
+export function useDeleteNotificationRule() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => api.del<MessageResponse>(`/notifications/rules/${id}`),
+    onSuccess: () => {
+      void client.invalidateQueries({ queryKey: ["notifications"] });
+      toast.success("Regel gelöscht.");
+    },
+  });
+}
+
+export function useSendTestNotification() {
+  return useMutation({
+    mutationFn: (target?: string) =>
+      api.post<TestSendResponse>("/notifications/test", { target: target || null }),
+    onSuccess: (ergebnis) => {
+      const zugestellt = ergebnis.results
+        .filter((eintrag) => eintrag.sent)
+        .map((eintrag) => KANAL_NAMEN[eintrag.channel]);
+      const gescheitert = ergebnis.results.filter(
+        (eintrag) => eintrag.configured && !eintrag.sent,
+      );
+
+      if (zugestellt.length > 0) {
+        toast.success(
+          `Testnachricht versendet über ${zugestellt.join(" und ")}.`,
+          gescheitert.length > 0
+            ? `Fehlgeschlagen: ${gescheitert
+                .map((eintrag) => `${KANAL_NAMEN[eintrag.channel]} (${eintrag.error})`)
+                .join(", ")}`
+            : undefined,
+        );
+        return;
+      }
+
+      if (gescheitert.length > 0) {
+        toast.error(
+          "Der Testversand ist fehlgeschlagen.",
+          gescheitert.map((eintrag) => eintrag.error).join(" · "),
+        );
+        return;
+      }
+      toast.info("Kein Kanal eingerichtet.", "Trage SMTP- oder Apprise-Daten in die Umgebung ein.");
+    },
+  });
+}
+
+export function useRunNotifications() {
+  const client = useQueryClient();
+  return useMutation({
+    mutationFn: () => api.post<NotificationRunResult>("/notifications/run"),
+    onSuccess: (ergebnis) => {
+      void client.invalidateQueries({ queryKey: ["notifications"] });
+      toast.success(
+        ergebnis.sent > 0
+          ? `${ergebnis.sent} Benachrichtigung${ergebnis.sent === 1 ? "" : "en"} versendet.`
+          : "Nichts zu melden.",
+        `${ergebnis.checked} geprüft, ${ergebnis.skipped} bereits gemeldet.`,
+      );
+    },
+  });
+}

frontend/src/pages/SettingsPage.tsx

@@ -4,6 +4,7 @@ import { type FormEvent, useState } from "react";
 
 import { KeyRound, Pencil, Plus, Trash2, Wallet } from "lucide-react";
 
+import { NotificationSettings } from "@/components/NotificationSettings";
 import { PageHeader } from "@/components/layout/AppLayout";
 import { Button } from "@/components/ui/Button";
 import { Badge, ConfirmDialog, EmptyState, Skeleton } from "@/components/ui/Feedback";
@@ -31,11 +32,12 @@ const KONTOARTEN: Record<AccountType, string> = {
   cash: "Bargeld",
 };
 
-type Reiter = "accounts" | "categories" | "account";
+type Reiter = "accounts" | "categories" | "notifications" | "account";
 
 const REITER: { id: Reiter; label: string }[] = [
   { id: "accounts", label: "Konten" },
   { id: "categories", label: "Kategorien" },
+  { id: "notifications", label: "Benachrichtigungen" },
   { id: "account", label: "Konto & Darstellung" },
 ];
 
@@ -67,6 +69,7 @@ export function SettingsPage() {
 
       {reiter === "accounts" && <AccountsSection />}
       {reiter === "categories" && <CategoriesSection />}
+      {reiter === "notifications" && <NotificationSettings />}
       {reiter === "account" && <UserSection />}
     </>
   );

frontend/src/test/setup.ts

@@ -4,9 +4,13 @@ import "@testing-library/jest-dom/vitest";
 import { cleanup } from "@testing-library/react";
 import { afterEach, vi } from "vitest";
 
+import { useToastStore } from "@/store/toast";
+
 afterEach(() => {
   cleanup();
   vi.restoreAllMocks();
+  // Der Toast-Store lebt global – ohne Zurücksetzen tropfen Meldungen in den nächsten Test.
+  useToastStore.getState().clear();
 });
 
 // jsdom kennt matchMedia nicht; einzelne Komponenten fragen es ab.

frontend/src/test/utils.tsx

@@ -6,6 +6,8 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { render } from "@testing-library/react";
 import { MemoryRouter } from "react-router-dom";
 
+import { Toaster } from "@/components/ui/Toaster";
+
 /** Frischer Client je Test, ohne Wiederholungen und ohne Konsolenausgabe. */
 export function createTestQueryClient(): QueryClient {
   return new QueryClient({
@@ -27,6 +29,8 @@ export function renderWithProviders(ui: ReactElement, route = "/") {
           future={{ v7_startTransition: true, v7_relativeSplatPath: true }}
         >
           {children}
+          {/* Wie in der echten Anwendung – so lassen sich Rückmeldungen prüfen. */}
+          <Toaster />
         </MemoryRouter>
       </QueryClientProvider>
     );

frontend/src/types/api.ts

@@ -529,3 +529,75 @@ export interface Dashboard {
   upcoming: CalendarEntry[];
   upcoming_deadlines: Subscription[];
 }
+
+export type NotificationType =
+  | "due_soon"
+  | "notice_deadline"
+  | "budget_exceeded"
+  | "contract_renewal";
+
+export type NotificationChannel = "smtp" | "apprise";
+export type NotificationStatus = "sent" | "failed";
+
+export interface NotificationRule {
+  id: number;
+  type: NotificationType;
+  channel: NotificationChannel;
+  lead_days: number;
+  target: string | null;
+  is_active: boolean;
+  created_at: IsoDateTime;
+}
+
+export interface NotificationRuleInput {
+  type: NotificationType;
+  channel: NotificationChannel;
+  lead_days?: number;
+  target?: string | null;
+  is_active?: boolean;
+}
+
+export interface NotificationLogEntry {
+  id: number;
+  rule_id: number;
+  ref_type: string;
+  ref_id: string;
+  dedupe_day: IsoDate;
+  sent_at: IsoDateTime;
+  status: NotificationStatus;
+  error: string | null;
+}
+
+export interface ChannelStatus {
+  channel: NotificationChannel;
+  configured: boolean;
+  detail: string;
+}
+
+export interface NotificationSettings {
+  enabled: boolean;
+  scheduler_enabled: boolean;
+  run_at: string;
+  timezone: string;
+  next_run_at: IsoDateTime | null;
+  channels: ChannelStatus[];
+}
+
+export interface TestResult {
+  channel: NotificationChannel;
+  configured: boolean;
+  sent: boolean;
+  error: string | null;
+}
+
+export interface TestSendResponse {
+  results: TestResult[];
+  any_sent: boolean;
+}
+
+export interface NotificationRunResult {
+  checked: number;
+  sent: number;
+  skipped: number;
+  failed: number;
+}