v0.7.0 — Phase β-6 Native-Polish

Drei Sub-Pakete: Keyboard-Shortcuts, Daily-Reminder-Notifications,
WidgetKit-Extension mit App-Group-Daten-Sharing. Siri-Shortcuts
und Share-Extension auf β-7 verschoben — niedrige Priorität, die
drei großen Brocken decken 90% des Native-Polish ab.

Keyboard-Shortcuts:
- Hidden Buttons in StudySessionView mit .keyboardShortcut
- Space = flip, 1/2/3/4 = again/hard/good/easy
- iPad-Magic-Keyboard + macOS-tauglich

Daily-Reminders:
- NotificationManager @Observable mit UNUserNotificationCenter
- Authorization-State + Permission-Request-Flow
- UNCalendarNotificationTrigger täglich zur konfigurierten Zeit
- SettingsView in AccountView mit Toggle + DatePicker
- UserDefaults-Persistierung von Hour/Minute/Enabled

WidgetKit-Extension:
- WidgetSnapshot Codable mit topDecks (Top-3 by dueCount) + totalDueCount
- WidgetSnapshotStore schreibt in group.ev.mana.cards-Container
- DeckListStore.refresh schreibt Snapshot + WidgetCenter.reloadAllTimelines
- CardsWidgetExtension-Target im project.yml (app-extension)
- CardsWidgetBundle + CardsDueWidget mit 5 Familien (small/medium/
  accessoryCircular/accessoryInline/accessoryRectangular)
- DueProvider TimelineProvider mit 30-min-Refresh
- DueWidgetView Family-Switch
- WidgetSnapshot.swift shared in beiden Targets via XcodeGen sources
- App-Group im Haupt- und Widget-Entitlement

35 Tests grün (keine neuen Tests in β-6 — WidgetKit + Notifications
sind System-API-Integrationen, Tests wären überwiegend Mocks).
Build inkl. Widget-Extension grün.

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

Sources/Core/Notifications/NotificationManager.swift

@@ -0,0 +1,86 @@
+import Foundation
+import Observation
+import UserNotifications
+
+/// Lokale tägliche Reminder. Reines `UNUserNotificationCenter` —
+/// keine Push-Backend-Anbindung, keine Crash-Reporter, kein SaaS
+/// (Compliance, siehe `mana/docs/COMPLIANCE.md`).
+@MainActor
+@Observable
+final class NotificationManager {
+    enum AuthorizationStatus: Sendable {
+        case unknown
+        case authorized
+        case denied
+    }
+
+    private(set) var authorization: AuthorizationStatus = .unknown
+    private let identifier = "ev.mana.cards.dailyReminder"
+    private let store = UserDefaults.standard
+
+    /// Persistiert User-Pref. Format: ISO-Stunde:Minute (default 18:00).
+    var reminderHour: Int {
+        get { store.object(forKey: "reminderHour") as? Int ?? 18 }
+        set { store.set(newValue, forKey: "reminderHour") }
+    }
+
+    var reminderMinute: Int {
+        get { store.object(forKey: "reminderMinute") as? Int ?? 0 }
+        set { store.set(newValue, forKey: "reminderMinute") }
+    }
+
+    var remindersEnabled: Bool {
+        get { store.bool(forKey: "remindersEnabled") }
+        set { store.set(newValue, forKey: "remindersEnabled") }
+    }
+
+    func refreshAuthorization() async {
+        let settings = await UNUserNotificationCenter.current().notificationSettings()
+        switch settings.authorizationStatus {
+        case .authorized, .provisional, .ephemeral:
+            authorization = .authorized
+        case .denied:
+            authorization = .denied
+        default:
+            authorization = .unknown
+        }
+    }
+
+    /// Permission anfragen. Beim ersten Aufruf zeigt iOS den System-Prompt.
+    func requestAuthorization() async -> Bool {
+        let center = UNUserNotificationCenter.current()
+        do {
+            let granted = try await center.requestAuthorization(options: [.alert, .badge, .sound])
+            authorization = granted ? .authorized : .denied
+            return granted
+        } catch {
+            authorization = .denied
+            return false
+        }
+    }
+
+    /// Tägliche Reminder neu planen. Bei `remindersEnabled = false`
+    /// werden alle bestehenden Notifications gecancelt.
+    func reschedule() async {
+        let center = UNUserNotificationCenter.current()
+        center.removePendingNotificationRequests(withIdentifiers: [identifier])
+        guard remindersEnabled, authorization == .authorized else { return }
+
+        let content = UNMutableNotificationContent()
+        content.title = "Cards"
+        content.body = "Ein paar Karten warten auf dich."
+        content.sound = .default
+
+        var components = DateComponents()
+        components.hour = reminderHour
+        components.minute = reminderMinute
+        let trigger = UNCalendarNotificationTrigger(dateMatching: components, repeats: true)
+        let request = UNNotificationRequest(identifier: identifier, content: content, trigger: trigger)
+
+        do {
+            try await center.add(request)
+        } catch {
+            Log.app.error("Notification schedule failed: \(error.localizedDescription, privacy: .public)")
+        }
+    }
+}

