Flixy heißt ab hier Halo

Reine Umbenennung, kein Verhalten geändert — bewusst als eigener Commit,
damit „umbenannt" und „umgebaut" im Nachhinein auseinanderzuhalten sind.

712 mal `Flixy`, 778 mal `flixy`, 7 mal `FLIXY` in 169 Dateien, dazu 25
Pfade. Ziele: `Halo`, `HaloTV`, `HaloTopShelf`, `HaloUITests`, `HaloKit` mit
`HaloDesign`, `HaloDownloads`, `HaloPlayback` und `HaloProbe`. `MediaKit`,
`JellyfinKit` und `DownloadWidget` tragen den Namen nicht und bleiben.

`docs/superpowers/specs/` ist ausgenommen. Datierte Entwurfsdokumente sind
ein Protokoll getroffener Entscheidungen; sie nachträglich umzuschreiben
hiesse, die Vergangenheit zu glätten.

**Die Bundle-ID wandert mit** — ausdrücklich so gewollt, mit bekanntem Preis:
`com.scarriffleservices.halo` ist für iOS eine *andere* App. Die installierte
Fassung bleibt daneben stehen, mit Downloads und Anmeldung in ihrem Container;
Halo startet leer. Einmal neu anmelden, heruntergeladene Folgen einmal neu
laden. Dasselbe gilt für die App-Gruppe, die sich TV-App und Top Shelf teilen.

**Eine Folge davon, die beim Entscheiden noch nicht auf dem Tisch lag:** der
Aufräumschritt aus dem vorigen Commit kommt an die alten Plex-Token nicht mehr
heran. Der Schlüsselbund grenzt nach Team und Bundle-Kennung ab — was unter
`…flixy` liegt, ist für `…halo` unerreichbar. Erledigt wird es trotzdem, nur
anders: **die alte App löschen.** iOS räumt deren Schlüsselbund-Einträge beim
Deinstallieren mit ab. Der Code bleibt stehen, weil er für jeden Stand vor
dieser Umbenennung richtig ist und im Jahr einen Startvergleich kostet.

Die Projektdatei ist aus `project.yml` neu erzeugt, der alte Ordner gelöscht
statt umbenannt — sie steht ohnehin nicht im Repo.

Das Verzeichnis des Repos selbst heißt weiter `Flixy`; das umzubenennen ist
ein Handgriff ausserhalb des Projekts.

368 Tests grün. iOS und tvOS bauen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Packages/HaloKit/Sources/HaloDownloads/Engine/DownloadActivityPresenter.swift

@@ -0,0 +1,79 @@
+import Foundation
+
+// Catalyst ausdrücklich ausgenommen: dort gilt `os(iOS)`, aber ActivityKit
+// gibt es nicht — die Typen sind zwar da und jeder Aufruf ist als nicht
+// verfügbar markiert.
+#if os(iOS) && !targetEnvironment(macCatalyst)
+// `@preconcurrency`, weil `Activity` und `ActivityContent` keine
+// Sendable-Zusage tragen. Beide bleiben hier ohnehin auf dem Hauptakteur —
+// die Klasse ist darauf festgelegt, und ActivityKit erwartet seine Aufrufe
+// von dort. Ohne diese Zeile lehnt Swift 6 jeden Aufruf ab.
+@preconcurrency import ActivityKit
+
+/// Zeigt den Download-Fortschritt im Sperrbildschirm.
+///
+/// Getrennt vom Koordinator, weil Live Activities eine Reihe eigener Fallen
+/// haben — sie können vom Nutzer abgeschaltet sein, ihre Zahl ist begrenzt,
+/// und eine nicht beendete Activity bleibt stundenlang stehen. Der Koordinator
+/// meldet nur „das läuft gerade"; was daraus wird, entscheidet sich hier.
+@MainActor
+public final class DownloadActivityPresenter {
+    private var activity: Activity<DownloadActivityAttributes>?
+    /// Wann zuletzt aktualisiert wurde.
+    ///
+    /// ActivityKit drosselt häufige Aktualisierungen und verwirft sie
+    /// irgendwann kommentarlos. Der Fortschritt kommt mehrmals je Sekunde —
+    /// ungebremst weitergereicht bliebe die Anzeige irgendwann stehen.
+    private var lastUpdate = Date.distantPast
+    private let minimumInterval: TimeInterval = 1.5
+
+    public init() {}
+
+    /// Bringt die Anzeige auf den neuesten Stand.
+    ///
+    /// `nil` beendet sie — das ist der Fall, wenn nichts mehr läuft.
+    /// `async`, nicht `Task { … }` im Inneren: `Activity` und
+    /// `ActivityContent` sind nicht `Sendable`, und eine Aufgabe würde sie über
+    /// die Isolationsgrenze schicken. So bleibt alles auf dem Hauptakteur.
+    public func update(with state: DownloadActivityAttributes.ContentState?) async {
+        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
+
+        guard let state else {
+            await end()
+            return
+        }
+
+        if let activity {
+            guard Date().timeIntervalSince(lastUpdate) >= minimumInterval else { return }
+            lastUpdate = Date()
+            await activity.update(ActivityContent(state: state, staleDate: nil))
+        } else {
+            start(with: state)
+        }
+    }
+
+    private func start(with state: DownloadActivityAttributes.ContentState) {
+        do {
+            activity = try Activity.request(
+                attributes: DownloadActivityAttributes(),
+                content: ActivityContent(state: state, staleDate: nil)
+            )
+            lastUpdate = Date()
+        } catch {
+            // Scheitert meist, weil die Höchstzahl gleichzeitiger Activities
+            // erreicht ist. Kein Grund, den Download anzuhalten — die Anzeige
+            // ist Beiwerk.
+            activity = nil
+        }
+    }
+
+    /// Beendet die Anzeige.
+    public func end() async {
+        guard let activity else { return }
+        self.activity = nil
+        // `.immediate`: eine Download-Anzeige, die nach dem letzten Byte noch
+        // eine Viertelstunde im Sperrbildschirm klebt, ist Müll.
+        await activity.end(nil, dismissalPolicy: .immediate)
+    }
+}
+#endif