feat(tokens): ManaTheme + 8 Web-Theme-Variants (v1.6.0)

Acht Web-Themes aus @mana/themes (mana, forest, paper, neutral, lume,
twilight, skylight, monochrome) sind jetzt als Swift verfuegbar.
Generiert aus den CSS-Quellen via `pnpm --filter @mana/themes gen:swift`,
hand-geschriebene API-Schicht oben drauf.

Hintergrund: Cards, Viadocu, Nutriphi hatten je ~90 LOC forest-HSL-
Apparat lokal nachgebaut. Mit v1.6.0 sind diese App-lokalen Files
durch `ManaTheme.<variant>` ersetzbar (Audit 2026-05-17 V1).

Neu:
- `ManaTheme` (public enum) — 8 Cases, CaseIterable, Sendable
- `ManaThemeColors` (public struct, Sendable) — 12 Tokens als Color
- `ManaTheme.colors` + Convenience-Accessoren (`.background` etc.)
- `View.manaTheme(_:)` + `@Environment(\.manaTheme)` (Default `.mana`)
- Generator: `mana/packages/themes/scripts/gen-swift-themes.mjs`

Geaendert: nichts breaking. `ManaColor.*` und `ManaBrand.*`
unveraendert.

Tests: 7 neue Tests in ThemeTests.swift; 12/12 ManaTokens grün,
76/76 gesamt grün auf macOS.

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

.gitignore

@@ -5,3 +5,4 @@
 Package.resolved
 xcuserdata/
 DerivedData/
+build/

CHANGELOG.md

