Das Wetter sah nur einmal je Programmstart nach

Der Abruf hing an `task` der View — und die erscheint bei einem Panel, das
immer existiert, ein einziges Mal. Wer Onyx tagelang laufen lässt, sieht
tagelang dieselbe Temperatur. Gemessen: der Zwischenspeicher trug den Stand
vom 14. August, 15:17, und stand am 17. um 23:13 unverändert da — nachts
35 Grad, weil sie vom Nachmittag drei Tage vorher stammten.

Jetzt sieht das Modell im Takt der Haltbarkeit nach, also alle fünfzehn
Minuten. Teurer wird es dadurch nicht: `load` fragt nur nach, wenn der
gespeicherte Stand abgelaufen ist. Und der Ort wird dabei neu bestimmt — beim
Wechsel der Stadt stand sonst weiter das Wetter der alten da. Genau das war
hier zu sehen: Lemgo, längst verlassen.

Dazu die zweite Hälfte des Fehlers: ein „fertiger" Stand wurde immer als
frisch gezeichnet, egal wie alt er war. Warnzeichen und Zeitstempel gab es nur
bei einem gescheiterten Abruf. Ein Messwert gilt jetzt ab einer Stunde als
alt — großzügiger als die Haltbarkeit, damit ein einzelner verpasster Abruf
noch keine Warnung auslöst.

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

Packages/OnyxKit/Sources/WeatherProvider/WeatherCache.swift