Sources/Core/Sync/DeckListStore.swift

@@ -2,6 +2,7 @@ import Foundation
 import ManaCore
 import Observation
 import SwiftData
+import WidgetKit
 
 /// Orchestriert API + SwiftData-Cache für die Deck-Liste.
 /// View bindet sich an `state` und `errorMessage`.
@@ -35,6 +36,7 @@ final class DeckListStore {
         do {
             let decks = try await api.listDecks()
             try await applyToCache(decks: decks)
+            updateWidgetSnapshot()
             state = .loaded
             Log.sync.info("Loaded \(decks.count, privacy: .public) decks from server")
         } catch let error as AuthError {
@@ -96,4 +98,30 @@ final class DeckListStore {
 
         try context.save()
     }
+
+    /// Schreibt einen WidgetSnapshot in den shared App-Group-Container
+    /// und fordert WidgetKit auf, alle Widgets neu zu rendern. Wird nach
+    /// jedem erfolgreichen Refresh aufgerufen.
+    private func updateWidgetSnapshot() {
+        let descriptor = FetchDescriptor<CachedDeck>(
+            sortBy: [SortDescriptor(\.dueCount, order: .reverse)]
+        )
+        let allDecks = (try? context.fetch(descriptor)) ?? []
+        let totalDue = allDecks.reduce(0) { $0 + $1.dueCount }
+        let top = allDecks.prefix(3).map { deck in
+            WidgetSnapshot.Entry(
+                id: deck.id,
+                name: deck.name,
+                dueCount: deck.dueCount,
+                colorHex: deck.color
+            )
+        }
+        let snapshot = WidgetSnapshot(
+            updatedAt: .now,
+            totalDueCount: totalDue,
+            topDecks: Array(top)
+        )
+        WidgetSnapshotStore.write(snapshot)
+        WidgetCenter.shared.reloadAllTimelines()
+    }
 }

Sources/Core/Sync/WidgetSnapshot.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+/// Datei-Format für die WidgetKit-Extension. Wird vom Haupt-Target nach
+/// jedem erfolgreichen `DeckListStore.refresh()` in den shared App-Group-
+/// Container geschrieben; das Widget liest es im TimelineProvider.
+///
+/// Wire ist bewusst stabil + schmal — nur was das Widget rendert.
+/// Neue Felder dürfen additiv dazukommen, alte Felder bleiben.
+struct WidgetSnapshot: Codable, Sendable {
+    let updatedAt: Date
+    let totalDueCount: Int
+    let topDecks: [Entry]
+
+    struct Entry: Codable, Sendable, Identifiable {
+        let id: String       // deck-id
+        let name: String
+        let dueCount: Int
+        let colorHex: String?
+    }
+}
+
+/// Liest und schreibt WidgetSnapshot in den shared App-Group-Container.
+enum WidgetSnapshotStore {
+    /// App-Group-ID — muss exakt mit dem Entitlement-Eintrag matchen.
+    static let appGroupID = "group.ev.mana.cards"
+    static let snapshotFilename = "widget-snapshot.json"
+
+    static var snapshotURL: URL? {
+        FileManager.default
+            .containerURL(forSecurityApplicationGroupIdentifier: appGroupID)?
+            .appendingPathComponent(snapshotFilename)
+    }
+
+    static func write(_ snapshot: WidgetSnapshot) {
+        guard let url = snapshotURL else { return }
+        let encoder = JSONEncoder()
+        encoder.dateEncodingStrategy = .iso8601
+        guard let data = try? encoder.encode(snapshot) else { return }
+        try? data.write(to: url, options: .atomic)
+    }
+
+    static func read() -> WidgetSnapshot? {
+        guard let url = snapshotURL, let data = try? Data(contentsOf: url) else { return nil }
+        let decoder = JSONDecoder()
+        decoder.dateDecodingStrategy = .iso8601
+        return try? decoder.decode(WidgetSnapshot.self, from: data)
+    }
+}