CFG-03: benachrichtigungs-kanaele-e-mail-in-app

internal/channels: konkrete Zustellkanaele fuer CFG-02s Dispatcher. TemplateStore.Resolve loest Vorlagen pro Tenant auf und faellt auf GlobalTemplateScope zurueck, wenn ein Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3). Render nutzt text/template mit Option("missingkey=error") — ein fehlender Platzhalter bricht das Rendering MIT FEHLER ab, statt eine unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1). EmailSender implementiert notify.Sender: rendert ZUERST die Vorlage, bevor ueberhaupt eine SMTP-Verbindung aufgebaut wird — schlaegt das Rendering fehl, wird nie ein Netzwerkzugriff versucht. Ein anschliessend fehl- schlagender SMTP-Versand liefert einen Fehler, den CFG-02s bereits getestete Wiederholungslogik verarbeitet (kein zweiter Retry-Mechanismus hier). InAppSender persistiert In-App-Nachrichten ueber InAppStore (Akzeptanzkriterium 2, ueber API abrufbar/als gelesen markierbar). Router waehlt den Kanal anhand Notification.Channel — ein neuer Kanal wird per Register() ergaenzt, ohne Dispatcher oder Router umzubauen. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Vorlagenrendering mit fehlenden Platzhaltern bricht kontrolliert ab — TestRender_MissingPlaceholderAborts und TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing (Fehler kommt von der Vorlagenaufloesung, kein SMTP-Verbindungsversuch). PASS. 2. In-App-Benachrichtigung nach Markierung als gelesen korrekt gefuehrt — TestInAppStore_MarkReadIsReflectedCorrectly. PASS. 3. E-Mail-Versand bei nicht erreichbarem SMTP-Server loest dokumentiertes Retry-Verhalten ueber CFG-02 aus — TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP: echter EmailSender gegen unerreichbaren Host, ueber notify.Dispatcher eingereiht, nach ausgeschoepften Wiederholungen status=failed mit korrekter Versuchszahl. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
CFG-02: benachrichtigungs-dispatcher-core-service-fuer-module
2026-08-27 23:23:45 +02:00 · 2026-08-27 21:06:36 +02:00
15 changed files with 992 additions and 27 deletions
@@ -0,0 +1,207 @@
+package channels
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+func setupTest(t *testing.T) (*TemplateStore, *InAppStore, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_templates (
+			tenant_slug TEXT NOT NULL, key TEXT NOT NULL, subject TEXT NOT NULL, body TEXT NOT NULL,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_slug, key)
+		);
+		CREATE TABLE IF NOT EXISTS in_app_notifications (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL,
+			title TEXT NOT NULL, body TEXT NOT NULL, read_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','failed')),
+			attempts INT NOT NULL DEFAULT 0, max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return NewTemplateStore(pool), NewInAppStore(pool), cleanup
+}
+
+func uniqueKey(prefix string) string {
+	return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Vorlagenrendering mit fehlenden
+// Platzhaltern bricht kontrolliert ab.
+func TestRender_MissingPlaceholderAborts(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	_, _, err := Render(tmpl, map[string]any{"name": "Alice"}) // "code" fehlt
+	if err == nil {
+		t.Fatal("erwartet fehler bei fehlendem platzhalter 'code'")
+	}
+}
+
+func TestRender_SucceedsWithAllPlaceholders(t *testing.T) {
+	tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
+
+	subject, body, err := Render(tmpl, map[string]any{"name": "Alice", "code": "1234"})
+	if err != nil {
+		t.Fatalf("render: %v", err)
+	}
+	if subject != "Hallo Alice" || body != "Dein Code: 1234" {
+		t.Fatalf("unerwartet: subject=%q body=%q", subject, body)
+	}
+}
+
+// Akzeptanzkriterium 3: Vorlagen pro Tenant anpassbar, Fallback auf global.
+func TestTemplateStore_TenantOverrideFallsBackToGlobal(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	key := uniqueKey("welcome")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Willkommen", "Standardtext"); err != nil {
+		t.Fatalf("set global: %v", err)
+	}
+	if err := templates.Set(ctx, "acme", key, "Willkommen bei ACME", "ACME-Text"); err != nil {
+		t.Fatalf("set tenant: %v", err)
+	}
+
+	got, err := templates.Resolve(ctx, "acme", key)
+	if err != nil {
+		t.Fatalf("resolve acme: %v", err)
+	}
+	if got.Subject != "Willkommen bei ACME" {
+		t.Fatalf("erwartet tenant-vorlage, habe %q", got.Subject)
+	}
+
+	got, err = templates.Resolve(ctx, "globex", key) // hat keine eigene vorlage
+	if err != nil {
+		t.Fatalf("resolve globex: %v", err)
+	}
+	if got.Subject != "Willkommen" {
+		t.Fatalf("erwartet global-fallback, habe %q", got.Subject)
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: als gelesen markiert wird korrekt gefuehrt.
+func TestInAppStore_MarkReadIsReflectedCorrectly(t *testing.T) {
+	_, inApp, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	userID := uniqueKey("user")
+	id, err := inApp.Create(ctx, "acme", userID, "Titel", "Text")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	list, err := inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (vor markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt != nil {
+		t.Fatalf("erwartet 1 ungelesene benachrichtigung, habe %+v", list)
+	}
+
+	if err := inApp.MarkRead(ctx, id); err != nil {
+		t.Fatalf("mark read: %v", err)
+	}
+
+	list, err = inApp.ListForUser(ctx, "acme", userID)
+	if err != nil {
+		t.Fatalf("list (nach markierung): %v", err)
+	}
+	if len(list) != 1 || list[0].ReadAt == nil {
+		t.Fatalf("erwartet als gelesen markiert, habe %+v", list)
+	}
+}
+
+// EmailSender bricht ab, BEVOR SMTP ueberhaupt kontaktiert wird, wenn keine
+// Vorlage aufloesbar ist — Nachweis, dass der Abbruch vor dem Netzwerkzugriff
+// erfolgt (Akzeptanzkriterium 1).
+func TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+
+	err := sender.Send(ctx, notify.Notification{
+		Recipient: "user@example.com",
+		Payload:   map[string]any{"template_key": uniqueKey("nie_konfiguriert"), "tenant_slug": "acme"},
+	})
+	if !errors.Is(err, ErrTemplateNotFound) {
+		t.Fatalf("erwartet ErrTemplateNotFound (kein smtp-versuch), habe %v", err)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: E-Mail-Versand bei nicht erreichbarem
+// SMTP-Server loest das dokumentierte Retry-Verhalten ueber CFG-02 aus.
+func TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP(t *testing.T) {
+	templates, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	defer pool.Close()
+
+	key := uniqueKey("retry_test")
+	if err := templates.Set(ctx, GlobalTemplateScope, key, "Betreff", "Text ohne Platzhalter"); err != nil {
+		t.Fatalf("set template: %v", err)
+	}
+
+	sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
+	dispatcher := notify.NewDispatcher(pool).WithRetryPolicy(2, time.Millisecond)
+
+	jobID, err := dispatcher.Enqueue(ctx, "email", "user@example.com", map[string]any{"template_key": key, "tenant_slug": "acme"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	for i := 0; i < 2; i++ {
+		time.Sleep(5 * time.Millisecond)
+		if _, _, err := dispatcher.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process due %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, jobID).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach ausgeschoepften wiederholungen bei unerreichbarem smtp, habe %q", status)
+	}
+	if attempts != 2 {
+		t.Fatalf("erwartet 2 versuche, habe %d", attempts)
+	}
+}
@@ -0,0 +1,81 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"net/smtp"
+	"os"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// EmailSender implementiert notify.Sender fuer den E-Mail-Kanal
+// (Akzeptanzkriterium 1). SMTP-Zugangsdaten kommen ausschliesslich aus
+// Umgebungsvariablen, nie aus Code/DB.
+type EmailSender struct {
+	templates *TemplateStore
+	host      string
+	port      string
+	from      string
+	username  string
+	password  string
+}
+
+// NewEmailSenderFromEnv liest NEXARCH_SMTP_HOST/PORT/FROM (Pflicht) sowie
+// optional NEXARCH_SMTP_USER/PASSWORD.
+func NewEmailSenderFromEnv(templates *TemplateStore) (*EmailSender, error) {
+	host := os.Getenv("NEXARCH_SMTP_HOST")
+	port := os.Getenv("NEXARCH_SMTP_PORT")
+	from := os.Getenv("NEXARCH_SMTP_FROM")
+	if host == "" || port == "" || from == "" {
+		return nil, fmt.Errorf("channels: NEXARCH_SMTP_HOST/PORT/FROM muessen gesetzt sein")
+	}
+	return &EmailSender{
+		templates: templates,
+		host:      host,
+		port:      port,
+		from:      from,
+		username:  os.Getenv("NEXARCH_SMTP_USER"),
+		password:  os.Getenv("NEXARCH_SMTP_PASSWORD"),
+	}, nil
+}
+
+// NewEmailSender erlaubt Tests, Host/Port explizit zu setzen (z.B. einen
+// absichtlich nicht erreichbaren Host fuer den Retry-Nachweis), ohne
+// Umgebungsvariablen zu benoetigen.
+func NewEmailSender(templates *TemplateStore, host, port, from string) *EmailSender {
+	return &EmailSender{templates: templates, host: host, port: port, from: from}
+}
+
+// Send rendert zuerst die Vorlage — schlaegt das fehl (z.B. fehlender
+// Platzhalter), wird NIE eine SMTP-Verbindung aufgebaut
+// (Akzeptanzkriterium 1 / Pruefung 1: kontrollierter Abbruch statt
+// fehlerhafter Mail). Ein danach fehlschlagender SMTP-Versand liefert einen
+// Fehler zurueck, den CFG-02s Dispatcher fuer die bereits getestete
+// Wiederholungslogik nutzt (Akzeptanzkriterium 3 / Pruefung 3) — kein
+// zweiter Retry-Mechanismus hier.
+func (e *EmailSender) Send(ctx context.Context, n notify.Notification) error {
+	templateKey, _ := n.Payload["template_key"].(string)
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	tmpl, err := e.templates.Resolve(ctx, tenantSlug, templateKey)
+	if err != nil {
+		return fmt.Errorf("vorlage aufloesen: %w", err)
+	}
+	subject, body, err := Render(tmpl, n.Payload)
+	if err != nil {
+		return err
+	}
+
+	msg := []byte("Subject: " + subject + "\r\n\r\n" + body)
+
+	var auth smtp.Auth
+	if e.username != "" {
+		auth = smtp.PlainAuth("", e.username, e.password, e.host)
+	}
+	addr := e.host + ":" + e.port
+	if err := smtp.SendMail(addr, auth, e.from, []string{n.Recipient}, msg); err != nil {
+		return fmt.Errorf("smtp-versand fehlgeschlagen: %w", err)
+	}
+	return nil
+}
@@ -0,0 +1,74 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type InAppNotification struct {
+	ID         string
+	TenantSlug string
+	UserID     string
+	Title      string
+	Body       string
+	ReadAt     *time.Time
+	CreatedAt  time.Time
+}
+
+// InAppStore persistiert In-App-Benachrichtigungen (Akzeptanzkriterium 2).
+type InAppStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewInAppStore(pool *pgxpool.Pool) *InAppStore {
+	return &InAppStore{pool: pool}
+}
+
+func (s *InAppStore) Create(ctx context.Context, tenantSlug, userID, title, body string) (string, error) {
+	var id string
+	err := s.pool.QueryRow(ctx, `
+		INSERT INTO in_app_notifications (tenant_slug, user_id, title, body)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, tenantSlug, userID, title, body).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("in-app-benachrichtigung speichern: %w", err)
+	}
+	return id, nil
+}
+
+// ListForUser liefert alle Benachrichtigungen eines Benutzers (ueber API
+// abrufbar, Akzeptanzkriterium 2).
+func (s *InAppStore) ListForUser(ctx context.Context, tenantSlug, userID string) ([]InAppNotification, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, title, body, read_at, created_at FROM in_app_notifications
+		WHERE tenant_slug = $1 AND user_id = $2 ORDER BY created_at DESC
+	`, tenantSlug, userID)
+	if err != nil {
+		return nil, fmt.Errorf("benachrichtigungen auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []InAppNotification
+	for rows.Next() {
+		n := InAppNotification{TenantSlug: tenantSlug, UserID: userID}
+		if err := rows.Scan(&n.ID, &n.Title, &n.Body, &n.ReadAt, &n.CreatedAt); err != nil {
+			return nil, fmt.Errorf("benachrichtigung lesen: %w", err)
+		}
+		out = append(out, n)
+	}
+	return out, rows.Err()
+}
+
+// MarkRead markiert eine Benachrichtigung als gelesen (Akzeptanzkriterium 2
+// / Pruefung 2).
+func (s *InAppStore) MarkRead(ctx context.Context, id string) error {
+	_, err := s.pool.Exec(ctx, `UPDATE in_app_notifications SET read_at = now() WHERE id = $1`, id)
+	if err != nil {
+		return fmt.Errorf("als gelesen markieren: %w", err)
+	}
+	return nil
+}
@@ -0,0 +1,41 @@
+package channels
+
+import (
+	"context"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// InAppSender implementiert notify.Sender fuer den In-App-Kanal
+// (Akzeptanzkriterium 2). Nutzt eine Vorlage, falls payload["template_key"]
+// gesetzt ist, sonst direkt payload["title"]/["body"].
+type InAppSender struct {
+	store     *InAppStore
+	templates *TemplateStore
+}
+
+func NewInAppSender(store *InAppStore, templates *TemplateStore) *InAppSender {
+	return &InAppSender{store: store, templates: templates}
+}
+
+func (s *InAppSender) Send(ctx context.Context, n notify.Notification) error {
+	tenantSlug, _ := n.Payload["tenant_slug"].(string)
+
+	var title, body string
+	if templateKey, ok := n.Payload["template_key"].(string); ok && templateKey != "" {
+		tmpl, err := s.templates.Resolve(ctx, tenantSlug, templateKey)
+		if err != nil {
+			return err
+		}
+		title, body, err = Render(tmpl, n.Payload)
+		if err != nil {
+			return err
+		}
+	} else {
+		title, _ = n.Payload["title"].(string)
+		body, _ = n.Payload["body"].(string)
+	}
+
+	_, err := s.store.Create(ctx, tenantSlug, n.Recipient, title, body)
+	return err
+}
@@ -0,0 +1,32 @@
+package channels
+
+import (
+	"context"
+	"fmt"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/notify"
+)
+
+// Router waehlt anhand von Notification.Channel den zustaendigen Kanal aus
+// — ein neuer Kanal wird per Register() ergaenzt, ohne den Dispatcher
+// (CFG-02) oder Router selbst umzubauen (Unleash-artiger Strategie-Gedanke,
+// siehe Ticket-DNA).
+type Router struct {
+	channels map[string]notify.Sender
+}
+
+func NewRouter() *Router {
+	return &Router{channels: make(map[string]notify.Sender)}
+}
+
+func (r *Router) Register(channel string, sender notify.Sender) {
+	r.channels[channel] = sender
+}
+
+func (r *Router) Send(ctx context.Context, n notify.Notification) error {
+	sender, ok := r.channels[n.Channel]
+	if !ok {
+		return fmt.Errorf("channels: unbekannter kanal %q", n.Channel)
+	}
+	return sender.Send(ctx, n)
+}
@@ -0,0 +1,104 @@
+// Package channels implementiert Core CFG-03: konkrete Zustellkanaele fuer
+// den CFG-02-Dispatcher (E-Mail, In-App) inklusive Vorlagenverwaltung.
+// Neue Kanaele lassen sich ergaenzen, ohne den Dispatcher selbst
+// anzufassen — jeder Kanal implementiert nur notify.Sender.
+package channels
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"text/template"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// GlobalTemplateScope ist der Fallback-Wert, wenn ein Tenant keine eigene
+// Vorlage konfiguriert hat (Akzeptanzkriterium 3).
+const GlobalTemplateScope = "global"
+
+var ErrTemplateNotFound = errors.New("channels: keine vorlage gefunden")
+
+type Template struct {
+	Subject string
+	Body    string
+}
+
+type TemplateStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTemplateStore(pool *pgxpool.Pool) *TemplateStore {
+	return &TemplateStore{pool: pool}
+}
+
+// Set legt eine Vorlage fuer einen Tenant (oder GlobalTemplateScope) fest.
+func (s *TemplateStore) Set(ctx context.Context, tenantSlug, key, subject, body string) error {
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO notification_templates (tenant_slug, key, subject, body, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (tenant_slug, key) DO UPDATE SET subject = $3, body = $4, updated_at = now()
+	`, tenantSlug, key, subject, body)
+	if err != nil {
+		return fmt.Errorf("vorlage speichern: %w", err)
+	}
+	return nil
+}
+
+// Resolve liefert die Vorlage eines Tenants, faellt auf GlobalTemplateScope
+// zurueck, wenn der Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3).
+func (s *TemplateStore) Resolve(ctx context.Context, tenantSlug, key string) (Template, error) {
+	if tenantSlug != "" && tenantSlug != GlobalTemplateScope {
+		if t, err := s.get(ctx, tenantSlug, key); err == nil {
+			return t, nil
+		} else if !errors.Is(err, ErrTemplateNotFound) {
+			return Template{}, err
+		}
+	}
+	return s.get(ctx, GlobalTemplateScope, key)
+}
+
+func (s *TemplateStore) get(ctx context.Context, tenantSlug, key string) (Template, error) {
+	var t Template
+	err := s.pool.QueryRow(ctx, `
+		SELECT subject, body FROM notification_templates WHERE tenant_slug = $1 AND key = $2
+	`, tenantSlug, key).Scan(&t.Subject, &t.Body)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Template{}, ErrTemplateNotFound
+		}
+		return Template{}, fmt.Errorf("vorlage lesen: %w", err)
+	}
+	return t, nil
+}
+
+// Render fuellt eine Vorlage mit data. Fehlt ein referenzierter Platzhalter
+// in data, bricht das Rendering kontrolliert MIT FEHLER ab, statt eine
+// fehlerhafte/unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1 /
+// Pruefung 1) — text/template mit Option("missingkey=error") liefert dafuer
+// einen Fehler statt stillschweigend "<no value>" einzusetzen.
+func Render(tmpl Template, data map[string]any) (subject, body string, err error) {
+	subject, err = renderOne("subject", tmpl.Subject, data)
+	if err != nil {
+		return "", "", err
+	}
+	body, err = renderOne("body", tmpl.Body, data)
+	if err != nil {
+		return "", "", err
+	}
+	return subject, body, nil
+}
+
+func renderOne(name, text string, data map[string]any) (string, error) {
+	tmpl, err := template.New(name).Option("missingkey=error").Parse(text)
+	if err != nil {
+		return "", fmt.Errorf("vorlage %q parsen: %w", name, err)
+	}
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, data); err != nil {
+		return "", fmt.Errorf("vorlage %q rendern (fehlender platzhalter?): %w", name, err)
+	}
+	return buf.String(), nil
+}
@@ -0,0 +1,81 @@
+// Package notify implementiert Core CFG-02: den zentralen Benachrichtigungs-
+// Dispatcher, ueber den beliebige Module Benachrichtigungen ausloesen —
+// Warteschlange, Wiederholungslogik, Kanal-Abstraktion. Die tatsaechlichen
+// Kanaele (E-Mail/In-App) sind CFG-03, hier gibt es nur die Sender-
+// Schnittstelle als Vorbereitung.
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// DefaultMaxAttempts begrenzt Wiederholungsversuche (Akzeptanzkriterium 2) —
+// nach dieser Anzahl gibt der Dispatcher kontrolliert auf (status=failed)
+// statt endlos zu wiederholen.
+const DefaultMaxAttempts = 5
+
+// DefaultRetryBackoff ist die Basis-Wartezeit zwischen Wiederholungen,
+// linear mit der Versuchsnummer skaliert.
+const DefaultRetryBackoff = 200 * time.Millisecond
+
+type Notification struct {
+	ID        string
+	Channel   string
+	Recipient string
+	Payload   map[string]any
+	Attempts  int
+}
+
+// Sender ist die schmale Schnittstelle, die ein konkreter Kanal (CFG-03)
+// implementiert. Der Dispatcher selbst weiss nichts ueber E-Mail/In-App.
+type Sender interface {
+	Send(ctx context.Context, n Notification) error
+}
+
+// Dispatcher ist die EINE Schnittstelle, ueber die Module Benachrichtigungen
+// ausloesen — kein Modul baut eigenen Versandcode (Akzeptanzkriterium 1).
+type Dispatcher struct {
+	pool         *pgxpool.Pool
+	maxAttempts  int
+	retryBackoff time.Duration
+}
+
+func NewDispatcher(pool *pgxpool.Pool) *Dispatcher {
+	return &Dispatcher{pool: pool, maxAttempts: DefaultMaxAttempts, retryBackoff: DefaultRetryBackoff}
+}
+
+// WithRetryPolicy erlaubt Tests/Betrieb, Versuchsanzahl und Backoff
+// anzupassen, ohne die Default-Policy im Produktionscode zu veraendern.
+func (d *Dispatcher) WithRetryPolicy(maxAttempts int, backoff time.Duration) *Dispatcher {
+	return &Dispatcher{pool: d.pool, maxAttempts: maxAttempts, retryBackoff: backoff}
+}
+
+// Enqueue reiht eine Benachrichtigung in die Postgres-Warteschlange ein und
+// kehrt sofort zurueck — die Zeile ueberlebt jeden Neustart des Dispatcher-
+// Prozesses unveraendert (Akzeptanzkriterium 3), da sie ausschliesslich in
+// der Datenbank existiert, nicht im Prozessspeicher.
+func (d *Dispatcher) Enqueue(ctx context.Context, channel, recipient string, payload map[string]any) (string, error) {
+	if payload == nil {
+		payload = map[string]any{}
+	}
+	payloadJSON, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("payload serialisieren: %w", err)
+	}
+
+	var id string
+	err = d.pool.QueryRow(ctx, `
+		INSERT INTO notification_jobs (channel, recipient, payload, max_attempts)
+		VALUES ($1, $2, $3, $4)
+		RETURNING id
+	`, channel, recipient, payloadJSON, d.maxAttempts).Scan(&id)
+	if err != nil {
+		return "", fmt.Errorf("benachrichtigung einreihen: %w", err)
+	}
+	return id, nil
+}
@@ -0,0 +1,219 @@
+package notify
+
+import (
+	"context"
+	"errors"
+	"os"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*pgxpool.Pool, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	pool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("pool: %v", err)
+	}
+	if _, err := pool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS notification_jobs (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			channel TEXT NOT NULL,
+			recipient TEXT NOT NULL,
+			payload JSONB NOT NULL DEFAULT '{}'::jsonb,
+			status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+			attempts INT NOT NULL DEFAULT 0,
+			max_attempts INT NOT NULL DEFAULT 5,
+			next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			last_error TEXT,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	cleanup := func() { pool.Close() }
+	return pool, cleanup
+}
+
+type fakeSender struct {
+	mu        sync.Mutex
+	sentIDs   []string
+	failUntil int
+	calls     int
+}
+
+func (f *fakeSender) Send(ctx context.Context, n Notification) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.calls++
+	if f.calls <= f.failUntil {
+		return errors.New("simulierter zustellfehler")
+	}
+	f.sentIDs = append(f.sentIDs, n.ID)
+	return nil
+}
+
+func (f *fakeSender) sentCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.sentIDs)
+}
+
+// Akzeptanzkriterium 1: Module loesen ueber Enqueue aus, keine eigene
+// Versandlogik noetig.
+func TestDispatcher_EnqueueAndProcess(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	id, err := d.Enqueue(ctx, "email", "alice@example.com", map[string]any{"subject": "Willkommen"})
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+	if id == "" {
+		t.Fatal("erwartet nicht-leere id")
+	}
+
+	sender := &fakeSender{}
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 failed=0, habe sent=%d failed=%d", sent, failed)
+	}
+	if sender.sentCount() != 1 {
+		t.Fatalf("erwartet 1 zustellung, habe %d", sender.sentCount())
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Wiederholungslogik greift bei
+// simuliertem Fehler und bricht nach definierter Anzahl kontrolliert ab.
+func TestProcessDue_RetriesThenGivesUpAfterMaxAttempts(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool).WithRetryPolicy(3, time.Millisecond)
+	id, err := d.Enqueue(ctx, "email", "bob@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	sender := &fakeSender{failUntil: 100} // schlaegt bei jedem versuch fehl
+
+	for i := 0; i < 3; i++ {
+		time.Sleep(5 * time.Millisecond) // next_attempt_at abwarten
+		if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+			t.Fatalf("process %d: %v", i, err)
+		}
+	}
+
+	var status string
+	var attempts int
+	if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, id).Scan(&status, &attempts); err != nil {
+		t.Fatalf("status lesen: %v", err)
+	}
+	if status != "failed" {
+		t.Fatalf("erwartet status failed nach max_attempts, habe %q", status)
+	}
+	if attempts != 3 {
+		t.Fatalf("erwartet 3 versuche, habe %d", attempts)
+	}
+
+	// Weiteres ProcessDue darf den bereits aufgegebenen job nicht mehr anfassen.
+	sent, failed, err := d.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach abbruch: %v", err)
+	}
+	if sent != 0 || failed != 0 {
+		t.Fatalf("erwartet keine weitere verarbeitung, habe sent=%d failed=%d", sent, failed)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: Neustart des Dienstes waehrend offener
+// Zustellung verliert keine Nachricht — simuliert durch eine komplett neue
+// Dispatcher/Pool-Instanz nach dem Enqueue, bevor irgendetwas verarbeitet wurde.
+func TestQueue_SurvivesRestartWithoutMessageLoss(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	firstInstance := NewDispatcher(pool)
+	id, err := firstInstance.Enqueue(ctx, "email", "carol@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue: %v", err)
+	}
+
+	// "Neustart": eine voellig neue Dispatcher-Instanz (repraesentiert einen
+	// neuen Prozess) verbindet sich neu und verarbeitet die Warteschlange —
+	// die Nachricht existiert ausschliesslich in Postgres, nicht im
+	// Prozessspeicher der ersten Instanz.
+	restartedInstance := NewDispatcher(pool)
+	sender := &fakeSender{}
+	sent, failed, err := restartedInstance.ProcessDue(ctx, sender, 10)
+	if err != nil {
+		t.Fatalf("process nach neustart: %v", err)
+	}
+	if sent != 1 || failed != 0 {
+		t.Fatalf("erwartet sent=1 nach neustart, habe sent=%d failed=%d", sent, failed)
+	}
+	if len(sender.sentIDs) != 1 || sender.sentIDs[0] != id {
+		t.Fatalf("erwartet zustellung der urspruenglichen nachricht %q, habe %v", id, sender.sentIDs)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 3: zwei gleichzeitig ausloesende Module,
+// beide Nachrichten werden korrekt (und nicht doppelt) zugestellt.
+func TestProcessDue_ConcurrentDispatchBothDelivered(t *testing.T) {
+	pool, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	d := NewDispatcher(pool)
+	idA, err := d.Enqueue(ctx, "email", "modul-a@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue a: %v", err)
+	}
+	idB, err := d.Enqueue(ctx, "email", "modul-b@example.com", nil)
+	if err != nil {
+		t.Fatalf("enqueue b: %v", err)
+	}
+
+	sender := &fakeSender{}
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if _, _, err := d.ProcessDue(ctx, sender, 10); err != nil {
+				t.Errorf("process: %v", err)
+			}
+		}()
+	}
+	wg.Wait()
+
+	if sender.sentCount() != 2 {
+		t.Fatalf("erwartet genau 2 zustellungen, habe %d: %v", sender.sentCount(), sender.sentIDs)
+	}
+	seen := map[string]bool{}
+	for _, id := range sender.sentIDs {
+		if seen[id] {
+			t.Fatalf("nachricht %q wurde doppelt zugestellt", id)
+		}
+		seen[id] = true
+	}
+	if !seen[idA] || !seen[idB] {
+		t.Fatalf("erwartet beide nachrichten zugestellt, habe %v", sender.sentIDs)
+	}
+}
@@ -0,0 +1,102 @@
+package notify
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// ProcessDue holt bis zu limit faellige Benachrichtigungen und versucht sie
+// ueber sender zuzustellen. FOR UPDATE SKIP LOCKED serialisiert konkurrierende
+// Aufrufe (Akzeptanzkriterium 3 / Pruefung 3: zwei gleichzeitig ausloesende
+// Module duerfen sich nicht gegenseitig blockieren oder Nachrichten doppelt
+// zustellen) — dieselbe Konvention wie internal/tenant.Lifecycle.ProcessDueDeletions.
+func (d *Dispatcher) ProcessDue(ctx context.Context, sender Sender, limit int) (sent, failed int, err error) {
+	tx, err := d.pool.Begin(ctx)
+	if err != nil {
+		return 0, 0, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	rows, err := tx.Query(ctx, `
+		SELECT id, channel, recipient, payload, attempts, max_attempts
+		FROM notification_jobs
+		WHERE status = 'pending' AND next_attempt_at <= now()
+		ORDER BY created_at
+		FOR UPDATE SKIP LOCKED
+		LIMIT $1
+	`, limit)
+	if err != nil {
+		return 0, 0, fmt.Errorf("faellige benachrichtigungen abfragen: %w", err)
+	}
+
+	type due struct {
+		id, channel, recipient string
+		payload                []byte
+		attempts, maxAttempts  int
+	}
+	var candidates []due
+	for rows.Next() {
+		var c due
+		if err := rows.Scan(&c.id, &c.channel, &c.recipient, &c.payload, &c.attempts, &c.maxAttempts); err != nil {
+			rows.Close()
+			return 0, 0, fmt.Errorf("faellige benachrichtigung lesen: %w", err)
+		}
+		candidates = append(candidates, c)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, 0, err
+	}
+
+	for _, c := range candidates {
+		var payload map[string]any
+		if err := json.Unmarshal(c.payload, &payload); err != nil {
+			payload = map[string]any{}
+		}
+
+		sendErr := sender.Send(ctx, Notification{
+			ID: c.id, Channel: c.channel, Recipient: c.recipient, Payload: payload, Attempts: c.attempts,
+		})
+
+		if sendErr == nil {
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs SET status = 'sent', updated_at = now() WHERE id = $1
+			`, c.id); err != nil {
+				return sent, failed, fmt.Errorf("erfolg speichern: %w", err)
+			}
+			sent++
+			continue
+		}
+
+		newAttempts := c.attempts + 1
+		if newAttempts >= c.maxAttempts {
+			// Akzeptanzkriterium 2: kontrollierter Abbruch nach definierter
+			// Anzahl Versuche, kein endloses Wiederholen.
+			if _, err := tx.Exec(ctx, `
+				UPDATE notification_jobs
+				SET status = 'failed', attempts = $2, last_error = $3, updated_at = now()
+				WHERE id = $1
+			`, c.id, newAttempts, sendErr.Error()); err != nil {
+				return sent, failed, fmt.Errorf("fehlschlag speichern: %w", err)
+			}
+			failed++
+			continue
+		}
+
+		nextAttempt := time.Now().Add(time.Duration(newAttempts) * d.retryBackoff)
+		if _, err := tx.Exec(ctx, `
+			UPDATE notification_jobs
+			SET attempts = $2, next_attempt_at = $3, last_error = $4, updated_at = now()
+			WHERE id = $1
+		`, c.id, newAttempts, nextAttempt, sendErr.Error()); err != nil {
+			return sent, failed, fmt.Errorf("wiederholung planen: %w", err)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return 0, 0, fmt.Errorf("transaktion committen: %w", err)
+	}
+	return sent, failed, nil
+}
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS notification_jobs;
@@ -0,0 +1,20 @@
+-- Benachrichtigungs-Dispatcher-Warteschlange (CFG-02, siehe
+-- core-kanban/tickets/CFG-02.md). Postgres-basiert statt Redis/AMQP
+-- (Projekt-Konvention, siehe nexarch-state.json techstack.job_queue) —
+-- Zeilen ueberleben einen Neustart des Dispatcher-Prozesses unveraendert
+-- (Akzeptanzkriterium 3).
+CREATE TABLE notification_jobs (
+    id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    channel         TEXT NOT NULL,
+    recipient       TEXT NOT NULL,
+    payload         JSONB NOT NULL DEFAULT '{}'::jsonb,
+    status          TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
+    attempts        INT NOT NULL DEFAULT 0,
+    max_attempts    INT NOT NULL DEFAULT 5,
+    next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+    last_error      TEXT,
+    created_at      TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at      TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX notification_jobs_due_idx ON notification_jobs (status, next_attempt_at);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS in_app_notifications;
+DROP TABLE IF EXISTS notification_templates;
@@ -0,0 +1,28 @@
+-- Benachrichtigungs-Kanaele: Vorlagen (E-Mail) + In-App-Nachrichten
+-- (CFG-03, siehe core-kanban/tickets/CFG-03.md). Beide leben in der
+-- Registry-DB, analog zu feature_flags/config_values — modulübergreifende
+-- Konfiguration/UI-Zustand, keine Mandanten-Geschaeftsdaten.
+
+-- tenant_slug = 'global' ist der Fallback-Wert, wenn ein Tenant keine
+-- eigene Vorlage gesetzt hat (Akzeptanzkriterium 3: Vorlagen pro Tenant
+-- anpassbar, mit sinnvollem Default).
+CREATE TABLE notification_templates (
+    tenant_slug TEXT NOT NULL,
+    key         TEXT NOT NULL,
+    subject     TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    updated_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_slug, key)
+);
+
+CREATE TABLE in_app_notifications (
+    id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_slug TEXT NOT NULL,
+    user_id     TEXT NOT NULL,
+    title       TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    read_at     TIMESTAMPTZ,
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX in_app_notifications_user_idx ON in_app_notifications (tenant_slug, user_id, created_at);
@@ -1,26 +1,11 @@
 #!/usr/bin/env bash
-# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
-# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
-# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
-# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
-# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 ROLE="nexarch_test"
-
 export PGPASSWORD="$PASS"
-
 psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
-psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events CASCADE;"
-psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS config_value_history CASCADE;"
-psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS config_values CASCADE;"
-
 dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
 for db in $dbs; do
 	psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
 done
-
 echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
@@ -1,24 +1,12 @@
 #!/usr/bin/env bash
-# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
-# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
-# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
-# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
-#
-# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
 set -euo pipefail
-
 PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
 cd "$(dirname "$0")/.."
-
 NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
-
 export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
-
 echo "== go build =="
 go build ./...
-
 echo "== go vet =="
 go vet ./...
-
 echo "== go test (-p 1) =="
 go test ./... -p 1 -count=1