TEN-03: tenant-einstellungen-branding

internal/tenantsettings: pro-Tenant-Einstellungen (Anzeigename, Logo, Farbschema, Zeitzone, Sprache) in der Registry-DB, alle Spalten nullable — fehlender Wert bedeutet immer "Systemvoreinstellung verwenden" (Defaults(): color_scheme=system, timezone=UTC, language=de), niemals ein Fehler (Akzeptanzkriterium 2). Store.Update schreibt aktuellen Stand + Historieneintrag atomar in einer Transaktion mit FOR-UPDATE-Lock auf der aktuellen Zeile (Akzeptanzkriterium 3, Race-sicher bei nebenlaeufigen Updates desselben Tenants). Patch-Typ mit *string-Feldern erlaubt Teil-Updates ohne unbeteiligte Felder zu beruehren. Schlanker Handler (Get/Update ueber tenant_id-Query-Parameter) als Vorbereitung der REST-Schnittstelle — echte Auth/Versionierung kommt erst mit API-01/IAM-02/RBAC-01. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Aenderung eines Tenants wirkt sich nicht auf einen anderen aus — TestUpdate_IsolatedBetweenTenants: Tenant A geaendert, Tenant B bleibt nachweislich bei Defaults(). PASS. 2. Fehlende Werte liefern Defaults statt Fehler — TestGet_UnsetTenantReturnsDefaults (Tenant ganz ohne Datensatz) und TestUpdate_PartialPatchKeepsOtherFieldsAtDefault (nur ein Feld gesetzt, Rest bleibt Default). PASS. 3. API-Schema von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Zusaetzlich automatisiert getestet (Akzeptanzkriterium 3): TestUpdate_HistoryTracksVersions — 3 aufeinanderfolgende Aenderungen, Historie liefert alle 3 in korrekter Reihenfolge, nicht angefasste Felder bleiben aus dem vorherigen Update erhalten. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
TEN-02: tenant-onboarding-api-self-service
2026-08-27 19:34:09 +02:00 · 2026-08-27 18:16:54 +02:00 · 2026-08-27 17:57:49 +02:00 · 2026-08-27 17:40:35 +02:00
39 changed files with 1941 additions and 493 deletions
@@ -1,20 +0,0 @@
-name: Core-Pflichttest-Gate
-
-on:
-  pull_request: {}
-
-jobs:
-  pflichttest-gate:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v5
-        with:
-          go-version: "1.22"
-      - name: Gate bauen
-        run: go build -o /tmp/pflichttestgate ./cmd/pflichttestgate
-      - name: Geänderte Dateien gegen Pflichttest-Regel pruefen
-        run: |
-          git diff --name-only "origin/${{ github.base_ref }}...HEAD" | /tmp/pflichttestgate
@@ -44,20 +44,111 @@ Keine Commits in dieser Session.
 Keine Änderungen ermittelbar.

 ---
-## 2026-08-28 22:37 – 22:41 (3m)
+## 2026-08-27 17:26 – 17:28 (1m)
 **Beschreibung:** Claude Code Session
-**Projekt:** nexarch
+**Projekt:** code

 ### Commits
- 5a0d074 QA-01: teststrategie-core (pflichttest-gate, testdb-isolationsnachweis, ci-workflow)
+- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)

 ### Geänderte Dateien
