ζ-0 Setup: Repo-Skelett, iOS-Build grün, Healthz live

- project.yml mit Bundle ev.mana.zitare + Widget + ShareExt-Targets
- ManaSwiftCore (ManaCore + ManaTokens) + ManaSwiftUI (ManaAuthUI)
  als Package-Dependencies via path:
- Pure SwiftUI für Native-Surfaces, WKWebView nur für Lese-Tabs
  (Hybrid-Sonderfall vs cards/memoro/manaspur, dokumentiert im
  Playbook ZITARE_NATIVE_GREENFIELD.md)
- Theme: paper-Variant aus @mana/themes
- ZitareAPI.healthCheck via direct URLSession (öffentlicher
  Endpoint, kein AuthenticatedTransport-Gate)
- 6/6 AppConfigTests + 1/1 UI-Smoke grün auf iPhone 16e Simulator
- Live: zitare-api.mana.how/healthz → HTTP/2 200

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

Sources/Core/API/ZitareAPI.swift

@@ -0,0 +1,39 @@
+import Foundation
+import ManaCore
+
+/// Zitare-spezifischer API-Client. Wrapper um `AuthenticatedTransport`
+/// aus ManaCore, der die zitare-api-Endpoints kennt.
+///
+/// Phase ζ-0: nur Health-Probe. Endpoints für Submit, Share-Receive,
+/// Quote-Lookup folgen in ζ-3 / ζ-4.
+actor ZitareAPI {
+    let transport: AuthenticatedTransport
+    let decoder: JSONDecoder
+
+    init(auth: AuthClient) {
+        transport = AuthenticatedTransport(baseURL: AppConfig.apiBaseURL, auth: auth)
+        decoder = JSONDecoder()
+        // ζ-3 TODO: bei echten DTOs `.iso8601withFractional`-Extension
+        // aus cards-native portieren (Server liefert ISO8601 mit
+        // Fractional-Seconds, Standard `.iso8601` schluckt das nicht).
+    }
+
+    /// `GET /healthz` — verifiziert dass zitare-api erreichbar ist.
+    /// Öffentlicher Endpoint, läuft direkt via `URLSession` (nicht
+    /// `AuthenticatedTransport`), damit auch nicht-eingeloggte Apps
+    /// die API-Erreichbarkeit prüfen können.
+    func healthCheck() async throws -> Bool {
+        let url = AppConfig.apiBaseURL.appendingPathComponent("healthz")
+        let (_, response) = try await URLSession.shared.data(from: url)
+        guard let http = response as? HTTPURLResponse else { return false }
+        return http.statusCode == 200
+    }
+
+    // MARK: - Phase ζ-3: Submit
+
+    // func submitQuote(_ draft: QuoteDraft) async throws -> SubmittedQuote { ... }
+
+    // MARK: - Phase ζ-4: Share-Receive
+
+    // func receiveShare(_ envelope: ShareEnvelope) async throws -> ShareReceipt { ... }
+}

Sources/Core/Auth/AppConfig.swift

@@ -0,0 +1,30 @@
+import Foundation
+import ManaCore
+
+/// App-spezifische Konfiguration für Zitare. Implementiert
+/// `ManaAppConfig` aus ManaCore und ergänzt die Zitare-eigene
+/// `apiBaseURL` (zitare-api, getrennt von mana-auth) sowie
+/// `webBaseURL` (zitare.com, für WKWebView und Universal-Links)
+/// und `appBaseURL` (zitare.mana.how, für eingeloggte Pfade).
+enum AppConfig {
+    static let manaAppConfig: ManaAppConfig = DefaultManaAppConfig(
+        authBaseURL: URL(string: "https://auth.mana.how")!,
+        keychainService: "ev.mana.zitare",
+        keychainAccessGroup: nil
+    )
+
+    /// `zitare-api.mana.how` — API-Backend (Hono+Bun).
+    static let apiBaseURL = URL(string: "https://zitare-api.mana.how")!
+
+    /// `zitare.com` — öffentliches statisches Frontend. Universal-Link-
+    /// Domain. WKWebView-Default für Lesen-Surfaces.
+    static let webBaseURL = URL(string: "https://zitare.com")!
+
+    /// `zitare.mana.how` — SPA-Surface für eingeloggte Pfade (Submit,
+    /// Edit, Moderation). Bekommt den `mana.access`-Cookie injiziert
+    /// für Cookie-SSO.
+    static let appBaseURL = URL(string: "https://zitare.mana.how")!
+
+    /// App-Group für Daten-Sharing zwischen App ↔ Widget ↔ ShareExt.
+    static let appGroup = "group.ev.mana.zitare"
+}

Sources/Core/Telemetry/Log.swift