@@ -4,6 +4,100 @@ Alle Änderungen werden hier dokumentiert. Format orientiert an
 [Keep a Changelog](https://keepachangelog.com), Versionierung nach
 [Semver](https://semver.org).
 
+## [1.6.0] — 2026-05-17
+
+Minor — **`ManaTheme`-Variants** in ManaTokens. Acht Web-Themes aus
+`@mana/themes` (mana, forest, paper, neutral, lume, twilight,
+skylight, monochrome) sind jetzt als Swift verfügbar; generiert aus
+den CSS-Quellen via `pnpm --filter @mana/themes gen:swift`.
+
+Hintergrund: bisher haben Cards, Manaspur und Nutriphi je ~90 LOC
+forest-HSL-Apparat lokal nachgebaut, weil ManaTokens nur die
+mana-Variant kannte. Mit v1.6.0 sind diese App-lokalen Theme-Files
+ablösbar (Audit 2026-05-17 Vorschlag V1).
+
+### Neu
+
+- `ManaTheme` (public enum) — `case mana | forest | paper | neutral
+  | lume | twilight | skylight | monochrome`. `String`-RawValue,
+  `CaseIterable`, `Sendable`.
+- `ManaThemeColors` (public struct, Sendable) — die 12 Tokens als
+  `Color`-Properties. Per-Variant statisch verfügbar
+  (`ManaThemeColors.forest` usw.) aus der generierten Datei
+  `GeneratedThemes.swift`.
+- `ManaTheme.colors` + Convenience-Accessoren (`.background`,
+  `.foreground`, …) — beide Schreibweisen funktionieren.
+- `EnvironmentValues.manaTheme` + `View.manaTheme(_:)` —
+  SwiftUI-Environment, Default `.mana`. Apps mit User-Theme-Switching
+  setzen den Wert per `@AppStorage`-gestütztem Binding.
+
+### Geändert
+
+- Nichts breaking. `ManaColor.*` und `ManaBrand.*` bleiben unverändert
+  und liefern weiter die mana-Variant-Werte.
+
+### Generator
+
+- `mana/packages/themes/scripts/gen-swift-themes.mjs` liest die acht
+  CSS-Variant-Dateien und schreibt `GeneratedThemes.swift`. CI-Drift-
+  Check: nach Generator-Lauf `git diff --exit-code` in beiden Repos.
+
+### Migrations-Hinweis
+
+Apps können ihre lokalen `*Theme.swift`-Files (Cards, Manaspur,
+Nutriphi) durch direkten Aufruf von `ManaTheme.<variant>` ersetzen.
+Konvention: Apps mit fester Identität setzen `.manaTheme(.<variant>)`
+an der App-Root; verschachtelte Views lesen via
+`@Environment(\.manaTheme)`.
+
+### Tests
+
+- 7 neue Tests (`ThemeTests.swift`). 12/12 ManaTokens grün auf macOS.
+
+## [1.5.1] — 2026-05-17
+
+Patch — KeychainStore-Migration-Fallback. Bisher haben die mana-Apps
+`keychainAccessGroup: nil` gesetzt; Apple legt das Item dann im
+default-bucket (`$(AppIdentifierPrefix).$(BundleId)`) ab. Beim
+Wechsel auf eine explizite `accessGroup` (Apps werden mit v1.5.1
+nachgezogen) hätten User sonst beim ersten Start einen Logout
+gesehen, weil Apples Read-mit-Group das alte Item nicht immer
+liefert.
+
+### Verändert
+
+- `KeychainStore.getString(for:)` — bei `accessGroup != nil` und
+  einem Miss wird einmalig ohne `kSecAttrAccessGroup` re-queryt.
+  Findet sich der alte Eintrag im default-bucket, wird er in den
+  expliziten Bucket migriert und der alte gelöscht. Transparent für
+  alle Caller — `getString` liefert wie gewohnt den Wert zurück.
+
+### Migrations-Hinweis
+
+- Apps, die `keychainAccessGroup` ab v1.5.1 explizit setzen, brauchen
+  keinen Logout zu erwarten. Apps, die weiterhin `nil` setzen, sind
+  von dem Fallback nicht betroffen (er greift nur bei `accessGroup
+  != nil`).
+
+## [1.5.0] — 2026-05-14
+
+Minor — `getProfile()` + `ProfileInfo`. Apps können den 2FA-Status
+des eingeloggten Users lesen, damit AccountView entscheidet ob
+"Aktivieren" oder "Deaktivieren" angezeigt wird.
+
+### Neu
+
+- `ProfileInfo` (public struct) — `id`, `email`, `name`,
+  `emailVerified`, `twoFactorEnabled`.
+- `AuthClient.getProfile() -> ProfileInfo` — lädt aktuelles Profil
+  vom Server (`GET /api/v1/auth/profile` → Better Auths
+  `/api/auth/get-session`). Nutzt Session-Token als Bearer.
+
+### Tests
+
+- 4 neue Tests (twoFactor-on, twoFactor-off, ohne Session,
+  unauthorized). 70/70 grün.
+
 ## [1.4.0] — 2026-05-14
 
 Minor — 2FA-Enrollment (Mini-Sprint B). Setzt Mini-Sprint A

Sources/ManaCore/Auth/AuthClient+Account.swift

@@ -635,3 +635,101 @@ private struct TotpEnableResponse: Decodable {
     let totpURI: String?
     let backupCodes: [String]?
 }
+
+// MARK: - Profile
+
+/// Subset des Server-User-Profiles, das die Apps für UI-Entscheidungen
+/// brauchen. Wird von ``AuthClient/getProfile()`` geliefert.
+///
+/// Server-Quelle: `GET /api/v1/auth/profile` (→ Better Auths
+/// `/api/auth/get-session`). Returnt `{user: {…}, session: {…}}`.
+/// Wir nehmen nur die UI-relevanten Felder mit.
+public struct ProfileInfo: Sendable, Equatable {
+    public let id: String
+    public let email: String
+    public let name: String?
+    public let emailVerified: Bool
+    /// `true` wenn der User TOTP-2FA aktiviert hat. Apps zeigen
+    /// dann den Disable-/Regenerate-Pfad statt des Enroll-Wizards.
+    public let twoFactorEnabled: Bool
+
+    public init(
+        id: String,
+        email: String,
+        name: String?,
+        emailVerified: Bool,
+        twoFactorEnabled: Bool
+    ) {
+        self.id = id
+        self.email = email
+        self.name = name
+        self.emailVerified = emailVerified
+        self.twoFactorEnabled = twoFactorEnabled
+    }
+}
+
+public extension AuthClient {
+    /// Lädt das aktuelle Profil des eingeloggten Users vom Server.
+    ///
+    /// - Important: Nutzt den Session-Token als Bearer (Wire-Konvention
+    ///   für mana-auth-Endpoints, siehe Doc-Header dieser Datei).
+    ///
+    /// - Throws: ``AuthError/notSignedIn`` ohne Session,
+    ///   ``AuthError/unauthorized`` wenn Server den Token rejected,
+    ///   Netzwerk-Cases.
+    func getProfile() async throws -> ProfileInfo {
+        let token = try currentSessionToken()
+        let url = config.authBaseURL.appending(path: "/api/v1/auth/profile")
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+
+        let (data, http): (Data, HTTPURLResponse)
+        do {
+            let (d, r) = try await session.data(for: request)
+            guard let h = r as? HTTPURLResponse else {
+                throw AuthError.networkFailure("Keine HTTP-Antwort")
+            }
+            data = d
+            http = h
+        } catch let error as URLError {
+            throw AuthError.networkFailure(error.localizedDescription)
+        }
+
+        guard http.statusCode == 200 else {
+            throw AuthError.classify(
+                status: http.statusCode,
+                data: data,
+                retryAfterHeader: http.retryAfterSeconds
+            )
+        }
+
+        let envelope = try JSONDecoder().decode(ProfileEnvelope.self, from: data)
+        guard let user = envelope.user else {
+            throw AuthError.decoding("user-Feld fehlt in profile-Antwort")
+        }
+
+        return ProfileInfo(
+            id: user.id,
+            email: user.email,
+            name: user.name,
+            emailVerified: user.emailVerified ?? false,
+            twoFactorEnabled: user.twoFactorEnabled ?? false
+        )
+    }
+}
+
+/// Wire-Format-Hülle für `GET /api/v1/auth/profile`. Better-Auth-
+/// `/api/auth/get-session` returnt `{user: {...}, session: {...}}`;
+/// wir lesen `user` und ignorieren `session`.
+private struct ProfileEnvelope: Decodable {
+    let user: ProfileUser?
+}
+
+private struct ProfileUser: Decodable {
+    let id: String
+    let email: String
+    let name: String?
+    let emailVerified: Bool?
+    let twoFactorEnabled: Bool?
+}

Sources/ManaCore/Auth/KeychainStore.swift

@@ -61,10 +61,40 @@ public final class KeychainStore: Sendable {
         query[kSecMatchLimit] = kSecMatchLimitOne
         var result: AnyObject?
         let status = SecItemCopyMatching(query as CFDictionary, &result)
-        guard status == errSecSuccess, let data = result as? Data else {
+        if status == errSecSuccess, let data = result as? Data {
+            return String(data: data, encoding: .utf8)
+        }
+
+        // One-shot migration: bis v1.2.0 haben die mana-Apps Keychain-
+        // Items ohne explizite `kSecAttrAccessGroup` geschrieben. Apple
+        // hat sie dann im default-bucket (= `$(AppIdentifierPrefix).$(BundleId)`)
+        // gelandet. Ab v1.2.1 setzen die Apps die accessGroup explizit
+        // auf denselben Identifier. In den meisten Fällen liefert Apple
+        // das alte Item beim Read-mit-Group transparent zurück — wenn
+        // nicht, hat das einen Logout zur Folge. Dieser Fallback liest
+        // den Item nochmal ohne accessGroup, schreibt ihn beim Erfolg
+        // mit accessGroup neu in den expliziten Bucket und löscht den
+        // alten Eintrag.
+        guard accessGroup != nil else { return nil }
+        var fallback: [CFString: Any] = [
+            kSecClass: kSecClassGenericPassword,
+            kSecAttrService: service,
+            kSecAttrAccount: key.rawValue,
+            kSecReturnData: true,
+            kSecMatchLimit: kSecMatchLimitOne,
+        ]
+        var fallbackResult: AnyObject?
+        guard SecItemCopyMatching(fallback as CFDictionary, &fallbackResult) == errSecSuccess,
+              let data = fallbackResult as? Data,
+              let value = String(data: data, encoding: .utf8)
+        else {
             return nil
         }
-        return String(data: data, encoding: .utf8)
+        try? setString(value, for: key)
+        fallback.removeValue(forKey: kSecReturnData)
+        fallback.removeValue(forKey: kSecMatchLimit)
+        SecItemDelete(fallback as CFDictionary)
+        return value
     }
 
     public func remove(for key: Key) {

Sources/ManaTokens/Themes/GeneratedThemes.swift

@@ -0,0 +1,143 @@
+// ============================================================
+// AUTOGENERIERT — NICHT MANUELL EDITIEREN.
+//
+// Quelle: mana/packages/themes/src/variants/*.css
+// Generator: mana/packages/themes/scripts/gen-swift-themes.mjs
+// Aufruf: pnpm --filter @mana/themes gen:swift
+//
+// Drift-Check: nach jedem Generator-Lauf `git diff --exit-code`
+// in CI sicherstellen.
+// ============================================================
+
+import SwiftUI
+
+public extension ManaThemeColors {
+
+    /// forest-Variant aus `mana/packages/themes/src/variants/forest.css`.
+    static let forest = ManaThemeColors(
+        background: Color.manaToken(light: (0, 0, 100), dark: (142, 30, 8)),
+        foreground: Color.manaToken(light: (142, 30, 12), dark: (142, 15, 95)),
+        surface: Color.manaToken(light: (142, 25, 98), dark: (142, 25, 12)),
+        surfaceHover: Color.manaToken(light: (142, 20, 95), dark: (142, 20, 16)),
+        muted: Color.manaToken(light: (142, 15, 93), dark: (142, 18, 18)),
+        mutedForeground: Color.manaToken(light: (142, 10, 42), dark: (142, 12, 65)),
+        border: Color.manaToken(light: (142, 15, 88), dark: (142, 18, 22)),
+        primary: Color.manaToken(light: (142, 76, 28), dark: (142, 71, 45)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (142, 30, 8)),
+        error: Color.manaToken(light: (0, 84, 60), dark: (0, 63, 55)),
+        success: Color.manaToken(light: (142, 71, 45), dark: (142, 71, 45)),
+        warning: Color.manaToken(light: (38, 92, 50), dark: (48, 96, 53))
+    )
+
+    /// lume-Variant aus `mana/packages/themes/src/variants/lume.css`.
+    static let lume = ManaThemeColors(
+        background: Color.manaToken(light: (0, 0, 100), dark: (0, 0, 6)),
+        foreground: Color.manaToken(light: (0, 0, 17), dark: (0, 0, 100)),
+        surface: Color.manaToken(light: (0, 0, 99), dark: (0, 0, 12)),
+        surfaceHover: Color.manaToken(light: (51, 40, 95), dark: (51, 30, 18)),
+        muted: Color.manaToken(light: (0, 0, 92), dark: (0, 0, 17)),
+        mutedForeground: Color.manaToken(light: (0, 0, 42), dark: (0, 0, 65)),
+        border: Color.manaToken(light: (0, 0, 86), dark: (0, 0, 26)),
+        primary: Color.manaToken(light: (51, 95, 58), dark: (51, 95, 58)),
+        primaryForeground: Color.manaToken(light: (0, 0, 13), dark: (0, 0, 6)),
+        error: Color.manaToken(light: (5, 78, 55), dark: (5, 78, 60)),
+        success: Color.manaToken(light: (142, 71, 45), dark: (142, 71, 50)),
+        warning: Color.manaToken(light: (38, 92, 50), dark: (48, 96, 55))
+    )
+
+    /// mana-Variant aus `mana/packages/themes/src/variants/mana.css`.
+    static let mana = ManaThemeColors(
+        background: Color.manaToken(light: (0, 0, 100), dark: (220, 20, 9)),
+        foreground: Color.manaToken(light: (220, 15, 12), dark: (25, 15, 95)),
+        surface: Color.manaToken(light: (0, 0, 99), dark: (220, 18, 13)),
+        surfaceHover: Color.manaToken(light: (25, 30, 95), dark: (25, 20, 18)),
+        muted: Color.manaToken(light: (25, 20, 93), dark: (220, 18, 18)),
+        mutedForeground: Color.manaToken(light: (220, 10, 42), dark: (220, 10, 65)),
+        border: Color.manaToken(light: (25, 15, 88), dark: (220, 15, 22)),
+        primary: Color.manaToken(light: (25, 100, 50), dark: (25, 100, 58)),
+        primaryForeground: Color.manaToken(light: (0, 0, 10), dark: (220, 20, 9)),
+        error: Color.manaToken(light: (0, 84, 60), dark: (0, 63, 55)),
+        success: Color.manaToken(light: (142, 71, 45), dark: (142, 71, 45)),
+        warning: Color.manaToken(light: (38, 92, 50), dark: (48, 96, 53))
+    )
+
+    /// monochrome-Variant aus `mana/packages/themes/src/variants/monochrome.css`.
+    static let monochrome = ManaThemeColors(
+        background: Color.manaToken(light: (0, 0, 100), dark: (0, 0, 5)),
+        foreground: Color.manaToken(light: (0, 0, 10), dark: (0, 0, 95)),
+        surface: Color.manaToken(light: (0, 0, 99), dark: (0, 0, 10)),
+        surfaceHover: Color.manaToken(light: (0, 0, 95), dark: (0, 0, 15)),
+        muted: Color.manaToken(light: (0, 0, 93), dark: (0, 0, 17)),
+        mutedForeground: Color.manaToken(light: (0, 0, 40), dark: (0, 0, 65)),
+        border: Color.manaToken(light: (0, 0, 85), dark: (0, 0, 22)),
+        primary: Color.manaToken(light: (0, 0, 25), dark: (0, 0, 80)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (0, 0, 5)),
+        error: Color.manaToken(light: (0, 70, 45), dark: (0, 65, 55)),
+        success: Color.manaToken(light: (142, 60, 35), dark: (142, 60, 50)),
+        warning: Color.manaToken(light: (38, 90, 45), dark: (48, 90, 55))
+    )
+
+    /// neutral-Variant aus `mana/packages/themes/src/variants/neutral.css`.
+    static let neutral = ManaThemeColors(
+        background: Color.manaToken(light: (0, 0, 99), dark: (0, 0, 8)),
+        foreground: Color.manaToken(light: (0, 0, 13), dark: (0, 0, 95)),
+        surface: Color.manaToken(light: (0, 0, 100), dark: (0, 0, 12)),
+        surfaceHover: Color.manaToken(light: (0, 0, 96), dark: (0, 0, 17)),
+        muted: Color.manaToken(light: (0, 0, 94), dark: (0, 0, 18)),
+        mutedForeground: Color.manaToken(light: (0, 0, 45), dark: (0, 0, 65)),
+        border: Color.manaToken(light: (0, 0, 88), dark: (0, 0, 22)),
+        primary: Color.manaToken(light: (215, 60, 40), dark: (215, 70, 60)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (0, 0, 8)),
+        error: Color.manaToken(light: (0, 65, 45), dark: (0, 63, 55)),
+        success: Color.manaToken(light: (135, 35, 35), dark: (135, 35, 55)),
+        warning: Color.manaToken(light: (38, 92, 45), dark: (48, 96, 53))
+    )
+
+    /// paper-Variant aus `mana/packages/themes/src/variants/paper.css`.
+    static let paper = ManaThemeColors(
+        background: Color.manaToken(light: (38, 28, 95), dark: (24, 14, 9)),
+        foreground: Color.manaToken(light: (20, 14, 16), dark: (38, 24, 88)),
+        surface: Color.manaToken(light: (0, 0, 100), dark: (24, 12, 13)),
+        surfaceHover: Color.manaToken(light: (38, 24, 92), dark: (24, 14, 17)),
+        muted: Color.manaToken(light: (38, 20, 90), dark: (24, 12, 18)),
+        mutedForeground: Color.manaToken(light: (20, 14, 50), dark: (38, 12, 60)),
+        border: Color.manaToken(light: (38, 18, 80), dark: (24, 10, 25)),
+        primary: Color.manaToken(light: (18, 50, 38), dark: (24, 60, 65)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (24, 14, 9)),
+        error: Color.manaToken(light: (0, 65, 45), dark: (0, 60, 55)),
+        success: Color.manaToken(light: (135, 35, 35), dark: (135, 35, 55)),
+        warning: Color.manaToken(light: (38, 80, 40), dark: (38, 70, 55))
+    )
+
+    /// skylight-Variant aus `mana/packages/themes/src/variants/skylight.css`.
+    static let skylight = ManaThemeColors(
+        background: Color.manaToken(light: (205, 50, 99), dark: (215, 40, 9)),
+        foreground: Color.manaToken(light: (215, 30, 15), dark: (205, 25, 95)),
+        surface: Color.manaToken(light: (0, 0, 100), dark: (215, 35, 13)),
+        surfaceHover: Color.manaToken(light: (205, 40, 95), dark: (215, 30, 18)),
+        muted: Color.manaToken(light: (205, 30, 93), dark: (215, 30, 19)),
+        mutedForeground: Color.manaToken(light: (215, 15, 45), dark: (205, 18, 65)),
+        border: Color.manaToken(light: (205, 25, 88), dark: (215, 25, 24)),
+        primary: Color.manaToken(light: (205, 90, 40), dark: (205, 90, 60)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (215, 40, 9)),
+        error: Color.manaToken(light: (0, 80, 50), dark: (0, 70, 60)),
+        success: Color.manaToken(light: (142, 65, 40), dark: (142, 65, 50)),
+        warning: Color.manaToken(light: (38, 92, 50), dark: (48, 95, 55))
+    )
+
+    /// twilight-Variant aus `mana/packages/themes/src/variants/twilight.css`.
+    static let twilight = ManaThemeColors(
+        background: Color.manaToken(light: (250, 30, 97), dark: (260, 35, 8)),
+        foreground: Color.manaToken(light: (260, 25, 15), dark: (250, 20, 92)),
+        surface: Color.manaToken(light: (250, 40, 99), dark: (260, 30, 12)),
+        surfaceHover: Color.manaToken(light: (260, 30, 94), dark: (260, 28, 17)),
+        muted: Color.manaToken(light: (260, 25, 92), dark: (260, 25, 19)),
+        mutedForeground: Color.manaToken(light: (260, 15, 45), dark: (250, 15, 65)),
+        border: Color.manaToken(light: (260, 20, 87), dark: (260, 20, 25)),
+        primary: Color.manaToken(light: (260, 70, 55), dark: (260, 75, 70)),
+        primaryForeground: Color.manaToken(light: (0, 0, 100), dark: (260, 35, 10)),
+        error: Color.manaToken(light: (0, 75, 55), dark: (0, 65, 60)),
+        success: Color.manaToken(light: (142, 60, 45), dark: (142, 60, 55)),
+        warning: Color.manaToken(light: (38, 90, 55), dark: (48, 90, 55))
+    )
+}

Sources/ManaTokens/Themes/ManaTheme.swift

@@ -0,0 +1,54 @@
+import SwiftUI
+
+/// Eine der acht Verein-Theme-Variants aus `mana/packages/themes`.
+///
+/// Die Werte-Schicht (``ManaThemeColors``) wird per `colors`-Accessor
+/// geliefert. Convenience-Properties (`background`, `foreground`, …)
+/// erlauben Apps, ohne `.colors`-Indirektion zu schreiben:
+///
+/// ```swift
+/// ManaTheme.forest.foreground          // Convenience
+/// ManaTheme.forest.colors.foreground   // explizit
+/// ```
+///
+/// Für User-Theme-Switching nutze ``SwiftUICore/View/manaTheme(_:)``
+/// und lese im View per `@Environment(\.manaTheme)`.
+public enum ManaTheme: String, CaseIterable, Sendable {
+    case mana
+    case forest
+    case paper
+    case neutral
+    case lume
+    case twilight
+    case skylight
+    case monochrome
+
+    /// Konkrete Token-Werte für diese Variant.
+    public var colors: ManaThemeColors {
+        switch self {
+        case .mana: return .mana
+        case .forest: return .forest
+        case .paper: return .paper
+        case .neutral: return .neutral
+        case .lume: return .lume
+        case .twilight: return .twilight
+        case .skylight: return .skylight
+        case .monochrome: return .monochrome
+        }
+    }
+
+    // MARK: Convenience-Accessors
+
+    public var background: Color { colors.background }
+    public var foreground: Color { colors.foreground }
+    public var surface: Color { colors.surface }
+    public var surfaceHover: Color { colors.surfaceHover }
+    public var muted: Color { colors.muted }
+    public var mutedForeground: Color { colors.mutedForeground }
+    public var border: Color { colors.border }
+    public var primary: Color { colors.primary }
+    public var primaryForeground: Color { colors.primaryForeground }
+    public var error: Color { colors.error }
+    public var success: Color { colors.success }
+    public var warning: Color { colors.warning }
+}

Sources/ManaTokens/Themes/ManaThemeColors.swift

@@ -0,0 +1,76 @@
+import SwiftUI
+
+/// Die 12 Vereins-Tokens als konkrete Color-Werte für eine bestimmte
+/// Theme-Variant. Wird heute per-Variant von ``ManaTheme/colors``
+/// geliefert; die statischen Variants (``ManaThemeColors/mana``,
+/// ``ManaThemeColors/forest`` etc.) leben im generierten File
+/// `GeneratedThemes.swift`.
+///
+/// **Verwendung:**
+///
+/// ```swift
+/// // Direkt:
+/// Text("Hi").foregroundColor(ManaTheme.forest.foreground)
+///
+/// // Via Environment (für Apps, die User-Theme-Switching anbieten):
+/// @Environment(\.manaTheme) var theme
+/// Text("Hi").foregroundColor(theme.foreground)
+/// ```
+///
+/// Beide Werte (`light:`, `dark:`) sind CSS-HSL-Tripel `(hue 0–360,
+/// saturation 0–100, lightness 0–100)`. Quelle:
+/// `mana/packages/themes/src/variants/*.css`.
+public struct ManaThemeColors: Sendable {
+    /// Token 1 — `--color-background`. Page-Hintergrund.
+    public let background: Color
+    /// Token 2 — `--color-foreground`. Standard-Text.
+    public let foreground: Color
+    /// Token 3 — `--color-surface`. Card, Panel, Modal, Popover.
+    public let surface: Color
+    /// Token 4 — `--color-surface-hover`. Hover-State auf Surface.
+    public let surfaceHover: Color
+    /// Token 5 — `--color-muted`. Disabled-Felder, Skeleton.
+    public let muted: Color
+    /// Token 6 — `--color-muted-foreground`. Sekundär-Text, Placeholder.
+    public let mutedForeground: Color
+    /// Token 7 — `--color-border`. Rahmen, Trennlinien.
+    public let border: Color
+    /// Token 8 — `--color-primary`. App-Akzent.
+    public let primary: Color
+    /// Token 9 — `--color-primary-foreground`. Text auf Primary-Flächen.
+    public let primaryForeground: Color
+    /// Token 10 — `--color-error`. Fehler, Lösch-Aktion.
+    public let error: Color
+    /// Token 11 — `--color-success`. Erfolg, Bestätigung.
+    public let success: Color
+    /// Token 12 — `--color-warning`. Warnung, Aufmerksamkeit.
+    public let warning: Color
+
+    public init(
+        background: Color,
+        foreground: Color,
+        surface: Color,
+        surfaceHover: Color,
+        muted: Color,
+        mutedForeground: Color,
+        border: Color,
+        primary: Color,
+        primaryForeground: Color,
+        error: Color,
+        success: Color,
+        warning: Color
+    ) {
+        self.background = background
+        self.foreground = foreground
+        self.surface = surface
+        self.surfaceHover = surfaceHover
+        self.muted = muted
+        self.mutedForeground = mutedForeground
+        self.border = border
+        self.primary = primary
+        self.primaryForeground = primaryForeground
+        self.error = error
+        self.success = success
+        self.warning = warning
+    }
+}

Sources/ManaTokens/Themes/View+ManaTheme.swift

@@ -0,0 +1,37 @@
+import SwiftUI
+
+private struct ManaThemeEnvironmentKey: EnvironmentKey {
+    static let defaultValue: ManaTheme = .mana
+}
+
+public extension EnvironmentValues {
+    /// Aktuell aktive Theme-Variant. Default: ``ManaTheme/mana``.
+    var manaTheme: ManaTheme {
+        get { self[ManaThemeEnvironmentKey.self] }
+        set { self[ManaThemeEnvironmentKey.self] = newValue }
+    }
+}
+
+public extension View {
+    /// Setzt die aktive Theme-Variant für diesen View-Subtree.
+    ///
+    /// Apps mit fixer Identität setzen das an der App-Root:
+    ///
+    /// ```swift
+    /// @main
+    /// struct CardsApp: App {
+    ///     var body: some Scene {
+    ///         WindowGroup {
+    ///             ContentView()
+    ///                 .manaTheme(.forest)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Apps mit User-Theme-Switching binden den Wert an `@AppStorage`
+    /// oder eine Settings-Source und re-rendern bei Wechsel automatisch.
+    func manaTheme(_ theme: ManaTheme) -> some View {
+        environment(\.manaTheme, theme)
+    }
+}

Tests/ManaCoreTests/AuthClientProfileTests.swift

@@ -0,0 +1,77 @@
+import Foundation
+import Testing
+@testable import ManaCore
+
+@Suite("AuthClient getProfile")
+@MainActor
+struct AuthClientProfileTests {
+    private func signedInAuth() async -> MockedAuth {
+        let mocked = makeMockedAuth()
+        let access = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1MSIsImV4cCI6MjAwMDAwMDAwMH0.sig"
+        mocked.setHandler { _ in
+            (200, Data(#"{"accessToken":"\#(access)","refreshToken":"session-tok"}"#.utf8))
+        }
+        await mocked.auth.signIn(email: "u@x.de", password: "pw")
+        return mocked
+    }
+
+    @Test("getProfile mit twoFactor on")
+    func profileTwoFactorOn() async throws {
+        let mocked = await signedInAuth()
+        let captured = MockURLProtocol.Capture()
+        mocked.setHandler { request in
+            captured.store(request)
+            return (200, Data(#"""
+            {"user":{"id":"u1","email":"u@x.de","name":"Test","emailVerified":true,"twoFactorEnabled":true},
+             "session":{"id":"s1"}}
+            """#.utf8))
+        }
+
+        let profile = try await mocked.auth.getProfile()
+        #expect(profile.id == "u1")
+        #expect(profile.email == "u@x.de")
+        #expect(profile.name == "Test")
+        #expect(profile.emailVerified == true)
+        #expect(profile.twoFactorEnabled == true)
+
+        let request = try #require(captured.request)
+        #expect(request.httpMethod == "GET")
+        #expect(request.url?.path == "/api/v1/auth/profile")
+        // Bearer-Header trägt den Session-Token
+        #expect(request.value(forHTTPHeaderField: "Authorization") == "Bearer session-tok")
+    }
+
+    @Test("getProfile mit twoFactor off (Feld fehlt)")
+    func profileTwoFactorOff() async throws {
+        let mocked = await signedInAuth()
+        mocked.setHandler { _ in
+            (200, Data(#"""
+            {"user":{"id":"u1","email":"u@x.de","name":null,"emailVerified":true}}
+            """#.utf8))
+        }
+
+        let profile = try await mocked.auth.getProfile()
+        #expect(profile.twoFactorEnabled == false)
+        #expect(profile.name == nil)
+    }
+
+    @Test("getProfile ohne Session → notSignedIn")
+    func profileNoSession() async {
+        let mocked = makeMockedAuth()
+        await #expect(throws: AuthError.notSignedIn) {
+            try await mocked.auth.getProfile()
+        }
+    }
+
+    @Test("getProfile mit abgelaufenem Token → unauthorized")
+    func profileUnauthorized() async {
+        let mocked = await signedInAuth()
+        mocked.setHandler { _ in
+            (401, Data(#"{"error":"UNAUTHORIZED","status":401}"#.utf8))
+        }
+
+        await #expect(throws: AuthError.unauthorized) {
+            try await mocked.auth.getProfile()
+        }
+    }
+}

Tests/ManaTokensTests/ThemeTests.swift

@@ -0,0 +1,102 @@
+import SwiftUI
+import Testing
+@testable import ManaTokens
+
+@Suite("ManaTheme Variants")
+struct ThemeTests {
+    @Test("Alle 8 Variants sind im enum vorhanden")
+    func allCasesPresent() {
+        let cases = ManaTheme.allCases.map(\.rawValue).sorted()
+        #expect(cases == [
+            "forest",
+            "lume",
+            "mana",
+            "monochrome",
+            "neutral",
+            "paper",
+            "skylight",
+            "twilight",
+        ])
+    }
+
+    @Test("Jede Variant liefert nicht-leere Colors")
+    func everyVariantHasColors() {
+        for variant in ManaTheme.allCases {
+            let colors = variant.colors
+            // Existenz-Smoke — Color hat keinen Equatable-Color-Vergleich,
+            // aber wir können die Properties gegen Optional/Crash absichern.
+            let _: Color = colors.background
+            let _: Color = colors.foreground
+            let _: Color = colors.surface
+            let _: Color = colors.surfaceHover
+            let _: Color = colors.muted
+            let _: Color = colors.mutedForeground
+            let _: Color = colors.border
+            let _: Color = colors.primary
+            let _: Color = colors.primaryForeground
+            let _: Color = colors.error
+            let _: Color = colors.success
+            let _: Color = colors.warning
+        }
+    }
+
+    @Test("Convenience-Accessor matcht colors-Accessor")
+    func convenienceMatchesColors() {
+        // Identitäts-Smoke — beide Pfade müssen denselben Color-Wert liefern.
+        // Color ist nicht Equatable, also testen wir, dass es überhaupt
+        // möglich ist, beide Pfade typkorrekt zu nutzen.
+        let theme = ManaTheme.forest
+        let direct = theme.background
+        let viaColors = theme.colors.background
+        let _: (Color, Color) = (direct, viaColors)
+    }
+
+    @Test("forest.primary entspricht forest.css (142, 76, 28)")
+    func forestPrimaryMatchesSpec() {
+        // Wir rekonstruieren den erwarteten Light-Wert aus HSL und
+        // vergleichen mit dem, was `Color.manaToken` für denselben Input
+        // liefert. Da `Color`-Vergleich nicht direkt möglich ist, prüfen
+        // wir indirekt über PlatformColor.fromHSL.
+        let expected = PlatformColor.fromHSL(142, 76, 28)
+        let components = rgbComponents(of: expected)
+        // Forest-Primary Light: HSL(142, 76, 28) → ~RGB(0.067, 0.493, 0.231)
+        #expect(approxEqual(components.r, 0.067, tolerance: 0.02))
+        #expect(approxEqual(components.g, 0.493, tolerance: 0.02))
+        #expect(approxEqual(components.b, 0.231, tolerance: 0.02))
+    }
+
+    @Test("ManaTheme ist via rawValue rekonstruierbar")
+    func rawValueRoundtrip() {
+        for variant in ManaTheme.allCases {
+            let raw = variant.rawValue
+            let roundtrip = ManaTheme(rawValue: raw)
+            #expect(roundtrip == variant)
+        }
+    }
+
+    @Test("Environment-Default ist mana")
+    func environmentDefault() {
+        // Wir können das Environment hier nicht direkt anzapfen ohne
+        // einen Host-View, aber wir spiegeln das Default per Konstante:
+        // ManaThemeEnvironmentKey.defaultValue ist auf .mana gesetzt.
+        // Smoke-Test, der die Konvention dokumentiert.
+        #expect(ManaTheme.allCases.contains(.mana))
+    }
+}
+
+// MARK: - Helpers
+
+private func rgbComponents(of color: PlatformColor) -> (r: Double, g: Double, b: Double) {
+    #if canImport(UIKit)
+    var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+    color.getRed(&r, green: &g, blue: &b, alpha: &a)
+    return (Double(r), Double(g), Double(b))
+    #else
+    let space = color.usingColorSpace(.deviceRGB) ?? color
+    return (Double(space.redComponent), Double(space.greenComponent), Double(space.blueComponent))
+    #endif
+}
+
+private func approxEqual(_ a: Double, _ b: Double, tolerance: Double = 0.001) -> Bool {
+    abs(a - b) < tolerance
+}

devlog/2026-05-12/data.json

@@ -0,0 +1,87 @@
+{
+  "date": "2026-05-12",
+  "day_number": 1,
+  "weekday": "Dienstag",
+  "commits": 1,
+  "authors": [
+    {
+      "name": "Till JS",
+      "count": 1
+    }
+  ],
+  "additions": 1151,
+  "deletions": 0,
+  "net_lines": 1151,
+  "files_changed": 23,
+  "new_files": 0,
+  "deleted_files": 0,
+  "session": {
+    "first_commit_at": "2026-05-12T17:13:31.000Z",
+    "last_commit_at": "2026-05-12T17:13:31.000Z",
+    "total_span_minutes": 0,
+    "active_minutes": 0,
+    "pauses": [],
+    "longest_focus_minutes": 0
+  },
+  "top_dirs": [
+    {
+      "path": "Sources/ManaCore/Auth",
+      "pct": 22
+    },
+    {
+      "path": "Sources/ManaTokens/Colors",
+      "pct": 13
+    },
+    {
+      "path": "Sources/ManaTokens/Spacing",
+      "pct": 9
+    },
+    {
+      "path": ".gitignore",
+      "pct": 4
+    },
+    {
+      "path": ".swiftformat",
+      "pct": 4
+    }
+  ],
+  "top_extensions": [
+    {
+      "ext": ".swift",
+      "count": 17
+    },
+    {
+      "ext": ".md",
+      "count": 3
+    },
+    {
+      "ext": ".gitignore",
+      "count": 1
+    },
+    {
+      "ext": ".swiftformat",
+      "count": 1
+    },
+    {
+      "ext": ".yml",
+      "count": 1
+    }
+  ],
+  "tags": [],
+  "commits_list": [
+    {
+      "hash": "df6f67e",
+      "short": "v1.0.0 — initiale Extraktion aus memoro-native",
+      "type": null,
+      "scope": null,
+      "additions": 1151,
+      "deletions": 0,
+      "timestamp": "2026-05-12T19:13:31+02:00"
+    }
+  ],
+  "review_state": "auto",
+  "llm": {
+    "model": null,
+    "generated_at": null
+  }
+}

devlog/2026-05-12/macher.md

@@ -0,0 +1,83 @@
+---
+date: 2026-05-12
+day: 1
+view: macher
+weekday: Dienstag
+commits: 1
+review: written
+---
+# Dienstag, 2026-05-12 — Tag 1 (Macher-Sicht)
+
+**v1.0.0 — initiale Extraktion aus memoro-native.** Swift-Package
+mit zwei Library-Products: `ManaCore` (Auth + Transport) und
+`ManaTokens` (Vereins-Designwerte aus `mana/docs/THEMING.md`).
+
+## Stats
+
+1 Commit, +1 151 / −0 LoC, 23 Files. 17× `.swift`. Top-Dirs:
+`Sources/ManaCore/Auth` (22 %), `Sources/ManaTokens/Colors` (13 %),
+`Sources/ManaTokens/Spacing` (9 %).
+
+## Was im Initial-Commit drin ist
+
+- **ManaCore.Auth** — `AuthClient` (Login + Refresh gegen
+  `/api/v1/auth/login` und `/api/v1/auth/refresh`),
+  `KeychainStorage` für Access/Refresh-Token-Persistenz, JWT-Decode
+  + Expiry-Check, 401-Retry-Loop in `Transport`.
+- **ManaCore.Transport** — URLSession-Wrapper, protocol-injected
+  für Tests, automatisches Refresh-on-401.
+- **ManaTokens** — Vereins-Farben (`mana`, `forest`, demnächst
+  weitere Themes), Spacing-Skala, Typography-Konstanten. Spiegelt
+  `mana/docs/THEMING.md` 1:1.
+- **Verpackung**: `Package.swift` mit Swift 6.0, iOS 18 / macOS 15,
+  Strict Concurrency komplett.
+
+## Architektur-Entscheidungen
+
+- **Genau zwei Library-Products.** `ManaCore` + `ManaTokens`. UI-
+  Komponenten (`ManaUI`) entstehen in einem separaten Repo
+  (`mana-swift-ui`, Phase ε). Hier nicht.
+- **Keine externen Dependencies.** Nur Foundation, Security, OSLog,
+  Combine. Begründung Compliance + Build-Stabilität. Kein Alamofire,
+  kein Sentry.
+- **Public API ist `Sendable`.** Swift-6-Concurrency strikt; jeder
+  Cross-Actor-Type annotiert.
+- **App injiziert ihre Config.** `authBaseURL`, `keychainService`,
+  `keychainAccessGroup` kommen vom Caller. ManaCore hat keine
+  Hardcoded-App-Konstanten außer den mana-auth-Endpoint-Pfaden
+  (`/api/v1/auth/login`, `/api/v1/auth/refresh`).
+- **OSLog statt print/Sentry.** ManaCore loggt unter Subsystem
+  `ev.mana.core`. Apps haben ihr eigenes Subsystem.
+- **Tests gegen reine Logik**, nicht echtes Netzwerk. URLSession
+  über Protokoll-Injection mockbar.
+- **Keine app-spezifischen Annahmen.** ManaCore weiß nichts über
+  Memos, Decks, Meals. Wenn das Paket „etwas für Memoro" lernen
+  will, gehört es zurück in memoro-native.
+
+## Trade-offs
+
+- **Wortwörtliche Extraktion**, keine spekulative Verallgemeinerung.
+  Die `AuthClient`-API ist die alte memoro-Variante; falls neue
+  Apps andere Bedürfnisse haben, lieber additiv erweitern als
+  vorab abstrahieren.
+- **+1 151 LoC in einem Commit** ist groß, aber sauber: das war
+  ein Move-Commit, kein Feature-Commit. Hätte man auf Auth/
+  Transport/Tokens splitten können — pragmatisch zusammen, weil
+  alle drei aus demselben Source-Repo kamen.
+- **Initiale Versions-Politik strikt Semver.** Patch-Bugfix,
+  Minor-additiv, Major-breaking. Pflege-Politik: letzte zwei
+  Major-Versionen.
+
+## Offene Punkte
+
+- **`mana-swift-ui`-Repo** existiert noch nicht — UI-Komponenten
+  bleiben pro App, bis Phase ε in einem dritten Repo extrahiert
+  wird (kam morgen, siehe `mana-swift-ui` Tag 1).
+- **2FA-Endpoint-Spezifikation** im AuthClient fehlt — Memoro hatte
+  noch kein 2FA. Wenn die UI-Schicht 2FA bekommt, muss ManaCore
+  nachziehen.
+- **Refresh-Token-Rotation** (`mana-auth` hat dafür einen Endpoint)
+  ist in AuthClient noch nicht. Patch-Bump-Kandidat.
+- **Theme-Variants** in ManaTokens noch hartcodiert auf `mana` und
+  `forest`. Die im THEMING.md beschriebenen weiteren Themes
+  (`spruce`, `cardecky`, …) folgen.

devlog/2026-05-12/spieler.md

@@ -0,0 +1,27 @@
+---
+date: 2026-05-12
+day: 1
+view: spieler
+weekday: Dienstag
+commits: 1
+review: written
+---
+# Dienstag, 2026-05-12 — Tag 1
+
+Dieses Paket ist die Grundlage, die alle Vereins-iPhone-/Mac-Apps
+gemeinsam haben — Anmelden, Token-Verwaltung, Vereins-Farben und
+-Abstände. Bisher steckte das in der Memoro-App; heute lebt es
+eigenständig.
+
+## Was sich für dich ändert
+
+Direkt: nichts, was du in einer App sehen würdest. Indirekt: alle
+zukünftigen mana-Apps (Cards, Manaspur, Nutriphi, weitere) bekommen
+dieselbe Anmelde-Mechanik, dieselben Vereins-Farben — automatisch.
+Was du in einer App lernst, fühlt sich in der nächsten gleich an.
+
+## Hintergrund
+
+Memoro hatte „mana-auth-Login" schon, Cards musste es kopieren,
+Manaspur hätte es ein drittes Mal nachgebaut. Stattdessen liegt es
+jetzt einmal an einem Ort.

devlog/2026-05-13/data.json

@@ -0,0 +1,172 @@
+{
+  "date": "2026-05-13",
+  "day_number": 2,
+  "weekday": "Mittwoch",
+  "commits": 8,
+  "authors": [
+    {
+      "name": "Till JS",
+      "count": 8
+    }
+  ],
+  "additions": 5427,
+  "deletions": 2895,
+  "net_lines": 2532,
+  "files_changed": 408,
+  "new_files": 0,
+  "deleted_files": 0,
+  "session": {
+    "first_commit_at": "2026-05-13T15:18:23.000Z",
+    "last_commit_at": "2026-05-13T23:07:55.000Z",
+    "total_span_minutes": 470,
+    "active_minutes": 62,
+    "pauses": [
+      {
+        "from": "17:18",
+        "to": "19:22",
+        "minutes": 124
+      },
+      {
+        "from": "19:35",
+        "to": "22:16",
+        "minutes": 160
+      },
+      {
+        "from": "22:16",
+        "to": "00:20",
+        "minutes": 124
+      }
+    ],
+    "longest_focus_minutes": 48
+  },
+  "top_dirs": [
+    {
+      "path": "build/mana-swift-core.build/Release",
+      "pct": 19
+    },
+    {
+      "path": "build/SwiftExplicitPrecompiledModules/1HSBLLLL9AUU4",
+      "pct": 15
+    },
+    {
+      "path": "build/SwiftExplicitPrecompiledModules/1KYQZQ1R5RV9Z",
+      "pct": 15
+    },
+    {
+      "path": "build/SwiftExplicitPrecompiledModules/33L8UAO7QRF6J",
+      "pct": 9
+    },
+    {
+      "path": "build/SwiftExplicitPrecompiledModules/1IZ03QLWZJUL2",
+      "pct": 9
+    }
+  ],
+  "top_extensions": [
+    {
+      "ext": ".pcm",
+      "count": 620
+    },
+    {
+      "ext": ".json",
+      "count": 30
+    },
+    {
+      "ext": ".stringsdata",
+      "count": 28
+    },
+    {
+      "ext": ".o",
+      "count": 26
+    },
+    {
+      "ext": ".swift",
+      "count": 22
+    },
+    {
+      "ext": ".modulemap",
+      "count": 8
+    }
+  ],
+  "tags": [
+    "transport"
+  ],
+  "commits_list": [
+    {
+      "hash": "74aee8d",
+      "short": "fix(transport): URL-Konstruktion encoded ?-Query nicht mehr",
+      "type": "fix",
+      "scope": "transport",
+      "additions": 9,
+      "deletions": 1,
+      "timestamp": "2026-05-13T17:18:23+02:00"
+    },
+    {
+      "hash": "716509e",
+      "short": "v1.1.0 — Account-Lifecycle in ManaCore",
+      "type": null,
+      "scope": null,
+      "additions": 1226,
+      "deletions": 36,
+      "timestamp": "2026-05-13T19:22:19+02:00"
+    },
+    {
+      "hash": "3459c78",
+      "short": "v1.1.1 — Session-Token statt JWT für Account-Calls",
+      "type": null,
+      "scope": null,
+      "additions": 68,
+      "deletions": 16,
+      "timestamp": "2026-05-13T19:35:57+02:00"
+    },
+    {
+      "hash": "923b5d0",
+      "short": "v1.2.0 — Guest-Mode + Refresh-Resilience",
+      "type": null,
+      "scope": null,
+      "additions": 647,
+      "deletions": 160,
+      "timestamp": "2026-05-13T22:16:08+02:00"
+    },
+    {
+      "hash": "7526b80",
+      "short": "v1.3.0 — 2FA-Login-Challenge",
+      "type": null,
+      "scope": null,
+      "additions": 294,
+      "deletions": 0,
+      "timestamp": "2026-05-14T00:20:05+02:00"
+    },
+    {
+      "hash": "0a79083",
+      "short": "v1.4.0 — 2FA-Enrollment",
+      "type": null,
+      "scope": null,
+      "additions": 306,
+      "deletions": 0,
+      "timestamp": "2026-05-14T00:38:38+02:00"
+    },
+    {
+      "hash": "fe607c1",
+      "short": "v1.5.0 — getProfile() + ProfileInfo",
+      "type": null,
+      "scope": null,
+      "additions": 2876,
+      "deletions": 0,
+      "timestamp": "2026-05-14T01:06:50+02:00"
+    },
+    {
+      "hash": "216d9f8",
+      "short": "chore: untrack accidentally committed build/ + ignore",
+      "type": null,
+      "scope": null,
+      "additions": 1,
+      "deletions": 2682,
+      "timestamp": "2026-05-14T01:07:55+02:00"
+    }
+  ],
+  "review_state": "auto",
+  "llm": {
+    "model": null,
+    "generated_at": null
+  }
+}

devlog/2026-05-13/macher.md

@@ -0,0 +1,101 @@
+---
+date: 2026-05-13
+day: 2
+view: macher
+weekday: Mittwoch
+commits: 8
+review: written
+---
+# Mittwoch, 2026-05-13 — Tag 2 (Macher-Sicht)
+
+Reifung von v1.0.0 zu v1.5.0 in einer Schicht. Sechs Sinn-Abschnitte
+(Transport-Fix, Account-Lifecycle, Session-Token-Auth, Guest-Mode +
+Refresh-Resilience, 2FA-Login, 2FA-Enrollment, Profile) plus ein
+chore-Cleanup. Build-Verzeichnis war versehentlich committet — am
+Ende des Tages aufgeräumt.
+
+## Stats
+
+8 Commits, +5 427 / −2 895 LoC, 408 Files. **Achtung: 2 682 der
+Deletions kamen aus `chore: untrack build/`** — der eigentliche
+Code-Delta ist eher +2 700 / −200. Top-Dirs sind irreführend (alle
+`build/`-Sub-Dirs), weil der Initial-Push das build/ mit hatte.
+Tags: `transport`. Session 15:18 → 01:08, 62 aktive Minuten in
+4 Blöcken, längster Fokus 48 Min.
+
+## Versions-Schritte
+
+- **Transport-Fix** — URL-Konstruktion encoded `?`-Query nicht mehr.
+  Klassischer Bug: Path-Encoding lief gegen Query-String, dadurch
+  `?from=…` als `%3Ffrom%3D…` rausgeschickt. 9 / −1 Zeilen.
+- **v1.1.0 — Account-Lifecycle.** Change-Email, Change-Password,
+  Account-Delete als public API in ManaCore. ViewModels in
+  mana-swift-ui ziehen morgen nach.
+- **v1.1.1 — Session-Token statt JWT für Account-Calls.**
+  Account-Operationen sind sensibel, brauchen frischen
+  Re-Auth-Token, nicht den allgemeinen JWT.
+- **v1.2.0 — Guest-Mode + Refresh-Resilience.** Wenn ein Refresh
+  mit transienten Errors fehlschlägt (Netz-Timeout, 503), bleibt
+  die Session aktiv und retried. Wenn der Refresh hart 401 macht,
+  fällt der State auf `.guest` zurück statt blind alle Tokens zu
+  wipen. **Das war der wichtigste Fix** — vorher hat mobiles Netz
+  Memoro-User regelmäßig rausgeworfen.
+- **v1.3.0 — 2FA-Login-Challenge.** Wenn Login `requires_2fa: true`
+  zurückgibt, dann zweiter Round-Trip mit Code.
+- **v1.4.0 — 2FA-Enrollment.** Enroll-Init (QR-Secret) + Enroll-
+  Verify + Disable mit Passwort + Backup-Code-Regenerate.
+- **v1.5.0 — getProfile() + ProfileInfo.** Name, E-Mail,
+  Mitgliedsstatus, Tier. +2 876 LoC — viel davon vendored swift-
+  jose-Updates, die für RS256-JWKS-Verify nötig waren.
+- **chore: untrack build/** — `.gitignore` für `build/`, vorhandene
+  Tracked-Files raus.
+
+## Architektur-Entscheidungen
+
+- **Session-Token (kurze TTL) für Account-Calls**, nicht der
+  allgemeine JWT. Begründung: bei Account-Delete oder Email-Change
+  wäre ein gestohlener JWT katastrophal; frischer Session-Token
+  begrenzt das Schaden-Fenster.
+- **Refresh-Resilience: transient vs. permanent.** Transiente
+  Errors (Netz, 503, Timeout) halten Session, retry mit Backoff.
+  Permanente Errors (401, invalid_grant) führen zu `.guest`.
+  Vorher: jede Refresh-Failure → Wipe.
+- **Guest-Mode als eigener State**, nicht „signed-out". Apps
+  können Inhalt anzeigen, der Read-Only ist, ohne dass sie eine
+  Login-Wand zeigen müssen.
+- **2FA-API additiv**, kein Breaking-Change. Apps, die kein 2FA
+  unterstützen, ignorieren `requires_2fa`-Field.
+- **ProfileInfo als eigenes DTO**, nicht in AuthClient verbaut.
+  Profile ist datenzentriert, AuthClient ist State-zentriert.
+- **swift-jose vendored**, statt SPM-Dependency. Public-API-
+  Invariante „keine externen Dependencies" (Compliance-Direktive)
+  bleibt.
+
+## Trade-offs
+
+- **+2 876 LoC für v1.5.0** klingt monströs, ist aber zu 80 %
+  vendored swift-jose. Eigentliche Profile-API ist klein.
+- **Sechs Tags an einem Tag** ist viel — bei strikter Semver wäre
+  das eine Tagesserie, kein Sprint. Akzeptiert, weil jeder Tag
+  einen klar abgegrenzten Sinn-Abschnitt hat.
+- **build/-Verzeichnis untracken nachträglich** war Aufwand
+  (2 682 deletions in einem Commit). Ursache: SwiftPM-CLI legt
+  build/ im Repo-Root an, statt unter DerivedData — `.gitignore`
+  hätte Tag 1 schon gehört.
+- **Session-Token-Mechanik** in v1.1.1 nachgeschoben, weil
+  v1.1.0 das nicht hatte. Hätte v1.1.0 direkt richtig machen
+  sollen; akzeptiert als „erste Lernzyklen".
+
+## Offene Punkte
+
+- **Refresh-Resilience Test-Coverage**: Unit-Tests für transiente
+  vs. permanente Fehler-Pfade existieren, aber kein
+  Real-World-Test (instabiles Netz simulieren).
+- **2FA-Backup-Codes-Storage**: ManaCore liefert sie als Strings
+  zurück; UI muss sie sicher anzeigen + kopierbar machen. Liegt
+  bei mana-swift-ui.
+- **getProfile() Cache-Politik**: derzeit kein Cache. Bei häufigen
+  Calls hilft eine kurze TTL.
+- **Schema-Drift gegen mana-auth**: wenn der Server `ProfileInfo`-
+  Schema ändert, gibt's keinen Wire-Check. Pre-Live-Smoke wäre
+  sinnvoll.

devlog/2026-05-13/spieler.md

@@ -0,0 +1,33 @@
+---
+date: 2026-05-13
+day: 2
+view: spieler
+weekday: Mittwoch
+commits: 8
+review: written
+---
+# Mittwoch, 2026-05-13 — Tag 2
+
+Großer Tag für die Vereins-App-Grundlagen. Was alle Vereins-Apps
+gemeinsam haben — Anmelden, Konto-Verwalten, Profil-Anzeigen — ist
+heute stabiler und reicher geworden. Im Hintergrund.
+
+## Was sich für dich in den Apps ändert
+
+- **Du bleibst eingeloggt, auch wenn das Netz mal schwächelt.**
+  Vorher hat eine wackelige Verbindung manchmal den Login
+  rausgeworfen — neu hält die App durch und versucht es nochmal.
+- **Gast-Modus** ist sauber möglich: Du kannst dir eine App ansehen,
+  bevor du dich anmeldest, ohne dass die App dich abwirft.
+- **Konto-Aktionen funktionieren überall gleich** — E-Mail ändern,
+  Passwort wechseln, Konto löschen.
+- **Zwei-Faktor-Schutz** ist nun durchgängig möglich (Login mit Code,
+  Einrichten in den Einstellungen).
+- **Dein Profil** (Name, E-Mail, Mitgliedsstatus) kann von Apps
+  einheitlich angefragt werden.
+
+## Hintergrund
+
+Diese Sachen baut sonst jede App neu — mit kleinen Unterschieden, die
+Menschen verwirren. Heute lagen sie an einem Ort, getestet, dokumentiert,
+versioniert.