@@ -11,6 +11,14 @@ public struct WeatherCache: Sendable {
     /// Wie lange ein Stand als aktuell gilt.
     public static let maxAge: TimeInterval = 15 * 60
 
+    /// Ab wann ein Messwert nicht mehr als aktuell durchgeht.
+    ///
+    /// Großzügiger als die Haltbarkeit: dass ein Abruf einmal danebengeht und
+    /// der Wert zwanzig Minuten alt ist, muss keine Warnung wert sein. Eine
+    /// Stunde altes Wetter dagegen schon — spätestens dann stimmt die
+    /// Temperatur nicht mehr mit dem überein, was man vor dem Fenster sieht.
+    public static let staleAge: TimeInterval = 60 * 60
+
     private var entries: [String: WeatherSnapshot] = [:]
     private let url: URL?
 

Packages/OnyxKit/Sources/WeatherProvider/WeatherModels.swift

@@ -71,6 +71,14 @@ public struct WeatherAttribution: Equatable, Sendable, Codable {
 }
 
 public struct WeatherSnapshot: Equatable, Sendable, Codable {
+
+    /// Ob ein Messwert nicht mehr als aktuell durchgeht.
+    ///
+    /// Die Prüfung liegt hier und nicht in der View: sie entscheidet, ob eine
+    /// Warnung erscheint, und das ist eine Regel, keine Darstellung.
+    public static func isStale(asOf: Date, now: Date = Date()) -> Bool {
+        now.timeIntervalSince(asOf) > WeatherCache.staleAge
+    }
     public let placeName: String
     public let temperature: Measurement<UnitTemperature>
     public let apparentTemperature: Measurement<UnitTemperature>

Packages/OnyxKit/Sources/WeatherProvider/WeatherWidget.swift

@@ -34,6 +34,8 @@ public final class WeatherModel {
     private let defaults: UserDefaults
     private var cache = WeatherCache()
     private var task: Task<Void, Never>?
+    /// Der Takt, in dem nachgesehen wird.
+    private var timer: Timer?
 
     public init(source: WeatherKitSource = WeatherKitSource(),
                 defaults: UserDefaults = .standard) {
@@ -80,6 +82,8 @@ public final class WeatherModel {
     /// Panels. WeatherKit rechnet nach Abrufen ab, und das Wetter ändert sich
     /// nicht im Sekundentakt.
     public func load(force: Bool = false) {
+        startTimerIfNeeded()
+
         if !force, let fresh = cache.valid(for: place) {
             state = .ready(fresh)
             return
@@ -113,9 +117,32 @@ public final class WeatherModel {
         }
     }
 
+    /// Sieht regelmäßig nach.
+    ///
+    /// **Ohne das lud das Widget genau einmal je Programmstart.** Der Aufruf
+    /// hing an `task` der View, und die erscheint bei einem Panel, das immer
+    /// existiert, ein einziges Mal. Wer Onyx tagelang laufen lässt, sah
+    /// tagelang dieselbe Temperatur — nachts 35 Grad, weil sie vom Nachmittag
+    /// des Vortags stammte.
+    ///
+    /// Der Takt entspricht der Haltbarkeit des Zwischenspeichers. Teurer wird
+    /// es dadurch nicht: `load` fragt nur nach, wenn der gespeicherte Stand
+    /// abgelaufen ist. Und der Ort wird dabei neu bestimmt — wer die Stadt
+    /// wechselt, sieht sonst weiter das Wetter der alten.
+    private func startTimerIfNeeded() {
+        guard timer == nil else { return }
+        let timer = Timer(timeInterval: WeatherCache.maxAge, repeats: true) { [weak self] _ in
+            Task { @MainActor in self?.load() }
+        }
+        RunLoop.main.add(timer, forMode: .common)
+        self.timer = timer
+    }
+
     public func stop() {
         task?.cancel()
         task = nil
+        timer?.invalidate()
+        timer = nil
     }
 
     /// Sucht die Koordinaten zu einem Ortsnamen und übernimmt ihn.
@@ -159,7 +186,11 @@ private struct WeatherWidgetView: View {
         Group {
             switch model.state {
             case .ready(let snapshot):
-                content(snapshot, isStale: false)
+                // Auch ein „fertiger" Stand kann alt sein — dann ist er als
+                // solcher zu kennzeichnen. Genau das fehlte: drei Tage alte
+                // 35 Grad standen um elf Uhr nachts da, als wären sie eben
+                // gemessen worden.
+                content(snapshot, isStale: WeatherSnapshot.isStale(asOf: snapshot.asOf))
             case .unavailable(let lastKnown, _):
                 if let lastKnown {
                     content(lastKnown, isStale: true)

Packages/OnyxKit/Tests/WeatherProviderTests/StalenessTests.swift

@@ -0,0 +1,40 @@
+import Testing
+import Foundation
+@testable import WeatherProvider
+
+@Suite("Alter eines Messwerts")
+struct StalenessTests {
+
+    private let now = Date(timeIntervalSince1970: 1_800_000_000)
+
+    @Test("Frisch Gemessenes ist nicht alt")
+    func freshIsNotStale() {
+        #expect(!WeatherSnapshot.isStale(asOf: now.addingTimeInterval(-60), now: now))
+    }
+
+    @Test("Ein missglückter Abruf macht noch keine Warnung")
+    func aMissedFetchIsTolerated() {
+        // Zwanzig Minuten sind über der Haltbarkeit, aber kein Grund für ein
+        // Warnzeichen — sonst steht es bei jedem verpassten Abruf da.
+        #expect(!WeatherSnapshot.isStale(asOf: now.addingTimeInterval(-20 * 60), now: now))
+    }
+
+    @Test("Nach einer Stunde ist es alt")
+    func anHourIsStale() {
+        #expect(WeatherSnapshot.isStale(asOf: now.addingTimeInterval(-61 * 60), now: now))
+    }
+
+    @Test("Der Fall aus der Praxis: drei Tage")
+    func threeDaysIsStale() {
+        // Nachts um elf standen 35 Grad da, gemessen am Nachmittag drei Tage
+        // vorher — und nichts wies darauf hin.
+        #expect(WeatherSnapshot.isStale(asOf: now.addingTimeInterval(-3 * 86400), now: now))
+    }
+
+    @Test("Die Haltbarkeit ist kürzer als die Warnschwelle")
+    func cacheExpiresBeforeItWarns() {
+        // Sonst wäre jeder abgelaufene Eintrag zugleich ein Warnfall, und die
+        // Warnung sagte nichts mehr aus.
+        #expect(WeatherCache.maxAge < WeatherCache.staleAge)
+    }
+}