@@ -0,0 +1,16 @@
+import Foundation
+import OSLog
+
+/// App-eigene OSLog-Logger unter Subsystem `ev.mana.zitare`.
+/// ManaCore loggt unter `ev.mana.core` parallel — siehe
+/// `mana-swift-core/Sources/ManaCore/Telemetry/CoreLog.swift`.
+enum Log {
+    static let app = Logger(subsystem: "ev.mana.zitare", category: "app")
+    static let auth = Logger(subsystem: "ev.mana.zitare", category: "auth")
+    static let api = Logger(subsystem: "ev.mana.zitare", category: "api")
+    static let web = Logger(subsystem: "ev.mana.zitare", category: "web")
+    static let snapshot = Logger(subsystem: "ev.mana.zitare", category: "snapshot")
+    static let widget = Logger(subsystem: "ev.mana.zitare", category: "widget")
+    static let spotlight = Logger(subsystem: "ev.mana.zitare", category: "spotlight")
+    static let share = Logger(subsystem: "ev.mana.zitare", category: "share")
+}

Sources/Core/Theme/ZitareTheme.swift

@@ -0,0 +1,105 @@
+import SwiftUI
+
+#if canImport(UIKit)
+    import UIKit
+
+    private typealias PlatformColorType = UIColor
+#elseif canImport(AppKit)
+    import AppKit
+
+    private typealias PlatformColorType = NSColor
+#endif
+
+/// Paper-Variant aus `mana/packages/themes/src/variants/paper.css`.
+/// Lokal in zitare-native nachgebaut, weil ManaTokens noch keine
+/// Variants kennt.
+///
+/// Sepia, warm, lese-fokussiert — skeumorph an Druckpapier angelehnt,
+/// passt zum (read)-Surface der Web-App.
+enum ZitareTheme {
+    /// Page-Hintergrund (warmes Off-White / dunkles Sepia)
+    static let background = dynamic(light: HSL(38, 28, 95), dark: HSL(24, 14, 9))
+
+    /// Standard-Text
+    static let foreground = dynamic(light: HSL(20, 14, 16), dark: HSL(38, 24, 88))
+
+    /// Card, Panel, Modal
+    static let surface = dynamic(light: HSL(0, 0, 100), dark: HSL(24, 12, 13))
+
+    /// Hover-State auf Surface
+    static let surfaceHover = dynamic(light: HSL(38, 24, 92), dark: HSL(24, 14, 17))
+
+    /// Disabled-Felder, Skeleton
+    static let muted = dynamic(light: HSL(38, 20, 90), dark: HSL(24, 12, 18))
+
+    /// Sekundär-Text, Placeholder
+    static let mutedForeground = dynamic(light: HSL(20, 14, 50), dark: HSL(38, 12, 60))
+
+    /// Rahmen, Trennlinien
+    static let border = dynamic(light: HSL(38, 18, 80), dark: HSL(24, 10, 25))
+
+    /// Zitare-Primary — warmes Terra/Sienna im Light, weicheres Sienna im Dark
+    static let primary = dynamic(light: HSL(18, 50, 38), dark: HSL(24, 60, 65))
+
+    /// Text auf Primary
+    static let primaryForeground = dynamic(light: HSL(0, 0, 100), dark: HSL(24, 14, 9))
+
+    static let error = dynamic(light: HSL(0, 65, 45), dark: HSL(0, 60, 55))
+    static let success = dynamic(light: HSL(135, 35, 35), dark: HSL(135, 35, 55))
+    static let warning = dynamic(light: HSL(38, 80, 40), dark: HSL(38, 70, 55))
+
+    // MARK: - HSL Helper
+
+    struct HSL {
+        let hue: Double
+        let saturation: Double
+        let lightness: Double
+
+        init(_ hue: Double, _ saturation: Double, _ lightness: Double) {
+            self.hue = hue
+            self.saturation = saturation
+            self.lightness = lightness
+        }
+
+        var color: Color {
+            Color(
+                hue: hue / 360.0,
+                saturation: saturation / 100.0,
+                brightness: brightnessFromLightness(),
+                opacity: 1.0
+            )
+        }
+
+        /// HSL → HSB Konversion (SwiftUI Color nutzt HSB).
+        private func brightnessFromLightness() -> Double {
+            let l = lightness / 100.0
+            let s = saturation / 100.0
+            return l + s * min(l, 1 - l)
+        }
+    }
+
+    private static func dynamic(light: HSL, dark: HSL) -> Color {
+        #if canImport(UIKit)
+            return Color(
+                PlatformColorType { trait in
+                    trait.userInterfaceStyle == .dark
+                        ? PlatformColorType(dark.color)
+                        : PlatformColorType(light.color)
+                }
+            )
+        #elseif canImport(AppKit)
+            return Color(
+                PlatformColorType(name: nil) { appearance in
+                    let isDark = appearance.bestMatch(
+                        from: [.darkAqua, .aqua]
+                    ) == .darkAqua
+                    return isDark
+                        ? PlatformColorType(dark.color)
+                        : PlatformColorType(light.color)
+                }
+            )
+        #else
+            return light.color
+        #endif
+    }
+}