- .gitea/workflows/pflichttest-gate.yml      | 20 ++++++++++++++++++++
- cmd/pflichttestgate/main.go                | 41 +++++++++++++++++++++++++++++++++++++++++
- docs/TESTSTRATEGIE-CORE.md                 | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- internal/pflichttestgate/gate.go           | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- internal/pflichttestgate/gate_test.go      | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- internal/testdbisolation/isolation.go      | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- internal/testdbisolation/isolation_test.go | 99 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:28 – 17:29 (1m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:31 – 17:31 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:36 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:36 – 17:37 (0m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+Keine Commits in dieser Session.
+
+### Geänderte Dateien
+- .gitignore                          |  2 ++
+- DEVLOG.md                           | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+- cmd/core/main.go                    | 33 +++++++++++++++++++++++++++++++++
+- go.mod                              |  5 +++++
+- internal/config/config.go           | 29 +++++++++++++++++++++++++++++
+- internal/db/db.go                   | 11 +++++++++++
+- migrations/0001_tenant_registry.sql | 10 ++++++++++
+
+---
+## 2026-08-27 17:53 – 17:57 (4m)
+**Beschreibung:** Claude Code Session
+**Projekt:** code
+
+### Commits
+- e479330 IAM-01: benutzer-datenmodell-crud
+
+### Geänderte Dateien
+- cmd/core/main.go                      |  11 ++++++++++-
+- go.mod                                |   9 +++++++++
+- go.sum                                |  28 ++++++++++++++++++++++++++++
+- internal/user/handler.go              |  66 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/user/store_test.go           | 173 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/user/superadmin_store.go     |  77 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/user/tenant_store.go         | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+- internal/user/user.go                 |  42 ++++++++++++++++++++++++++++++++++++++++++
+- internal/user/user_test.go            |  24 ++++++++++++++++++++++++
+- migrations/0002_superadmins.down.sql  |   1 +
+- migrations/0002_superadmins.up.sql    |  14 ++++++++++++++
+- migrations/tenant/0001_users.down.sql |   1 +
+- migrations/tenant/0001_users.up.sql   |  16 ++++++++++++++++

 ---
@@ -7,6 +7,8 @@ import (

 	"gitea.perlbach24.de/scripte/nexarch/internal/config"
 	"gitea.perlbach24.de/scripte/nexarch/internal/db"
+	"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
 )

 func main() {
@@ -15,16 +17,41 @@ func main() {
 		log.Fatalf("config: %v", err)
 	}

-	pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
+	ctx := context.Background()
+
+	registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
 	if err != nil {
-		log.Fatalf("db: %v", err)
+		log.Fatalf("registry db: %v", err)
 	}
-	defer pool.Close()
+	defer registryPool.Close()
+
+	adminPool, err := db.Connect(ctx, cfg.AdminDSN)
+	if err != nil {
+		log.Fatalf("admin db: %v", err)
+	}
+	defer adminPool.Close()
+
+	registry := tenant.NewRegistry(registryPool)
+	provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
+	tenantHandler := tenant.NewHandler(provisioner)
+	onboardingService := tenant.NewOnboardingService(provisioner, cfg.TenantSchemaPath)
+	onboardingHandler := tenant.NewOnboardingHandler(onboardingService)
+
+	// Superadmin-Konten leben mandantenuebergreifend in der Registry-DB.
+	// Tenant-User-CRUD (user.TenantUserStore) braucht Connection-Routing pro
+	// Mandant (TEN-06, noch nicht gebaut) und wird hier bewusst noch nicht
+	// verdrahtet — Package ist bereits eigenstaendig nutzbar/testbar.
+	superadmins := user.NewSuperadminStore(registryPool)
+	userHandler := user.NewHandler(nil, superadmins)

 	mux := http.NewServeMux()
 	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
+	// Vorlaeufige Pfade ohne Versionierung/Auth — werden mit API-01/IAM-02 abgeloest.
+	mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
+	mux.HandleFunc("/internal/tenants/onboard", onboardingHandler.Onboard)
+	mux.HandleFunc("/internal/superadmins", userHandler.CreateSuperadmin)

 	log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
 	if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
@@ -1,41 +0,0 @@
-// Command pflichttestgate ist das CI-Gate aus docs/TESTSTRATEGIE-CORE.md Abschnitt 5.
-// Aufruf: pflichttestgate <geänderte-Dateien-getrennt-durch-Zeilenumbruch-via-stdin>
-// Beendet sich mit Exit-Code 1 und einer Liste der Verstöße, wenn ein sicherheitskritisches
-// Package ohne begleitende Testdatei geändert wurde.
-package main
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-
-	"gitea.perlbach24.de/scripte/nexarch/internal/pflichttestgate"
-)
-
-func main() {
-	var changedFiles []string
-	scanner := bufio.NewScanner(os.Stdin)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if line != "" {
-			changedFiles = append(changedFiles, line)
-		}
-	}
-	if err := scanner.Err(); err != nil {
-		fmt.Fprintf(os.Stderr, "pflichttestgate: Eingabe konnte nicht gelesen werden: %v\n", err)
-		os.Exit(2)
-	}
-
-	violations := pflichttestgate.CheckDiff(changedFiles)
-	if len(violations) == 0 {
-		fmt.Println("pflichttestgate: bestanden — alle sicherheitskritischen Änderungen haben begleitende Tests.")
-		return
-	}
-
-	fmt.Fprintln(os.Stderr, "pflichttestgate: FEHLGESCHLAGEN — Pflichttest fehlt für:")
-	for _, v := range violations {
-		fmt.Fprintf(os.Stderr, "  - Package %q (Datei %q hat keine begleitende _test.go-Änderung)\n", v.Package, v.ChangedFile)
-	}
-	fmt.Fprintln(os.Stderr, "\nSiehe docs/TESTSTRATEGIE-CORE.md Abschnitt 3.")
-	os.Exit(1)
-}
@@ -1,81 +0,0 @@
-# NEXARCH Core – Teststrategie
-
-Stand: 2026-08-28. Ticket: QA-01.
-
-## 1. Warum dieses Dokument existiert
-
-archivdms hatte zur Zeit der Bestandsaufnahme nur 2 `_test.go`-Dateien in ganz `internal/`, davon 0 für
-`auth`/`storage`/`permissions.go`. archivmail testete 2 von 18 Modulen. Beide Lücken wurden erst im
-Betrieb entdeckt, nicht vor dem Merge. NEXARCH Core übernimmt daraus einen Grundsatz: **Testpflicht für
-Auth, Tenant-Scoping und Policy-Enforcement ist ein Merge-Gate, keine Nachrüstung.**
-
-## 2. Testpyramide
-
-| Ebene | Werkzeug | Umfang |
-|---|---|---|
-| Unit | `go test` (Standardbibliothek) | Einzelne Funktionen/Typen, keine externe Abhängigkeit (DB, Netzwerk) |
-| Integration | `go test` gegen echte PostgreSQL-Instanz (`nexarch_test`-Rolle) | Repository-/Handler-Schicht, Tenant-Scoping, Policy-Enforcement |
-| Vertragstests | `internal/contracttest` (siehe QA-07) | Öffentliche API-Verträge zwischen Core und Modulen |
-| Last-/Leistungstests | `internal/loadtest` (siehe QA-08) | Mehrmodul-Last, JWT-Verifikation, Connection-Pooling |
-| Extern | Core `QA-06` Penetrationstest | Vor Produktivbetrieb, außerhalb dieses CI-Gates |
-
-Diese Kachel (QA-01) legt die Pflichtebenen fest und erzwingt sie technisch für die drei sicherheitskritischsten Bereiche; sie ersetzt nicht QA-07/QA-08, die eigene, bereits umgesetzte CI-Gates haben.
-
-## 3. Pflichttests als Merge-Gate
-
-Verbindlich für jeden Pull Request, der Dateien in einem der folgenden Bereiche ändert:
-
- **Auth** (`internal/auth/`, `internal/iam/`, Login/Session/2FA/SSO-Pakete)
- **Tenant-Scoping** (`internal/tenant/`, jede Repository-Schicht mit `tenant_id`-Filterung)
- **Policy-Enforcement** (`internal/rbac/`, `internal/policy/`, jede Autorisierungsprüfung)
-
-Regel: **jede geänderte `.go`-Datei in einem dieser Bereiche muss von einer geänderten oder neuen
-`_test.go`-Datei im selben Package begleitet sein.** Das CI-Gate (Abschnitt 5) prüft das automatisiert
-und blockiert den Merge, wenn die Regel verletzt ist — analog zum bereits etablierten Sprintf-Verbot für
-SQL (siehe `SICHERHEITSKONZEPT.md`), nur als technisch erzwungene statt nur dokumentierte Regel.
-
-Diese Regel gilt projektweit für alle sieben Boards, nicht nur Core — siehe die entsprechenden
-Akzeptanzkriterien in den `QA-01`-Tickets von DMS, Mail, Archive, Workflow, AI, Connect
-(`SICHERHEITSKONZEPT.md` Abschnitt 11, Punkt 8, 2026-08-28 geklärt).
-
-## 4. Testdatenbank-Strategie
-
-Isolation zwischen parallelen Testläufen ist die zentrale Lehre aus dem bisherigen Testbetrieb
-(siehe Projekt-Testinfrastruktur): mehrere Go-Testpakete teilen sich dieselbe physische PostgreSQL-Instanz
-auf dem Testhost, aber jedes Paket braucht einen isolierten Datenbestand.
-
- **Rolle `nexarch_test`**: `CREATEDB`, kein Superuser, einmalig eingerichtet über `scripts/setup-test-env.sh`.
- **Reset vor jedem Testlauf**: `scripts/reset-test-env.sh` droppt die geteilte `tenants`-Registry-Tabelle
-  und alle `tenant_*`-Datenbanken in der `postgres`-Wartungs-DB. Nötig, weil verschiedene Branches
-  unterschiedliche Registry-Schemata erwarten, aber dieselbe physische Instanz teilen.
- **`-p 1` ist Pflicht** für `go test ./...`, sobald mehrere Pakete gegen die geteilte Registry-Tabelle
-  testen (z. B. `internal/tenant` + `internal/migrate`). Ohne `-p 1` laufen Paket-Testbinaries parallel
-  gegen dieselbe physische PostgreSQL-Instanz, ihre Registry-Einträge/DBs kollidieren
-  (falsche Tenant-Zählungen, „database already exists"-Fehler).
- **Isolation innerhalb eines Testlaufs**: jeder Test, der eine Tenant-Datenbank braucht, provisioniert
-  seine eigene, eindeutig benannte `tenant_*`-DB über dieselbe Provisionierungs-Logik wie die
-  Anwendung selbst (`TEN-01`) und räumt sie in einem `t.Cleanup()` wieder ab — keine geteilten
-  Fixture-Datenbanken zwischen Testfällen.
-
-Siehe `internal/testdbisolation/isolation_test.go` (dieses Ticket) für den automatisierten Nachweis,
-dass zwei parallel laufende Tenant-Provisionierungen sich nicht gegenseitig sehen.
-
-## 5. CI-Gate
-
-`.gitea/workflows/pflichttest-gate.yml` führt `cmd/pflichttestgate` gegen den PR-Diff aus
-(`git diff --name-only origin/<base>...HEAD`). Das Programm:
-
-1. Filtert die geänderten Dateien auf die in Abschnitt 3 genannten Pfad-Muster.
-2. Prüft je betroffenem Go-Package, ob mindestens eine `_test.go`-Datei desselben Packages ebenfalls
-   im Diff enthalten ist.
-3. Beendet sich mit Exit-Code 1 und einer Liste der betroffenen Packages ohne Teständerung, wenn die
-   Regel verletzt ist — der CI-Job schlägt dann fehl, der Merge ist blockiert.
-
-Negativtest des Gates selbst: `internal/pflichttestgate/gate_test.go` enthält einen Testfall, der einen
-Diff mit geänderter `internal/auth/login.go` ohne begleitende Testdatei simuliert und erwartet, dass das
-Gate das als Verstoß erkennt (Prüfung 1 dieses Tickets).
-
-## 6. Dokumentation & Gegenlesen
-
-Dieses Dokument ist von einer zweiten Person gegenzulesen, bevor die Kachel als abgeschlossen gilt
-(Akzeptanzkriterium 3 / Prüfung 3). Fund/Freigabe wird im Pull Request vermerkt.
@@ -3,3 +3,12 @@ module gitea.perlbach24.de/scripte/nexarch
 go 1.22

 require github.com/jackc/pgx/v5 v5.6.0
+
+require (
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+)
@@ -10,8 +10,18 @@ import (
 // connection info, superadmin accounts) — see nexarch-state.json
 // multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
 type Config struct {
-	ListenAddr  string
+	ListenAddr string
+	// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
 	RegistryDSN string
+	// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
+	// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
+	AdminDSN string
+	// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
+	TenantDSNTemplate string
+	// TenantSchemaPath zeigt auf migrations/tenant/0001_users.up.sql, mit der
+	// TEN-02 eine frisch provisionierte Tenant-Datenbank initialisiert.
+	TenantSchemaPath string
 }

 func Load() (Config, error) {
@@ -20,10 +30,31 @@ func Load() (Config, error) {
 		return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
 	}

+	adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
+	if adminDSN == "" {
+		return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
+	}
+
+	dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
+	if dsnTemplate == "" {
+		return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
+	}
+
+	schemaPath := os.Getenv("NEXARCH_TENANT_SCHEMA_PATH")
+	if schemaPath == "" {
+		return Config{}, fmt.Errorf("NEXARCH_TENANT_SCHEMA_PATH not set")
+	}
+
 	addr := os.Getenv("NEXARCH_LISTEN_ADDR")
 	if addr == "" {
 		addr = ":8080"
 	}

-	return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
+	return Config{
+		ListenAddr:        addr,
+		RegistryDSN:       dsn,
+		AdminDSN:          adminDSN,
+		TenantDSNTemplate: dsnTemplate,
+		TenantSchemaPath:  schemaPath,
+	}, nil
 }
@@ -1,67 +0,0 @@
-// Package pflichttestgate erzwingt die in docs/TESTSTRATEGIE-CORE.md Abschnitt 3 festgelegte Regel:
-// jede geänderte Go-Datei in einem sicherheitskritischen Bereich (Auth, Tenant-Scoping, Policy)
-// muss von einer geänderten oder neuen _test.go-Datei im selben Package begleitet sein.
-package pflichttestgate
-
-import (
-	"path"
-	"regexp"
-	"strings"
-)
-
-// sensitivePathPatterns beschreibt die Bereiche aus TESTSTRATEGIE-CORE.md Abschnitt 3.
-var sensitivePathPatterns = []*regexp.Regexp{
-	regexp.MustCompile(`(^|/)internal/auth/`),
-	regexp.MustCompile(`(^|/)internal/iam/`),
-	regexp.MustCompile(`(^|/)internal/tenant/`),
-	regexp.MustCompile(`(^|/)internal/rbac/`),
-	regexp.MustCompile(`(^|/)internal/policy/`),
-}
-
-// Violation beschreibt ein Package mit sicherheitskritischer Änderung ohne begleitende Testdatei.
-type Violation struct {
-	Package     string
-	ChangedFile string
-}
-
-// isSensitive meldet, ob eine geänderte Datei in einen der Pflichttest-Bereiche fällt.
-func isSensitive(file string) bool {
-	if !strings.HasSuffix(file, ".go") || strings.HasSuffix(file, "_test.go") {
-		return false
-	}
-	for _, re := range sensitivePathPatterns {
-		if re.MatchString(file) {
-			return true
-		}
-	}
-	return false
-}
-
-// CheckDiff prüft eine Liste geänderter Dateipfade (z. B. aus `git diff --name-only`) gegen die
-// Pflichttest-Regel und gibt für jedes betroffene Package ohne begleitende Testdatei eine Violation
-// zurück. Ein leeres Ergebnis bedeutet: Gate besteht.
-func CheckDiff(changedFiles []string) []Violation {
-	sensitiveByPkg := map[string]string{}  // package -> erste sensible Datei (fürs Reporting)
-	testTouchedPkgs := map[string]bool{}
-
-	for _, f := range changedFiles {
-		pkg := path.Dir(f)
-		if strings.HasSuffix(f, "_test.go") {
-			testTouchedPkgs[pkg] = true
-			continue
-		}
-		if isSensitive(f) {
-			if _, seen := sensitiveByPkg[pkg]; !seen {
-				sensitiveByPkg[pkg] = f
-			}
-		}
-	}
-
-	var violations []Violation
-	for pkg, file := range sensitiveByPkg {
-		if !testTouchedPkgs[pkg] {
-			violations = append(violations, Violation{Package: pkg, ChangedFile: file})
-		}
-	}
-	return violations
-}
@@ -1,84 +0,0 @@
-package pflichttestgate
-
-import "testing"
-
-// Prüfung 1 (QA-01): CI-Lauf mit absichtlich fehlendem Pflichttest schlägt kontrolliert fehl —
-// Negativtest des Gates selbst.
-func TestCheckDiff_BlocksAuthChangeWithoutTest(t *testing.T) {
-	changed := []string{
-		"internal/auth/login.go",
-		"internal/apiserver/handler.go", // unkritisch, keine Testpflicht
-	}
-
-	violations := CheckDiff(changed)
-
-	if len(violations) != 1 {
-		t.Fatalf("erwartet 1 Verstoß, bekommen %d: %+v", len(violations), violations)
-	}
-	if violations[0].Package != "internal/auth" {
-		t.Errorf("erwartetes Package internal/auth, bekommen %q", violations[0].Package)
-	}
-	if violations[0].ChangedFile != "internal/auth/login.go" {
-		t.Errorf("erwartete Datei internal/auth/login.go, bekommen %q", violations[0].ChangedFile)
-	}
-}
-
-func TestCheckDiff_PassesWhenTestFileAccompaniesChange(t *testing.T) {
-	changed := []string{
-		"internal/auth/login.go",
-		"internal/auth/login_test.go",
-	}
-
-	violations := CheckDiff(changed)
-
-	if len(violations) != 0 {
-		t.Fatalf("erwartet keinen Verstoß, bekommen %+v", violations)
-	}
-}
-
-func TestCheckDiff_PassesForNewTestFileEvenWithoutSourceChange(t *testing.T) {
-	// Nachtraeglich ergaenzter Test fuer bestehenden Code ist erlaubt/erwuenscht.
-	changed := []string{"internal/tenant/registry_test.go"}
-
-	violations := CheckDiff(changed)
-
-	if len(violations) != 0 {
-		t.Fatalf("erwartet keinen Verstoß, bekommen %+v", violations)
-	}
-}
-
-func TestCheckDiff_IgnoresUnrelatedPackages(t *testing.T) {
-	changed := []string{"internal/config/config.go", "internal/db/db.go"}
-
-	violations := CheckDiff(changed)
-
-	if len(violations) != 0 {
-		t.Fatalf("erwartet keinen Verstoß fuer unkritische Pakete, bekommen %+v", violations)
-	}
-}
-
-func TestCheckDiff_CoversAllSensitiveAreas(t *testing.T) {
-	cases := []string{
-		"internal/auth/session.go",
-		"internal/iam/user.go",
-		"internal/tenant/provisioner.go",
-		"internal/rbac/enforcer.go",
-		"internal/policy/decision.go",
-	}
-	for _, f := range cases {
-		violations := CheckDiff([]string{f})
-		if len(violations) != 1 {
-			t.Errorf("Datei %q sollte als sensibel erkannt werden, Verstöße: %+v", f, violations)
-		}
-	}
-}
-
-func TestCheckDiff_IgnoresNonGoFiles(t *testing.T) {
-	changed := []string{"internal/auth/README.md"}
-
-	violations := CheckDiff(changed)
-
-	if len(violations) != 0 {
-		t.Fatalf("Nicht-Go-Dateien duerfen keine Testpflicht ausloesen, bekommen %+v", violations)
-	}
-}
@@ -0,0 +1,94 @@
+package tenant
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
+// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
+// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
+// TEN-01 und werden dort nachgezogen.
+type Handler struct {
+	provisioner *Provisioner
+}
+
+func NewHandler(p *Provisioner) *Handler {
+	return &Handler{provisioner: p}
+}
+
+type createTenantRequest struct {
+	Slug string `json:"slug"`
+	Name string `json:"name"`
+}
+
+func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
+	var req createTenantRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
+	if err != nil {
+		if err == ErrInvalidSlug {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(t)
+}
+
+// OnboardingHandler stellt den Self-Service-Endpunkt aus TEN-02 bereit —
+// eigener Handler statt Erweiterung von Handler.CreateTenant, damit die
+// TEN-01-Schnittstelle (reines Provisioning ohne Admin-Konto) unveraendert
+// bleibt.
+type OnboardingHandler struct {
+	service *OnboardingService
+}
+
+func NewOnboardingHandler(s *OnboardingService) *OnboardingHandler {
+	return &OnboardingHandler{service: s}
+}
+
+type onboardRequest struct {
+	Slug       string `json:"slug"`
+	Name       string `json:"name"`
+	AdminEmail string `json:"admin_email"`
+	AdminName  string `json:"admin_name"`
+}
+
+func (h *OnboardingHandler) Onboard(w http.ResponseWriter, r *http.Request) {
+	var req onboardRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	result, err := h.service.Onboard(r.Context(), req.Slug, req.Name, req.AdminEmail, req.AdminName)
+	if err != nil {
+		switch {
+		case errors.Is(err, ErrInvalidSlug),
+			errors.Is(err, ErrMissingField),
+			errors.Is(err, user.ErrInvalidEmail):
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		case errors.Is(err, ErrTenantExists):
+			http.Error(w, err.Error(), http.StatusConflict)
+		default:
+			http.Error(w, "mandant konnte nicht angelegt werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(result)
+}
@@ -0,0 +1,83 @@
+package tenant
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+var ErrMissingField = errors.New("tenant: pflichtfeld fehlt")
+
+// OnboardingService implementiert TEN-02: Self-Service-Anlage eines neuen
+// Mandanten inklusive Ersteinrichtung des Administrator-Kontos in einem
+// Vorgang. Schlaegt die Admin-Anlage fehl, wird der bereits provisionierte
+// Tenant per Deprovision wieder vollstaendig entfernt (Saga-Kompensation,
+// da CREATE DATABASE keine echte cross-database Transaktion erlaubt).
+type OnboardingService struct {
+	provisioner   *Provisioner
+	// tenantSchemaPath zeigt auf migrations/tenant/0001_users.up.sql, mit der
+	// die frisch angelegte Tenant-Datenbank initialisiert wird, bevor der
+	// erste Administrator angelegt werden kann.
+	tenantSchemaPath string
+}
+
+func NewOnboardingService(provisioner *Provisioner, tenantSchemaPath string) *OnboardingService {
+	return &OnboardingService{provisioner: provisioner, tenantSchemaPath: tenantSchemaPath}
+}
+
+type OnboardResult struct {
+	Tenant Tenant
+	Admin  user.User
+}
+
+func (s *OnboardingService) Onboard(ctx context.Context, slug, tenantName, adminEmail, adminName string) (OnboardResult, error) {
+	if tenantName == "" {
+		return OnboardResult{}, fmt.Errorf("%w: name", ErrMissingField)
+	}
+	if adminName == "" {
+		return OnboardResult{}, fmt.Errorf("%w: admin-name", ErrMissingField)
+	}
+	if err := ValidateSlug(slug); err != nil {
+		return OnboardResult{}, err
+	}
+	if err := user.ValidateEmail(adminEmail); err != nil {
+		return OnboardResult{}, err
+	}
+
+	t, err := s.provisioner.Provision(ctx, slug, tenantName)
+	if err != nil {
+		return OnboardResult{}, err
+	}
+
+	admin, err := s.setupAdmin(ctx, t, adminEmail, adminName)
+	if err != nil {
+		_ = s.provisioner.Deprovision(ctx, t)
+		return OnboardResult{}, err
+	}
+
+	return OnboardResult{Tenant: t, Admin: admin}, nil
+}
+
+func (s *OnboardingService) setupAdmin(ctx context.Context, t Tenant, adminEmail, adminName string) (user.User, error) {
+	pool, err := pgxpool.New(ctx, t.DBDSN)
+	if err != nil {
+		return user.User{}, fmt.Errorf("verbindung zur neuen tenant-datenbank: %w", err)
+	}
+	defer pool.Close()
+
+	schema, err := os.ReadFile(s.tenantSchemaPath)
+	if err != nil {
+		return user.User{}, fmt.Errorf("tenant-schema lesen: %w", err)
+	}
+	if _, err := pool.Exec(ctx, string(schema)); err != nil {
+		return user.User{}, fmt.Errorf("tenant-schema anwenden: %w", err)
+	}
+
+	store := user.NewTenantUserStore(pool)
+	return store.Create(ctx, adminEmail, adminName)
+}
@@ -0,0 +1,169 @@
+package tenant
+
+import (
+	"context"
+	"errors"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"gitea.perlbach24.de/scripte/nexarch/internal/user"
+)
+
+// schemaPathForTest liefert den Pfad zur echten Migration, damit Tests exakt
+// dasselbe Schema anwenden wie die Produktion (keine Zweitkopie des SQL).
+const schemaPathForTest = "../../migrations/tenant/0001_users.up.sql"
+
+func TestOnboarding_ValidationErrors(t *testing.T) {
+	// Reine Eingabevalidierung, braucht keine Datenbank.
+	svc := NewOnboardingService(nil, schemaPathForTest)
+	ctx := context.Background()
+
+	cases := []struct {
+		name       string
+		slug       string
+		tenantName string
+		email      string
+		adminName  string
+		wantErr    error
+	}{
+		{"leerer name", "acme", "", "a@b.de", "Admin", ErrMissingField},
+		{"leerer admin-name", "acme", "Acme", "a@b.de", "", ErrMissingField},
+		{"ungueltiger slug", "Acme!", "Acme", "a@b.de", "Admin", ErrInvalidSlug},
+		{"ungueltige email", "acme", "Acme", "keine-email", "Admin", user.ErrInvalidEmail},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, err := svc.Onboard(ctx, c.slug, c.tenantName, c.email, c.adminName)
+			if !errors.Is(err, c.wantErr) {
+				t.Fatalf("erwartet %v, habe %v", c.wantErr, err)
+			}
+		})
+	}
+}
+
+func newTestOnboardingService(t *testing.T) (*OnboardingService, func()) {
+	t.Helper()
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	registryPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("registry-schema: %v", err)
+	}
+
+	registry := NewRegistry(registryPool)
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
+	svc := NewOnboardingService(provisioner, schemaPathForTest)
+
+	cleanup := func() {
+		registryPool.Close()
+		adminPool.Close()
+	}
+	return svc, cleanup
+}
+
+// Akzeptanzkriterien 1+2: Mandant + Erst-Admin in einem Vorgang.
+func TestOnboarding_CreatesTenantAndAdmin(t *testing.T) {
+	svc, cleanup := newTestOnboardingService(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	t.Cleanup(func() {
+		adminDSN := os.Getenv("TEST_ADMIN_DSN")
+		p, _ := pgxpool.New(ctx, adminDSN)
+		defer p.Close()
+		_, _ = p.Exec(ctx, `DELETE FROM tenants WHERE slug = 'onboardtest'`)
+		_, _ = p.Exec(ctx, `DROP DATABASE IF EXISTS tenant_onboardtest`)
+	})
+
+	result, err := svc.Onboard(ctx, "onboardtest", "Onboard Test GmbH", "admin@onboardtest.example", "Erste Admin")
+	if err != nil {
+		t.Fatalf("onboard: %v", err)
+	}
+	if result.Tenant.Slug != "onboardtest" {
+		t.Fatalf("tenant slug = %q", result.Tenant.Slug)
+	}
+	if result.Admin.Email != "admin@onboardtest.example" {
+		t.Fatalf("admin email = %q", result.Admin.Email)
+	}
+
+	pool, err := pgxpool.New(ctx, result.Tenant.DBDSN)
+	if err != nil {
+		t.Fatalf("connect tenant db: %v", err)
+	}
+	defer pool.Close()
+
+	var count int
+	if err := pool.QueryRow(ctx, `SELECT count(*) FROM users WHERE email = $1`, "admin@onboardtest.example").Scan(&count); err != nil {
+		t.Fatalf("admin in tenant-db pruefen: %v", err)
+	}
+	if count != 1 {
+		t.Fatalf("erwartet genau einen admin in der tenant-db, habe %d", count)
+	}
+}
+
+// Akzeptanzkriterium 3 + Pruefung 1: doppelte Registrierung wird abgewiesen,
+// auch bei zwei parallelen Anfragen entsteht kein Doppel-Tenant.
+func TestOnboarding_RejectsDuplicateSlugConcurrently(t *testing.T) {
+	svc, cleanup := newTestOnboardingService(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	t.Cleanup(func() {
+		adminDSN := os.Getenv("TEST_ADMIN_DSN")
+		p, _ := pgxpool.New(ctx, adminDSN)
+		defer p.Close()
+		_, _ = p.Exec(ctx, `DELETE FROM tenants WHERE slug = 'dupetest'`)
+		_, _ = p.Exec(ctx, `DROP DATABASE IF EXISTS tenant_dupetest`)
+	})
+
+	var wg sync.WaitGroup
+	results := make([]error, 2)
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			_, err := svc.Onboard(ctx, "dupetest", "Dupe Test", "admin@dupetest.example", "Admin")
+			results[i] = err
+		}(i)
+	}
+	wg.Wait()
+
+	successCount := 0
+	for _, err := range results {
+		if err == nil {
+			successCount++
+		} else if !errors.Is(err, ErrTenantExists) {
+			t.Fatalf("unerwarteter fehler: %v", err)
+		}
+	}
+	if successCount != 1 {
+		t.Fatalf("erwartet genau einen erfolgreichen onboarding-vorgang, habe %d", successCount)
+	}
+}
@@ -0,0 +1,109 @@
+package tenant
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// ErrTenantExists wird zurueckgegeben, wenn Slug oder Datenbankname eines
+// Mandanten bereits vergeben sind (TEN-02 Akzeptanzkriterium 3).
+var ErrTenantExists = errors.New("tenant: slug bereits vergeben")
+
+// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
+// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
+// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
+// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
+type Provisioner struct {
+	// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
+	// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
+	// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
+	adminPool *pgxpool.Pool
+	registry  *Registry
+	// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
+	// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
+	dsnTemplate string
+}
+
+func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
+	return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
+}
+
+// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
+// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
+// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
+func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
+	if err := ValidateSlug(slug); err != nil {
+		return Tenant{}, err
+	}
+
+	dbName := dbNameForSlug(slug)
+
+	// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
+	// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
+	if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		var pgErr *pgconn.PgError
+		// 42P04 (duplicate_database) im Normalfall; bei zwei echt parallelen
+		// CREATE DATABASE auf denselben Namen liefert Postgres stattdessen den
+		// internen Unique-Index-Konflikt 23505 auf pg_database — beide Faelle
+		// bedeuten: der Tenant existiert bereits bzw. wird gerade angelegt.
+		if errors.As(err, &pgErr) && (pgErr.Code == "42P04" || pgErr.Code == "23505") {
+			return Tenant{}, ErrTenantExists
+		}
+		return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
+	}
+
+	t := Tenant{
+		Slug:   slug,
+		Name:   name,
+		DBName: dbName,
+		DBDSN:  fmt.Sprintf(p.dsnTemplate, dbName),
+		Status: StatusActive,
+	}
+
+	tx, err := p.registry.pool.Begin(ctx)
+	if err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
+	}
+
+	created, err := p.registry.insertTx(ctx, tx, t)
+	if err != nil {
+		_ = tx.Rollback(ctx)
+		p.rollbackDatabase(ctx, dbName)
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) && pgErr.Code == "23505" { // unique_violation auf slug
+			return Tenant{}, ErrTenantExists
+		}
+		return Tenant{}, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		p.rollbackDatabase(ctx, dbName)
+		return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
+	}
+
+	return created, nil
+}
+
+// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
+// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
+func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
+	_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+}
+
+// Deprovision entfernt einen bereits erfolgreich registrierten Tenant wieder
+// vollstaendig (Registry-Eintrag + Datenbank). Wird als Kompensation
+// verwendet, wenn ein Schritt NACH Provision fehlschlaegt (z.B. die
+// Admin-Account-Anlage in TEN-02) — Provision selbst bleibt dadurch die
+// einzige Stelle, die "erfolgreich provisioniert" garantieren muss.
+func (p *Provisioner) Deprovision(ctx context.Context, t Tenant) error {
+	if err := p.registry.Delete(ctx, t.ID); err != nil {
+		return err
+	}
+	p.rollbackDatabase(ctx, t.DBName)
+	return nil
+}
@@ -0,0 +1,105 @@
+package tenant
+
+import (
+	"context"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
+// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
+// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
+//
+// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
+//
+//	postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
+func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+	defer adminPool.Close()
+
+	registryPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("registry pool: %v", err)
+	}
+	defer registryPool.Close()
+
+	if _, err := registryPool.Exec(ctx, `
+		CREATE TABLE IF NOT EXISTS tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		)`); err != nil {
+		t.Fatalf("registry-schema: %v", err)
+	}
+
+	dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
+	registry := NewRegistry(registryPool)
+	provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
+
+	t.Cleanup(func() {
+		_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
+		_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
+	})
+
+	tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
+	if err != nil {
+		t.Fatalf("provision acme: %v", err)
+	}
+	tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
+	if err != nil {
+		t.Fatalf("provision globex: %v", err)
+	}
+
+	if tenantA.DBName == tenantB.DBName {
+		t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
+	}
+
+	// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
+	// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
+	// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
+	poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
+	if err != nil {
+		t.Fatalf("connect tenant a: %v", err)
+	}
+	defer poolA.Close()
+
+	var globexVisible bool
+	err = poolA.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
+		)
+	`, tenantB.DBName).Scan(&globexVisible)
+	if err != nil {
+		t.Fatalf("pruefung tenant-trennung: %v", err)
+	}
+	// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
+	// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
+	// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
+	var currentDB string
+	if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(&currentDB); err != nil {
+		t.Fatalf("current_database: %v", err)
+	}
+	if currentDB != tenantA.DBName {
+		t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
+	}
+	if currentDB == tenantB.DBName {
+		t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
+	}
+}
@@ -0,0 +1,79 @@
+package tenant
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
+// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
+// niemals Geschaeftsdaten eines Mandanten.
+type Registry struct {
+	pool *pgxpool.Pool
+}
+
+func NewRegistry(pool *pgxpool.Pool) *Registry {
+	return &Registry{pool: pool}
+}
+
+// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
+// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
+func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
+	row := tx.QueryRow(ctx, `
+		INSERT INTO tenants (slug, name, db_name, db_dsn, status)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, created_at
+	`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
+
+	if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
+	}
+	return t, nil
+}
+
+func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
+	var t Tenant
+	row := r.pool.QueryRow(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants WHERE slug = $1
+	`, slug)
+
+	if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+		return Tenant{}, fmt.Errorf("tenant laden: %w", err)
+	}
+	return t, nil
+}
+
+// Delete entfernt einen Registry-Eintrag. Wird von Provisioner.Deprovision
+// als Kompensation verwendet, wenn nach erfolgreicher Registrierung ein
+// nachgelagerter Schritt (z.B. Admin-Account-Anlage in TEN-02) fehlschlaegt.
+func (r *Registry) Delete(ctx context.Context, id string) error {
+	if _, err := r.pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, id); err != nil {
+		return fmt.Errorf("tenant loeschen: %w", err)
+	}
+	return nil
+}
+
+func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
+	rows, err := r.pool.Query(ctx, `
+		SELECT id, slug, name, db_name, db_dsn, status, created_at
+		FROM tenants ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("tenants auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Tenant
+	for rows.Next() {
+		var t Tenant
+		if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
+			return nil, fmt.Errorf("tenant lesen: %w", err)
+		}
+		out = append(out, t)
+	}
+	return out, rows.Err()
+}
@@ -0,0 +1,42 @@
+// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
+// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
+package tenant
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive Status = "active"
+)
+
+type Tenant struct {
+	ID        string
+	Slug      string
+	Name      string
+	DBName    string
+	DBDSN     string
+	Status    Status
+	CreatedAt time.Time
+}
+
+// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
+// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
+var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
+
+var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
+
+func ValidateSlug(slug string) error {
+	if !slugPattern.MatchString(slug) {
+		return ErrInvalidSlug
+	}
+	return nil
+}
+
+func dbNameForSlug(slug string) string {
+	return "tenant_" + slug
+}
@@ -0,0 +1,35 @@
+package tenant
+
+import "testing"
+
+func TestValidateSlug(t *testing.T) {
+	cases := []struct {
+		slug    string
+		wantErr bool
+	}{
+		{"acme", false},
+		{"acme_gmbh", false},
+		{"a1", false},
+		{"", true},
+		{"a", true},
+		{"1acme", true},
+		{"Acme", true},
+		{"acme-gmbh", true},
+		{"acme;drop table tenants", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateSlug(c.slug)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
+		}
+	}
+}
+
+func TestDBNameForSlug(t *testing.T) {
+	got := dbNameForSlug("acme")
+	want := "tenant_acme"
+	if got != want {
+		t.Errorf("dbNameForSlug() = %q, want %q", got, want)
+	}
+}
@@ -0,0 +1,74 @@
+package tenantsettings
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// Handler stellt Lesen/Schreiben der Tenant-Einstellungen als schlanke
+// Vorbereitung der Schnittstelle bereit (API-01/TEN-05 sind nicht Teil
+// dieser Kachel). tenantID wird hier als Pfad-/Query-Parameter erwartet,
+// eine echte Auth-/Berechtigungspruefung kommt erst mit IAM-02/RBAC-01.
+type Handler struct {
+	store *Store
+}
+
+func NewHandler(store *Store) *Handler {
+	return &Handler{store: store}
+}
+
+func (h *Handler) Get(w http.ResponseWriter, r *http.Request) {
+	tenantID := r.URL.Query().Get("tenant_id")
+	if tenantID == "" {
+		http.Error(w, "tenant_id fehlt", http.StatusBadRequest)
+		return
+	}
+
+	settings, err := h.store.Get(r.Context(), tenantID)
+	if err != nil {
+		http.Error(w, "einstellungen konnten nicht geladen werden", http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, http.StatusOK, settings)
+}
+
+type updateRequest struct {
+	DisplayName *string `json:"display_name"`
+	LogoURL     *string `json:"logo_url"`
+	ColorScheme *string `json:"color_scheme"`
+	Timezone    *string `json:"timezone"`
+	Language    *string `json:"language"`
+}
+
+func (h *Handler) Update(w http.ResponseWriter, r *http.Request) {
+	tenantID := r.URL.Query().Get("tenant_id")
+	if tenantID == "" {
+		http.Error(w, "tenant_id fehlt", http.StatusBadRequest)
+		return
+	}
+
+	var req updateRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	settings, err := h.store.Update(r.Context(), tenantID, Patch{
+		DisplayName: req.DisplayName,
+		LogoURL:     req.LogoURL,
+		ColorScheme: req.ColorScheme,
+		Timezone:    req.Timezone,
+		Language:    req.Language,
+	})
+	if err != nil {
+		http.Error(w, "einstellungen konnten nicht gespeichert werden", http.StatusInternalServerError)
+		return
+	}
+	writeJSON(w, http.StatusOK, settings)
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
@@ -0,0 +1,156 @@
+package tenantsettings
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+func setupTest(t *testing.T) (*Store, string, string, 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 tenants (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+			slug TEXT NOT NULL UNIQUE,
+			name TEXT NOT NULL,
+			db_name TEXT NOT NULL UNIQUE,
+			db_dsn TEXT NOT NULL,
+			status TEXT NOT NULL DEFAULT 'active',
+			created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS tenant_settings (
+			tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
+			display_name TEXT, logo_url TEXT, color_scheme TEXT, timezone TEXT, language TEXT,
+			version INT NOT NULL DEFAULT 0, updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+		CREATE TABLE IF NOT EXISTS tenant_settings_history (
+			id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_id UUID NOT NULL,
+			display_name TEXT, logo_url TEXT, color_scheme TEXT, timezone TEXT, language TEXT,
+			version INT NOT NULL, changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+		);
+	`); err != nil {
+		t.Fatalf("schema: %v", err)
+	}
+
+	var tenantA, tenantB string
+	if err := pool.QueryRow(ctx, `INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ('ts_a', 'A', 'tenant_ts_a', 'unused') RETURNING id`).Scan(&tenantA); err != nil {
+		t.Fatalf("tenant a anlegen: %v", err)
+	}
+	if err := pool.QueryRow(ctx, `INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ('ts_b', 'B', 'tenant_ts_b', 'unused') RETURNING id`).Scan(&tenantB); err != nil {
+		t.Fatalf("tenant b anlegen: %v", err)
+	}
+
+	cleanup := func() {
+		_, _ = pool.Exec(ctx, `DELETE FROM tenant_settings_history WHERE tenant_id IN ($1, $2)`, tenantA, tenantB)
+		_, _ = pool.Exec(ctx, `DELETE FROM tenant_settings WHERE tenant_id IN ($1, $2)`, tenantA, tenantB)
+		_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id IN ($1, $2)`, tenantA, tenantB)
+		pool.Close()
+	}
+	return NewStore(pool), tenantA, tenantB, cleanup
+}
+
+func strp(s string) *string { return &s }
+
+// Akzeptanzkriterium 2 + Pruefung 2: fehlende Werte liefern Defaults, kein Fehler.
+func TestGet_UnsetTenantReturnsDefaults(t *testing.T) {
+	store, tenantA, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	got, err := store.Get(ctx, tenantA)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	want := Defaults()
+	if got != want {
+		t.Fatalf("erwartet defaults %+v, habe %+v", want, got)
+	}
+}
+
+// Akzeptanzkriterium 1 + 2: Teil-Update laesst nicht gesetzte Felder auf Default.
+func TestUpdate_PartialPatchKeepsOtherFieldsAtDefault(t *testing.T) {
+	store, tenantA, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	got, err := store.Update(ctx, tenantA, Patch{DisplayName: strp("Acme GmbH")})
+	if err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if got.DisplayName != "Acme GmbH" {
+		t.Fatalf("erwartet 'Acme GmbH', habe %q", got.DisplayName)
+	}
+	d := Defaults()
+	if got.ColorScheme != d.ColorScheme || got.Timezone != d.Timezone || got.Language != d.Language {
+		t.Fatalf("nicht gesetzte felder haetten auf default bleiben sollen, habe %+v", got)
+	}
+	if got.Version != 1 {
+		t.Fatalf("erwartet version 1, habe %d", got.Version)
+	}
+}
+
+// Akzeptanzkriterium 1 + Pruefung 1: Aenderung eines Tenants wirkt sich
+// nicht auf einen anderen aus.
+func TestUpdate_IsolatedBetweenTenants(t *testing.T) {
+	store, tenantA, tenantB, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Update(ctx, tenantA, Patch{DisplayName: strp("Tenant A")}); err != nil {
+		t.Fatalf("update a: %v", err)
+	}
+
+	gotB, err := store.Get(ctx, tenantB)
+	if err != nil {
+		t.Fatalf("get b: %v", err)
+	}
+	if gotB != Defaults() {
+		t.Fatalf("tenant b sollte unberuehrt bei defaults bleiben, habe %+v", gotB)
+	}
+}
+
+// Akzeptanzkriterium 3: Aenderungen versioniert nachvollziehbar.
+func TestUpdate_HistoryTracksVersions(t *testing.T) {
+	store, tenantA, _, cleanup := setupTest(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	if _, err := store.Update(ctx, tenantA, Patch{DisplayName: strp("v1")}); err != nil {
+		t.Fatalf("update 1: %v", err)
+	}
+	if _, err := store.Update(ctx, tenantA, Patch{DisplayName: strp("v2")}); err != nil {
+		t.Fatalf("update 2: %v", err)
+	}
+	if _, err := store.Update(ctx, tenantA, Patch{ColorScheme: strp("dark")}); err != nil {
+		t.Fatalf("update 3: %v", err)
+	}
+
+	history, err := store.History(ctx, tenantA)
+	if err != nil {
+		t.Fatalf("history: %v", err)
+	}
+	if len(history) != 3 {
+		t.Fatalf("erwartet 3 historieneintraege, habe %d", len(history))
+	}
+	if history[0].DisplayName != "v1" || history[0].Version != 1 {
+		t.Fatalf("history[0] unerwartet: %+v", history[0])
+	}
+	if history[1].DisplayName != "v2" || history[1].Version != 2 {
+		t.Fatalf("history[1] unerwartet: %+v", history[1])
+	}
+	if history[2].ColorScheme != "dark" || history[2].DisplayName != "v2" || history[2].Version != 3 {
+		t.Fatalf("history[2] unerwartet (display_name haette aus vorherigem update erhalten bleiben sollen): %+v", history[2])
+	}
+}
@@ -0,0 +1,187 @@
+// Package tenantsettings implementiert Core TEN-03: pro-Tenant-Einstellungen
+// (Anzeigename, Logo, Farbschema, Zeitzone, Sprache) mit versionierter
+// Aenderungshistorie und dokumentierten Systemvoreinstellungen.
+package tenantsettings
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Settings ist der vollstaendig AUFGELOESTE Stand (jede leere Einstellung ist
+// bereits durch ihren Default ersetzt) — Aufrufer muessen sich nie selbst um
+// Systemvoreinstellungen kuemmern (Akzeptanzkriterium 2).
+type Settings struct {
+	DisplayName string
+	LogoURL     string
+	ColorScheme string
+	Timezone    string
+	Language    string
+	Version     int
+}
+
+// Defaults liefert die dokumentierten Systemvoreinstellungen.
+func Defaults() Settings {
+	return Settings{
+		DisplayName: "",
+		LogoURL:     "",
+		ColorScheme: "system",
+		Timezone:    "UTC",
+		Language:    "de",
+		Version:     0,
+	}
+}
+
+// Patch enthaelt nur die Felder, die tatsaechlich geaendert werden sollen —
+// nil bedeutet "unveraendert lassen", nicht "auf Default zuruecksetzen".
+type Patch struct {
+	DisplayName *string
+	LogoURL     *string
+	ColorScheme *string
+	Timezone    *string
+	Language    *string
+}
+
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+// Get liefert die aufgeloesten Einstellungen eines Tenants. Existiert noch
+// kein Datensatz oder sind einzelne Spalten NULL, werden die jeweiligen
+// Systemvoreinstellungen eingesetzt (Akzeptanzkriterium 2 / Pruefung 2) —
+// niemals ein Fehler wegen fehlender Werte.
+func (s *Store) Get(ctx context.Context, tenantID string) (Settings, error) {
+	var displayName, logoURL, colorScheme, timezone, language *string
+	var version int
+
+	row := s.pool.QueryRow(ctx, `
+		SELECT display_name, logo_url, color_scheme, timezone, language, version
+		FROM tenant_settings WHERE tenant_id = $1
+	`, tenantID)
+	err := row.Scan(&displayName, &logoURL, &colorScheme, &timezone, &language, &version)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Defaults(), nil
+	}
+	if err != nil {
+		return Settings{}, fmt.Errorf("einstellungen lesen: %w", err)
+	}
+
+	d := Defaults()
+	return Settings{
+		DisplayName: orDefault(displayName, d.DisplayName),
+		LogoURL:     orDefault(logoURL, d.LogoURL),
+		ColorScheme: orDefault(colorScheme, d.ColorScheme),
+		Timezone:    orDefault(timezone, d.Timezone),
+		Language:    orDefault(language, d.Language),
+		Version:     version,
+	}, nil
+}
+
+func orDefault(v *string, def string) string {
+	if v == nil {
+		return def
+	}
+	return *v
+}
+
+// Update wendet patch auf den aktuellen Stand an, erhoeht die Version und
+// schreibt Stand + Historieneintrag atomar (Akzeptanzkriterium 3). Nicht in
+// patch gesetzte Felder bleiben unveraendert (bzw. weiterhin auf Default,
+// wenn sie es vorher schon waren).
+func (s *Store) Update(ctx context.Context, tenantID string, patch Patch) (Settings, error) {
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return Settings{}, fmt.Errorf("transaktion starten: %w", err)
+	}
+	defer func() { _ = tx.Rollback(ctx) }()
+
+	var rawDisplayName, rawLogoURL, rawColorScheme, rawTimezone, rawLanguage *string
+	var version int
+	row := tx.QueryRow(ctx, `
+		SELECT display_name, logo_url, color_scheme, timezone, language, version
+		FROM tenant_settings WHERE tenant_id = $1 FOR UPDATE
+	`, tenantID)
+	err = row.Scan(&rawDisplayName, &rawLogoURL, &rawColorScheme, &rawTimezone, &rawLanguage, &version)
+	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
+		return Settings{}, fmt.Errorf("aktuellen stand lesen: %w", err)
+	}
+
+	if patch.DisplayName != nil {
+		rawDisplayName = patch.DisplayName
+	}
+	if patch.LogoURL != nil {
+		rawLogoURL = patch.LogoURL
+	}
+	if patch.ColorScheme != nil {
+		rawColorScheme = patch.ColorScheme
+	}
+	if patch.Timezone != nil {
+		rawTimezone = patch.Timezone
+	}
+	if patch.Language != nil {
+		rawLanguage = patch.Language
+	}
+	newVersion := version + 1
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO tenant_settings (tenant_id, display_name, logo_url, color_scheme, timezone, language, version, updated_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, now())
+		ON CONFLICT (tenant_id) DO UPDATE SET
+			display_name = $2, logo_url = $3, color_scheme = $4, timezone = $5, language = $6, version = $7, updated_at = now()
+	`, tenantID, rawDisplayName, rawLogoURL, rawColorScheme, rawTimezone, rawLanguage, newVersion); err != nil {
+		return Settings{}, fmt.Errorf("einstellungen speichern: %w", err)
+	}
+
+	if _, err := tx.Exec(ctx, `
+		INSERT INTO tenant_settings_history (tenant_id, display_name, logo_url, color_scheme, timezone, language, version, changed_at)
+		VALUES ($1, $2, $3, $4, $5, $6, $7, now())
+	`, tenantID, rawDisplayName, rawLogoURL, rawColorScheme, rawTimezone, rawLanguage, newVersion); err != nil {
+		return Settings{}, fmt.Errorf("historie schreiben: %w", err)
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return Settings{}, fmt.Errorf("transaktion committen: %w", err)
+	}
+
+	return s.Get(ctx, tenantID)
+}
+
+// History liefert die vollstaendige Versionshistorie eines Tenants
+// (Akzeptanzkriterium 3 / Pruefung 3-Vorbereitung).
+func (s *Store) History(ctx context.Context, tenantID string) ([]Settings, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT display_name, logo_url, color_scheme, timezone, language, version
+		FROM tenant_settings_history WHERE tenant_id = $1 ORDER BY version
+	`, tenantID)
+	if err != nil {
+		return nil, fmt.Errorf("historie abfragen: %w", err)
+	}
+	defer rows.Close()
+
+	d := Defaults()
+	var out []Settings
+	for rows.Next() {
+		var displayName, logoURL, colorScheme, timezone, language *string
+		var version int
+		if err := rows.Scan(&displayName, &logoURL, &colorScheme, &timezone, &language, &version); err != nil {
+			return nil, fmt.Errorf("historieneintrag lesen: %w", err)
+		}
+		out = append(out, Settings{
+			DisplayName: orDefault(displayName, d.DisplayName),
+			LogoURL:     orDefault(logoURL, d.LogoURL),
+			ColorScheme: orDefault(colorScheme, d.ColorScheme),
+			Timezone:    orDefault(timezone, d.Timezone),
+			Language:    orDefault(language, d.Language),
+			Version:     version,
+		})
+	}
+	return out, rows.Err()
+}
@@ -1,76 +0,0 @@
-// Package testdbisolation demonstriert und prüft die in docs/TESTSTRATEGIE-CORE.md Abschnitt 4
-// beschriebene Testdatenbank-Isolation: jeder Test, der eine Tenant-Datenbank braucht,
-// provisioniert seine eigene, eindeutig benannte DB und räumt sie über Cleanup wieder ab —
-// keine geteilten Fixture-Datenbanken zwischen parallelen Testläufen.
-package testdbisolation
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgxpool"
-)
-
-// ProvisionEphemeralDB legt unter dem gegebenen Admin-DSN eine neue, eindeutig benannte Datenbank an
-// und liefert eine Cleanup-Funktion, die sie wieder droppt. adminDSN muss auf eine Wartungs-DB
-// (z. B. "postgres") zeigen, name muss ein gültiger, bereits eindeutiger Bezeichner sein.
-func ProvisionEphemeralDB(ctx context.Context, adminDSN, name string) (cleanup func(context.Context) error, err error) {
-	conn, err := pgx.Connect(ctx, adminDSN)
-	if err != nil {
-		return nil, fmt.Errorf("verbindung zur wartungs-db fehlgeschlagen: %w", err)
-	}
-	defer conn.Close(ctx)
-
-	if _, err := conn.Exec(ctx, fmt.Sprintf("CREATE DATABASE %s", pgx.Identifier{name}.Sanitize())); err != nil {
-		return nil, fmt.Errorf("datenbank %q konnte nicht angelegt werden: %w", name, err)
-	}
-
-	cleanup = func(cleanupCtx context.Context) error {
-		adminConn, err := pgx.Connect(cleanupCtx, adminDSN)
-		if err != nil {
-			return fmt.Errorf("cleanup: verbindung fehlgeschlagen: %w", err)
-		}
-		defer adminConn.Close(cleanupCtx)
-		_, err = adminConn.Exec(cleanupCtx, fmt.Sprintf("DROP DATABASE IF EXISTS %s", pgx.Identifier{name}.Sanitize()))
-		return err
-	}
-	return cleanup, nil
-}
-
-// WriteMarker schreibt einen eindeutigen Beleg-Datensatz in die angegebene Datenbank (verbindet
-// per dsnForDB), um im Test nachzuweisen, dass zwei parallele Provisionierungen sich nicht sehen.
-func WriteMarker(ctx context.Context, dsn, table, value string) error {
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		return err
-	}
-	defer pool.Close()
-
-	if _, err := pool.Exec(ctx, fmt.Sprintf(
-		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
-	)); err != nil {
-		return err
-	}
-	_, err = pool.Exec(ctx, fmt.Sprintf("INSERT INTO %s (value) VALUES ($1)", pgx.Identifier{table}.Sanitize()), value)
-	return err
-}
-
-// CountMarkers zählt die Belegzeilen in der angegebenen Datenbank/Tabelle.
-func CountMarkers(ctx context.Context, dsn, table string) (int, error) {
-	pool, err := pgxpool.New(ctx, dsn)
-	if err != nil {
-		return 0, err
-	}
-	defer pool.Close()
-
-	if _, err := pool.Exec(ctx, fmt.Sprintf(
-		"CREATE TABLE IF NOT EXISTS %s (value text primary key)", pgx.Identifier{table}.Sanitize(),
-	)); err != nil {
-		return 0, err
-	}
-
-	var n int
-	err = pool.QueryRow(ctx, fmt.Sprintf("SELECT count(*) FROM %s", pgx.Identifier{table}.Sanitize())).Scan(&n)
-	return n, err
-}
@@ -1,99 +0,0 @@
-package testdbisolation
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-// TestParallelProvisioning_AreIsolated ist der automatisierte Nachweis für QA-01 Prüfung 2:
-// Testdatenbank-Isolation zwischen parallelen Testläufen. Zwei Provisionierungen laufen
-// gleichzeitig, jede schreibt einen Beleg-Datensatz in ihre eigene DB — keine darf den
-// Beleg der jeweils anderen sehen.
-//
-// Braucht TEST_ADMIN_DSN (siehe Projekt-Testinfrastruktur), läuft auf dem Testhost, nicht lokal
-// auf der Entwicklungsmaschine (siehe "no installs"-Regel) — wird ohne gesetzte Variable übersprungen.
-func TestParallelProvisioning_AreIsolated(t *testing.T) {
-	adminDSN := os.Getenv("TEST_ADMIN_DSN")
-	if adminDSN == "" {
-		t.Skip("TEST_ADMIN_DSN nicht gesetzt — Test läuft nur auf dem Testhost, siehe docs/TESTSTRATEGIE-CORE.md")
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	const numParallel = 2
-	dbNames := make([]string, numParallel)
-	for i := range dbNames {
-		dbNames[i] = fmt.Sprintf("qa01_isolation_%d_%d", time.Now().UnixNano(), i)
-	}
-
-	var wg sync.WaitGroup
-	errs := make([]error, numParallel)
-	cleanups := make([]func(context.Context) error, numParallel)
-
-	for i, name := range dbNames {
-		wg.Add(1)
-		go func(idx int, dbName string) {
-			defer wg.Done()
-
-			cleanup, err := ProvisionEphemeralDB(ctx, adminDSN, dbName)
-			if err != nil {
-				errs[idx] = fmt.Errorf("provisionierung %d fehlgeschlagen: %w", idx, err)
-				return
-			}
-			cleanups[idx] = cleanup
-
-			dbDSN := dsnForDB(adminDSN, dbName)
-			// Jede Goroutine schreibt einen für sie eindeutigen Beleg.
-			if err := WriteMarker(ctx, dbDSN, "isolation_marker", fmt.Sprintf("marker-von-goroutine-%d", idx)); err != nil {
-				errs[idx] = fmt.Errorf("markierung %d fehlgeschlagen: %w", idx, err)
-			}
-		}(i, name)
-	}
-	wg.Wait()
-
-	t.Cleanup(func() {
-		for _, cleanup := range cleanups {
-			if cleanup != nil {
-				_ = cleanup(context.Background())
-			}
-		}
-	})
-
-	for i, err := range errs {
-		if err != nil {
-			t.Fatalf("goroutine %d: %v", i, err)
-		}
-	}
-
-	// Isolationsnachweis: jede DB enthält genau ihren eigenen Beleg (1), keinen fremden.
-	for i, name := range dbNames {
-		dbDSN := dsnForDB(adminDSN, name)
-		count, err := CountMarkers(ctx, dbDSN, "isolation_marker")
-		if err != nil {
-			t.Fatalf("zaehlung in db %d fehlgeschlagen: %v", i, err)
-		}
-		if count != 1 {
-			t.Errorf("db %d (%s): erwartet genau 1 eigenen Beleg, gefunden %d — Isolation verletzt", i, name, count)
-		}
-	}
-}
-
-// dsnForDB ersetzt den Datenbanknamen im Wartungs-DSN durch den gegebenen Namen.
-func dsnForDB(adminDSN, dbName string) string {
-	idx := strings.LastIndex(adminDSN, "/")
-	if idx == -1 {
-		return adminDSN
-	}
-	base := adminDSN[:idx+1]
-	rest := adminDSN[idx+1:]
-	if q := strings.Index(rest, "?"); q != -1 {
-		return base + dbName + rest[q:]
-	}
-	return base + dbName
-}
@@ -0,0 +1,66 @@
+package user
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+)
+
+// Handler stellt die CRUD-API fuer Benutzerkonten bereit (IAM-01-Auftrag).
+// Auth/Sessions (IAM-02) und Rollen (RBAC-01) sind ausdruecklich nicht Teil
+// dieser Kachel und daher hier noch nicht angebunden.
+type Handler struct {
+	users       *TenantUserStore
+	superadmins *SuperadminStore
+}
+
+func NewHandler(users *TenantUserStore, superadmins *SuperadminStore) *Handler {
+	return &Handler{users: users, superadmins: superadmins}
+}
+
+type createUserRequest struct {
+	Email string `json:"email"`
+	Name  string `json:"name"`
+}
+
+func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.users.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+// CreateSuperadmin legt ein mandantenuebergreifendes Superadmin-Konto an —
+// bewusst ein eigener Endpunkt statt eines Tenant-Parameters mit Null-Wert.
+func (h *Handler) CreateSuperadmin(w http.ResponseWriter, r *http.Request) {
+	var req createUserRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
+		return
+	}
+
+	u, err := h.superadmins.Create(r.Context(), req.Email, req.Name)
+	writeUserResult(w, u, err)
+}
+
+func writeUserResult(w http.ResponseWriter, u User, err error) {
+	if err != nil {
+		switch {
+		case errors.Is(err, ErrInvalidEmail), errors.Is(err, ErrEmailTaken):
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		case errors.Is(err, ErrNotFound):
+			http.Error(w, err.Error(), http.StatusNotFound)
+		default:
+			http.Error(w, "benutzer konnte nicht verarbeitet werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	_ = json.NewEncoder(w).Encode(u)
+}
@@ -0,0 +1,173 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// setupTestDB legt eine frische, isolierte Testdatenbank an, wendet die
+// uebergebene Migration an und liefert einen verbundenen Pool. Wird ohne
+// TEST_ADMIN_DSN uebersprungen — siehe internal/tenant/provisioner_test.go
+// fuer dasselbe Muster.
+func setupTestDB(t *testing.T, dbName, schemaSQL string) *pgxpool.Pool {
+	t.Helper()
+
+	adminDSN := os.Getenv("TEST_ADMIN_DSN")
+	if adminDSN == "" {
+		t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
+	}
+	ctx := context.Background()
+
+	adminPool, err := pgxpool.New(ctx, adminDSN)
+	if err != nil {
+		t.Fatalf("admin pool: %v", err)
+	}
+
+	_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+	if _, err := adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
+		t.Fatalf("testdatenbank anlegen: %v", err)
+	}
+
+	dsn := strings.Replace(adminDSN, "/postgres?", "/"+dbName+"?", 1)
+	pool, err := pgxpool.New(ctx, dsn)
+	if err != nil {
+		t.Fatalf("connect testdatenbank: %v", err)
+	}
+
+	if _, err := pool.Exec(ctx, schemaSQL); err != nil {
+		t.Fatalf("schema anwenden: %v", err)
+	}
+
+	t.Cleanup(func() {
+		pool.Close()
+		_, _ = adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
+		adminPool.Close()
+	})
+
+	return pool
+}
+
+const usersSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE users (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+	email TEXT NOT NULL UNIQUE,
+	name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+const superadminsSchema = `
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+CREATE TABLE superadmins (
+	id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+	email TEXT NOT NULL UNIQUE,
+	name TEXT NOT NULL,
+	status TEXT NOT NULL DEFAULT 'active',
+	created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);`
+
+// Akzeptanzkriterium 1 + 3, Pruefung 1 (inkl. Negativfall doppelte E-Mail).
+func TestTenantUserStore_CRUD(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_users", usersSchema)
+	store := NewTenantUserStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "alice@example.com", "Alice")
+	if err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "alice@example.com" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	updated, err := store.Update(ctx, created.ID, "", "Alice A.")
+	if err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	if updated.Name != "Alice A." || updated.Email != "alice@example.com" {
+		t.Fatalf("update ergebnis unerwartet: %+v", updated)
+	}
+
+	list, err := store.List(ctx)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(list) != 1 {
+		t.Fatalf("erwartet 1 benutzer, habe %d", len(list))
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+
+	// Negativfall: doppelte E-Mail-Adresse.
+	if _, err := store.Create(ctx, "second@example.com", "Bob"); err != nil {
+		t.Fatalf("create second: %v", err)
+	}
+	if _, err := store.Create(ctx, "second@example.com", "Bob Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken, habe %v", err)
+	}
+
+	// Negativfall: fehlender Benutzer.
+	if _, err := store.Get(ctx, created.ID+"-nicht-vorhanden"); err == nil {
+		t.Fatalf("erwartet fehler bei unbekannter/ungueltiger id")
+	}
+}
+
+// Akzeptanzkriterium 2 + Pruefung 2: Superadmin-Anlage ohne Tenant-Kontext.
+// SuperadminStore.Create hat keinen Tenant-Parameter — es gibt syntaktisch
+// keine Moeglichkeit, hier versehentlich einen Tenant-Sonderfall zu vergessen.
+func TestSuperadminStore_CreateWithoutTenantContext(t *testing.T) {
+	pool := setupTestDB(t, "test_iam01_superadmins", superadminsSchema)
+	store := NewSuperadminStore(pool)
+	ctx := context.Background()
+
+	created, err := store.Create(ctx, "root@nexarch.internal", "Root")
+	if err != nil {
+		t.Fatalf("create superadmin: %v", err)
+	}
+	if created.Status != StatusActive {
+		t.Fatalf("erwartet status active, hat %q", created.Status)
+	}
+
+	got, err := store.Get(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Email != "root@nexarch.internal" {
+		t.Fatalf("get email = %q", got.Email)
+	}
+
+	if _, err := store.Create(ctx, "root@nexarch.internal", "Root Zwei"); !errors.Is(err, ErrEmailTaken) {
+		t.Fatalf("erwartet ErrEmailTaken (globale eindeutigkeit), habe %v", err)
+	}
+
+	deactivated, err := store.Deactivate(ctx, created.ID)
+	if err != nil {
+		t.Fatalf("deactivate: %v", err)
+	}
+	if deactivated.Status != StatusInactive {
+		t.Fatalf("erwartet status inactive, hat %q", deactivated.Status)
+	}
+}
@@ -0,0 +1,77 @@
+package user
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// SuperadminStore verwaltet mandantenuebergreifende Superadmin-Konten in der
+// Control-Plane-Registry (siehe internal/tenant.Registry). Superadmin-ohne-
+// Tenant ist dadurch ein eigener Typ statt eines Sonderfalls von User/
+// TenantUserStore — es gibt keinen Tenant-Parameter, den man weglassen
+// koennte (IAM-01, "ohne Sonderbehandlung im Code").
+type SuperadminStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewSuperadminStore(pool *pgxpool.Pool) *SuperadminStore {
+	return &SuperadminStore{pool: pool}
+}
+
+func (s *SuperadminStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO superadmins (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *SuperadminStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins WHERE id = $1
+	`, id))
+}
+
+func (s *SuperadminStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM superadmins ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("superadmins auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("superadmin lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+func (s *SuperadminStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE superadmins SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}
@@ -0,0 +1,128 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// TenantUserStore verwaltet Benutzer innerhalb GENAU EINER Tenant-Datenbank.
+// Welcher Mandant gemeint ist, ergibt sich ausschliesslich aus dem
+// uebergebenen Pool — es gibt keine tenant_id-Spalte (siehe migrations/tenant/0001_users.up.sql).
+type TenantUserStore struct {
+	pool *pgxpool.Pool
+}
+
+func NewTenantUserStore(pool *pgxpool.Pool) *TenantUserStore {
+	return &TenantUserStore{pool: pool}
+}
+
+func (s *TenantUserStore) Create(ctx context.Context, email, name string) (User, error) {
+	if err := ValidateEmail(email); err != nil {
+		return User{}, err
+	}
+
+	var u User
+	u.Email, u.Name, u.Status = email, name, StatusActive
+
+	row := s.pool.QueryRow(ctx, `
+		INSERT INTO users (email, name, status)
+		VALUES ($1, $2, $3)
+		RETURNING id, created_at, updated_at
+	`, u.Email, u.Name, u.Status)
+
+	if err := row.Scan(&u.ID, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+func (s *TenantUserStore) Get(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users WHERE id = $1
+	`, id))
+}
+
+func (s *TenantUserStore) List(ctx context.Context) ([]User, error) {
+	rows, err := s.pool.Query(ctx, `
+		SELECT id, email, name, status, created_at, updated_at
+		FROM users ORDER BY created_at
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("benutzer auflisten: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+			return nil, fmt.Errorf("benutzer lesen: %w", err)
+		}
+		out = append(out, u)
+	}
+	return out, rows.Err()
+}
+
+// Update aendert Name und E-Mail. Eine leere email/name laesst das jeweilige
+// Feld unveraendert.
+func (s *TenantUserStore) Update(ctx context.Context, id, email, name string) (User, error) {
+	if email != "" {
+		if err := ValidateEmail(email); err != nil {
+			return User{}, err
+		}
+	}
+
+	row := s.pool.QueryRow(ctx, `
+		UPDATE users
+		SET email = COALESCE(NULLIF($2, ''), email),
+		    name = COALESCE(NULLIF($3, ''), name),
+		    updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, email, name)
+
+	u, err := scanUser(row)
+	if err != nil {
+		return User{}, mapWriteErr(err)
+	}
+	return u, nil
+}
+
+// Deactivate setzt den Benutzer auf inaktiv statt ihn zu loeschen.
+func (s *TenantUserStore) Deactivate(ctx context.Context, id string) (User, error) {
+	return scanUser(s.pool.QueryRow(ctx, `
+		UPDATE users SET status = $2, updated_at = now()
+		WHERE id = $1
+		RETURNING id, email, name, status, created_at, updated_at
+	`, id, StatusInactive))
+}
+
+func scanUser(row pgx.Row) (User, error) {
+	var u User
+	if err := row.Scan(&u.ID, &u.Email, &u.Name, &u.Status, &u.CreatedAt, &u.UpdatedAt); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return User{}, ErrNotFound
+		}
+		return User{}, fmt.Errorf("benutzer lesen: %w", err)
+	}
+	return u, nil
+}
+
+// mapWriteErr uebersetzt den Unique-Constraint-Verstoss der E-Mail-Spalte in
+// einen sprechenden Fehler statt der rohen Postgres-Fehlermeldung.
+func mapWriteErr(err error) error {
+	var pgErr *pgconn.PgError
+	if errors.As(err, &pgErr) && pgErr.Code == "23505" {
+		return ErrEmailTaken
+	}
+	if errors.Is(err, pgx.ErrNoRows) {
+		return ErrNotFound
+	}
+	return fmt.Errorf("benutzer schreiben: %w", err)
+}
@@ -0,0 +1,42 @@
+// Package user implementiert Core IAM-01: das Benutzer-Datenmodell und die
+// CRUD-Operationen. Tenant-Zugehoerigkeit ist ueber die Zieldatenbank
+// gegeben (Modell C, siehe internal/tenant) — Superadmin-Konten leben
+// dagegen mandantenuebergreifend in der Registry und sind ueber
+// SuperadminStore als eigener, First-Class-Typ modelliert, nicht als
+// tenant_id-NULL-Sonderfall in User.
+package user
+
+import (
+	"errors"
+	"regexp"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusActive   Status = "active"
+	StatusInactive Status = "inactive"
+)
+
+type User struct {
+	ID        string
+	Email     string
+	Name      string
+	Status    Status
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+var emailPattern = regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
+
+var ErrInvalidEmail = errors.New("user: ungueltige E-Mail-Adresse")
+var ErrEmailTaken = errors.New("user: E-Mail-Adresse bereits vergeben")
+var ErrNotFound = errors.New("user: nicht gefunden")
+
+func ValidateEmail(email string) error {
+	if !emailPattern.MatchString(email) {
+		return ErrInvalidEmail
+	}
+	return nil
+}
@@ -0,0 +1,24 @@
+package user
+
+import "testing"
+
+func TestValidateEmail(t *testing.T) {
+	cases := []struct {
+		email   string
+		wantErr bool
+	}{
+		{"a@b.de", false},
+		{"a.b+c@sub.example.com", false},
+		{"", true},
+		{"keine-email", true},
+		{"a@b", true},
+		{"@b.de", true},
+	}
+
+	for _, c := range cases {
+		err := ValidateEmail(c.email)
+		if (err != nil) != c.wantErr {
+			t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", c.email, err, c.wantErr)
+		}
+	}
+}
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS tenants;
@@ -1,10 +0,0 @@
-- Control-plane registry: tenant list + connection info (Modell C).
-- Core TEN-01 (siehe core-kanban).
-CREATE TABLE tenants (
-    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    slug         TEXT NOT NULL UNIQUE,
-    name         TEXT NOT NULL,
-    db_dsn       TEXT NOT NULL,
-    status       TEXT NOT NULL DEFAULT 'active',
-    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
-);
@@ -0,0 +1,14 @@
+-- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
+-- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
+-- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE tenants (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug         TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    db_name      TEXT NOT NULL UNIQUE,
+    db_dsn       TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS superadmins;
@@ -0,0 +1,14 @@
+-- Superadmin-Konten arbeiten mandantenuebergreifend und leben deshalb in der
+-- Control-Plane-Registry (siehe TEN-01), nicht in einer Tenant-Datenbank.
+-- Das bildet "Superadmin ohne Tenant" strukturell als First-Class-Zustand ab,
+-- statt ihn als Sonderfall in der Tenant-users-Tabelle zu behandeln
+-- (IAM-01, siehe core-kanban/tickets/IAM-01.md — bekannte Fehler vermeiden).
+-- E-Mail-Eindeutigkeit ist hier global, da die Registry-DB einmalig existiert.
+CREATE TABLE superadmins (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email        TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1,2 @@
+DROP TABLE IF EXISTS tenant_settings_history;
+DROP TABLE IF EXISTS tenant_settings;
@@ -0,0 +1,27 @@
+-- Pro-Tenant-Einstellungen & Branding (TEN-03, siehe core-kanban/tickets/TEN-03.md).
+-- Alle Spalten NULLABLE: ein fehlender Wert bedeutet "System-Default
+-- verwenden" (Akzeptanzkriterium 2), niemals ein Fehler.
+CREATE TABLE tenant_settings (
+    tenant_id    UUID PRIMARY KEY REFERENCES tenants(id),
+    display_name TEXT,
+    logo_url     TEXT,
+    color_scheme TEXT,
+    timezone     TEXT,
+    language     TEXT,
+    version      INT NOT NULL DEFAULT 0,
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TABLE tenant_settings_history (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    tenant_id    UUID NOT NULL,
+    display_name TEXT,
+    logo_url     TEXT,
+    color_scheme TEXT,
+    timezone     TEXT,
+    language     TEXT,
+    version      INT NOT NULL,
+    changed_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE INDEX tenant_settings_history_tenant_idx ON tenant_settings_history (tenant_id, version);
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS users;
@@ -0,0 +1,16 @@
+-- Benutzer-Datenmodell (IAM-01, siehe core-kanban/tickets/IAM-01.md).
+-- Diese Migration laeuft in der DB EINES Mandanten (Modell C, siehe TEN-01) —
+-- die Tenant-Zugehoerigkeit ist implizit durch die Datenbankverbindung
+-- gegeben, es gibt daher bewusst KEINE tenant_id-Spalte.
+-- E-Mail-Eindeutigkeit ist hier tenant-scoped: der UNIQUE-Constraint gilt
+-- nur innerhalb dieser einen Tenant-Datenbank.
+CREATE EXTENSION IF NOT EXISTS pgcrypto;
+
+CREATE TABLE users (
+    id           UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    email        TEXT NOT NULL UNIQUE,
+    name         TEXT NOT NULL,
+    status       TEXT NOT NULL DEFAULT 'active',
+    created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now()
+);
@@ -0,0 +1,25 @@
+#!/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 tenant_settings_history CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenant_settings CASCADE;"
+psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants 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."
@@ -0,0 +1,24 @@
+#!/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
Author	SHA1	Message	Date
sysopsandClaude Sonnet 5	383da92ca8	TEN-03: tenant-einstellungen-branding internal/tenantsettings: pro-Tenant-Einstellungen (Anzeigename, Logo, Farbschema, Zeitzone, Sprache) in der Registry-DB, alle Spalten nullable — fehlender Wert bedeutet immer "Systemvoreinstellung verwenden" (Defaults(): color_scheme=system, timezone=UTC, language=de), niemals ein Fehler (Akzeptanzkriterium 2). Store.Update schreibt aktuellen Stand + Historieneintrag atomar in einer Transaktion mit FOR-UPDATE-Lock auf der aktuellen Zeile (Akzeptanzkriterium 3, Race-sicher bei nebenlaeufigen Updates desselben Tenants). Patch-Typ mit *string-Feldern erlaubt Teil-Updates ohne unbeteiligte Felder zu beruehren. Schlanker Handler (Get/Update ueber tenant_id-Query-Parameter) als Vorbereitung der REST-Schnittstelle — echte Auth/Versionierung kommt erst mit API-01/IAM-02/RBAC-01. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Aenderung eines Tenants wirkt sich nicht auf einen anderen aus — TestUpdate_IsolatedBetweenTenants: Tenant A geaendert, Tenant B bleibt nachweislich bei Defaults(). PASS. 2. Fehlende Werte liefern Defaults statt Fehler — TestGet_UnsetTenantReturnsDefaults (Tenant ganz ohne Datensatz) und TestUpdate_PartialPatchKeepsOtherFieldsAtDefault (nur ein Feld gesetzt, Rest bleibt Default). PASS. 3. API-Schema von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Zusaetzlich automatisiert getestet (Akzeptanzkriterium 3): TestUpdate_HistoryTracksVersions — 3 aufeinanderfolgende Aenderungen, Historie liefert alle 3 in korrekter Reihenfolge, nicht angefasste Felder bleiben aus dem vorherigen Update erhalten. PASS. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 19:34:09 +02:00
sysopsandClaude Sonnet 5	5915a4e7b1	TEN-02: tenant-onboarding-api-self-service OnboardingService.Onboard: ein API-Aufruf legt Tenant (via bestehendem Provisioner) UND ersten Administrator-Account (via IAM-01 TenantUserStore) an. CREATE DATABASE erlaubt keine echte cross-database Transaktion, daher Saga-Kompensation: schlaegt die Admin-Anlage nach erfolgreichem Provisioning fehl, wird der Tenant per neuem Provisioner.Deprovision wieder vollstaendig entfernt (Registry.Delete + DB-Drop). Provisioner.Provision mappt Duplikat-Faelle (42P04 duplicate_database und den bei echt parallelen CREATE DATABASE moeglichen 23505-Unique-Konflikt auf pg_database) jetzt auf ErrTenantExists statt einer rohen Postgres-Fehlermeldung. Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. Onboarding-Vorgang zweimal parallel mit gleichem Slug ausgeloest — TestOnboarding_RejectsDuplicateSlugConcurrently: genau ein Erfolg, kein Doppel-Tenant, zweiter Aufruf bekommt ErrTenantExists. PASS. 2. Fehleingaben (leere Pflichtfelder, ungueltige E-Mail, ungueltiger Slug) — TestOnboarding_ValidationErrors deckt alle vier Faelle mit klaren Fehlern ab, bevor irgendein DB-Zugriff stattfindet. PASS. 3. Erfolgreicher Durchlauf von zweiter Person end-to-end nachvollzogen — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 18:16:54 +02:00
sysopsandClaude Sonnet 5	e4793303fc	IAM-01: benutzer-datenmodell-crud Benutzer-Datenmodell + CRUD fuer Tenant-User (tenant-scoped, keine tenant_id-Spalte noetig, Tenant ergibt sich aus der DB-Verbindung, Modell C) und getrennt dafuer SuperadminStore fuer mandantenuebergreifende Konten in der Registry-DB — First-Class-Typ statt tenant_id-NULL-Sonderfall im Tenant-User-Code (bekannter archivdms-Fehler vermieden). E-Mail-Eindeutigkeit: tenant-scoped fuer normale Benutzer (UNIQUE-Constraint gilt nur innerhalb der jeweiligen Tenant-DB), global fuer Superadmins (eine Registry-DB, ein UNIQUE-Constraint). Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS): 1. CRUD automatisiert getestet inkl. Negativfaellen — TestTenantUserStore_CRUD deckt doppelte E-Mail (ErrEmailTaken) und unbekannte ID ab. PASS. 2. Superadmin-Anlage ohne Tenant-Kontext — TestSuperadminStore_CreateWithoutTenantContext: SuperadminStore.Create hat syntaktisch keinen Tenant-Parameter, kein if-Zweig fuer "kein Tenant" im Code. PASS. 3. Datenmodell von zweiter Person gegen Dokumentation geprueft — NICHT durchgefuehrt (keine zweite Person in dieser Session verfuegbar). Offen. Tenant-User-Handler ist im Code vorhanden, aber in cmd/core/main.go noch nicht geroutet — braucht Connection-Routing pro Mandant (TEN-06), das nicht Teil dieser Kachel ist. Nur der Superadmin-Endpunkt ist verdrahtet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:57:49 +02:00
sysopsandClaude Sonnet 5	8da9c67d08	TEN-01: tenant-registry-datenbank-provisioning Registry-DB (nur Tenant-Metadaten), Provisioning-Routine legt pro Mandant eine physisch isolierte Postgres-DB an und registriert sie transaktional (Rollback der DB bei fehlgeschlagener Registrierung). Schlanker HTTP-Handler als Schnittstellen-Vorbereitung fuer API-01/TEN-02, kein eigenes REST-Grundgerüst. Pruefungen: 1. Migration up/down geschrieben (0001_tenant_registry.{up,down}.sql) — nicht gegen echte DB ausgefuehrt, da auf dieser Maschine kein Go/Postgres-Test- Setup verfuegbar ist. Offen zur Ausfuehrung. 2. Integrationstest TestProvision_CreatesIsolatedDatabases geschrieben (zwei Mandanten, prueft unterschiedliche db_name und current_database()) — ebenfalls nicht ausgefuehrt, guarded per TEST_ADMIN_DSN env var. Offen. 3. Slug-Validierung (unit test TestValidateSlug) deckt SQL-Injection-Versuch im Datenbanknamen ab — ebenfalls nicht lokal ausgefuehrt, da kein Go Compiler auf dieser Maschine vorhanden ist. Offen. Alle drei Pruefungen sind vorbereitet, aber NICHT durchgefuehrt worden — zaehlen laut Vorgabe als offen bis auf einer Maschine mit Go+Postgres verifiziert. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>	2026-08-27 17:40:35 +02:00