Optimize snapshot detail caching · e112cd0

Optimize snapshot detail caching
Browse files

bogdan committed 3 weeks ago

main

1 parent 7128827

commit e112cd0

Showing 19 changed files with 1219 additions and 413 deletions

+12 -0

AGENTS.md

@@ -152,6 +152,18 @@ final class TypeDistributionBin {
 // snapshot to contain real changes for some metrics while long-stable metrics behave
 // as temporal aliases and skip per-type detail cache/diff work.
 
+// Interface updated 2026-05-17 — see AGENTS.md
+// Models/HealthSnapshot stores cached overview scalars for UI consumption:
+// tracked type count, aggregate record count, and overall oldest/newest record dates.
+// These values must be computed during snapshot save while TypeCount data is already
+// in memory, so snapshot list/detail screens never recompute them by traversing
+// snapshot.typeCounts on the UI thread.
+
+// Interface updated 2026-05-17 — see AGENTS.md
+// Models/SnapshotDelta stores cached list/detail summary scalars derived from TypeDelta.
+// Overview screens consume these scalars and type-delta summaries directly instead of
+// recalculating per-snapshot changes from HealthSnapshot.typeCounts.
+
 // Models/DetectedAnomaly.swift
 enum AnomalyType: String, Codable {
     case historicalInsertion = "historical_insertion"


+1 -48

HealthProbe/ContentView.swift

View

+                     import SwiftData
+                     struct ContentView: View {
+                    -    @Environment(\.modelContext) private var modelContext
+                    -    @AppStorage(AppSettings.typeDetailCacheBackfillVersionKey)
+                    -    private var typeDetailCacheBackfillVersion: Int = 0
+                    -    @State private var didAttemptTypeDetailCacheBackfill = false
+                         var body: some View {
+                             TabView {
+                                 Tab("Dashboard", systemImage: "waveform.path.ecg") {
+                                     SettingsView()
+                    -        .task {
+                    -            await rebuildTypeDetailCachesIfNeeded()
+                    -        }
+                    -    }
+                    -    @MainActor
+                    -    private func rebuildTypeDetailCachesIfNeeded() async {
+                    -        guard !didAttemptTypeDetailCacheBackfill,
+                    -              typeDetailCacheBackfillVersion < AppSettings.currentTypeDetailCacheBackfillVersion else {
+                    -            return
+                    -        }
+                    -        didAttemptTypeDetailCacheBackfill = true
+                    -        try? await Task.sleep(for: .seconds(2))
+                    -        MemoryLog.log("typeDetailCacheBackfill.begin", metadata: [
+                    -            "storedVersion": "\(typeDetailCacheBackfillVersion)",
+                    -            "targetVersion": "\(AppSettings.currentTypeDetailCacheBackfillVersion)"
+                    -        ])
+                    -        let memoryPulse = MemoryLog.startPulse("typeDetailCacheBackfill", metadata: [
+                    -            "maxTypeCounts": "1"
+                    -        ])
+                    -        defer {
+                    -            memoryPulse.cancel()
+                    -            MemoryLog.log("typeDetailCacheBackfill.end", metadata: [
+                    -                "storedVersion": "\(typeDetailCacheBackfillVersion)"
+                    -            ])
+                    -        }
+                    -        do {
+                    -            let isComplete = try SnapshotLifecycleService.rebuildMissingDetailCaches(
+                    -                context: modelContext,
+                    -                maxTypeCounts: 1
+                    -            )
+                    -            MemoryLog.log("typeDetailCacheBackfill.result", metadata: [
+                    -                "isComplete": "\(isComplete)"
+                    -            ])
+                    -            if isComplete {
+                    -                typeDetailCacheBackfillVersion = AppSettings.currentTypeDetailCacheBackfillVersion
+                    -            }
+                    -        } catch {
+                    -            assertionFailure("Failed to rebuild type detail caches: \(error)")
+                    -        }
+                     #Preview {
+                         ContentView()
+                    -        .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
+                    +    .modelContainer(for: [HealthSnapshot.self, SnapshotDelta.self, TypeDelta.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
+                             .environment(AppSettings())

+18 -3

HealthProbe/Models/HealthRecord.swift

View

@@ -14,6 +14,21 @@ struct HealthRecordValue: Codable, Hashable, Identifiable, Sendable {
 enum HealthRecordArchive {
     private static let compactMagic = Data([0x48, 0x50, 0x52, 0x41, 0x32]) // HPRA2
 
+    static func isCompact(_ data: Data) -> Bool {
+        data.starts(with: compactMagic)
+    }
+
+    static func compactedIfNeeded(_ data: Data) -> Data? {
+        if isCompact(data) {
+            return data
+        }
+
+        guard let decoded = decode(data) else {
+            return nil
+        }
+        return encode(decoded)
+    }
+
     static func encode(_ values: [HealthRecordValue]) -> Data? {
         guard let typeIdentifier = values.first?.typeIdentifier else {
             return encodeCompact(typeIdentifier: "", values: [])
@@ -29,7 +44,7 @@ enum HealthRecordArchive {
     }
 
     static func forEachRecord(in data: Data, _ body: (HealthRecordValue) -> Void) -> Bool {
-        if data.starts(with: compactMagic) {
+        if isCompact(data) {
             return forEachCompactRecord(in: data, body)
         }
 
@@ -47,9 +62,9 @@ enum HealthRecordArchive {
 
         MemoryLog.log("healthRecordArchive.fingerprintSet.begin", metadata: [
             "archive": MemoryLog.format(UInt64(data.count)),
-            "format": data.starts(with: compactMagic) ? "compact" : "plist"
+            "format": isCompact(data) ? "compact" : "plist"
         ])
-        if data.starts(with: compactMagic) {
+        if isCompact(data) {
             let fingerprints = compactFingerprintSet(from: data)
             MemoryLog.log("healthRecordArchive.fingerprintSet.end", metadata: [
                 "archive": MemoryLog.format(UInt64(data.count)),


+45 -0

HealthProbe/Models/HealthSnapshot.swift

View

@@ -1,6 +1,7 @@
 import Foundation
 import SwiftData
 
+// Interface updated 2026-05-17 — see AGENTS.md
 @Model final class HealthSnapshot {
     var id: UUID = UUID()
     var timestamp: Date = Date.now
@@ -24,6 +25,11 @@ import SwiftData
     var monitoredTypeSetHash: String = ""
     var monitoredRegistryVersion: Int = 0
     var yearlyCountTimezoneIdentifier: String = ""
+    var cachedSummaryVersion: Int = 0
+    var cachedTypeCount: Int = 0
+    var cachedRecordCount: Int = 0
+    var cachedEarliestRecordDate: Date?
+    var cachedLatestRecordDate: Date?
     @Relationship(deleteRule: .cascade, inverse: \TypeCount.snapshot)
     var typeCounts: [TypeCount]? = []
 
@@ -38,6 +44,41 @@ import SwiftData
 }
 
 extension HealthSnapshot {
+    static let currentCachedSummaryVersion = 1
+
+    static func timelineSort(_ lhs: HealthSnapshot, _ rhs: HealthSnapshot) -> Bool {
+        if lhs.timestamp != rhs.timestamp {
+            return lhs.timestamp < rhs.timestamp
+        }
+        if lhs.localSequenceNumber != rhs.localSequenceNumber {
+            return lhs.localSequenceNumber < rhs.localSequenceNumber
+        }
+        return lhs.id.uuidString < rhs.id.uuidString
+    }
+
+    func previousInTimeline(_ snapshots: [HealthSnapshot]) -> HealthSnapshot? {
+        if let previousSnapshotID,
+           let previous = snapshots.first(where: { $0.id == previousSnapshotID }) {
+            return previous
+        }
+
+        let orderedSnapshots = snapshots.sorted(by: Self.timelineSort)
+        guard let index = orderedSnapshots.firstIndex(where: { $0.id == id }),
+              index > 0 else {
+            return nil
+        }
+        return orderedSnapshots[index - 1]
+    }
+
+    func nextInTimeline(_ snapshots: [HealthSnapshot]) -> HealthSnapshot? {
+        let orderedSnapshots = snapshots.sorted(by: Self.timelineSort)
+        guard let index = orderedSnapshots.firstIndex(where: { $0.id == id }),
+              index < orderedSnapshots.count - 1 else {
+            return nil
+        }
+        return orderedSnapshots[index + 1]
+    }
+
     var snapshotQuality: SnapshotQuality {
         get { SnapshotQuality(rawValue: snapshotQualityRaw) ?? .complete }
         set { snapshotQualityRaw = newValue.rawValue }
@@ -55,4 +96,8 @@ extension HealthSnapshot {
     var contentRepresentativeSnapshotID: UUID {
         contentEquivalentSnapshotID ?? id
     }
+
+    var hasCurrentCachedSummary: Bool {
+        cachedSummaryVersion >= Self.currentCachedSummaryVersion
+    }
 }


+33 -0

HealthProbe/Models/SnapshotDelta.swift

View

+                         var computedAt: Date = Date.now
+                         var checksumBefore: String = ""
+                         var checksumAfter: String = ""
+                    +    var listSummaryVersion: Int = 0
+                    +    var absoluteRecordChangeCount: Int = 0
+                    +    var changedMetricCount: Int = 0
+                    +    var appearedMetricCount: Int = 0
+                    +    var disappearedMetricCount: Int = 0
+                         var isCloudKitImported: Bool = false
+                         @Relationship(deleteRule: .cascade, inverse: \TypeDelta.delta)
+                         var typeDeltas: [TypeDelta]? = []
+                             self.deviceID = deviceID
+                    +struct SnapshotDeltaListSummary {
+                    +    let absoluteRecordChangeCount: Int
+                    +    let changedMetricCount: Int
+                    +    let appearedMetricCount: Int
+                    +    let disappearedMetricCount: Int
+                    +    var affectedMetricCount: Int {
+                    +        changedMetricCount + appearedMetricCount + disappearedMetricCount
+                    +    }
+                    +    var hasChanges: Bool {
+                    +        absoluteRecordChangeCount > 0 || affectedMetricCount > 0
+                    +    }
+                    +}
+                    +extension SnapshotDelta {
+                    +    static let currentListSummaryVersion = 1
+                    +    var listSummary: SnapshotDeltaListSummary {
+                    +        SnapshotDeltaListSummary(
+                    +            absoluteRecordChangeCount: absoluteRecordChangeCount,
+                    +            changedMetricCount: changedMetricCount,
+                    +            appearedMetricCount: appearedMetricCount,
+                    +            disappearedMetricCount: disappearedMetricCount
+                    +        )
+                    +    }
+                    +}

+383 -48

HealthProbe/Models/TypeCountDetailCache.swift

View

+                     enum TypeCountDetailCacheBuilder {
+                    +    private static let bucketTargetArchiveBytes = 8 * 1_024 * 1_024
+                    +    private static let minBucketCount = 4
+                    +    private static let maxBucketCount = 32
+                         static func build(
+                             current: TypeCount,
+                             previous: TypeCount?,
+                         ) -> TypeCountDetailCache? {
+                             let metadata = buildMetadata(current: current, previous: previous)
+                             MemoryLog.log("typeCountDetailCache.build.begin", metadata: metadata)
+                    -        guard !MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) else {
+                    -            MemoryLog.log("typeCountDetailCache.build.skippedMemoryPressure", metadata: metadata.merging([
+                    +        if current.count > 0, current.recordArchiveData == nil { return nil }
+                    +        if let previous, previous.count > 0, previous.recordArchiveData == nil { return nil }
+                    +        var accumulator = DetailCacheAccumulator()
+                    +        if MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) {
+                    +            MemoryLog.log("typeCountDetailCache.build.fastPathSkippedMemoryPressure", metadata: metadata.merging([
+                                     "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit)
+                                 ]) { _, new in new })
+                    -            return nil
+                    +            guard buildBucketedDiffData(
+                    +                currentArchive: current.recordArchiveData,
+                    +                previousArchive: previous?.recordArchiveData,
+                    +                metadata: metadata,
+                    +                accumulator: &accumulator
+                    +            ) else {
+                    +                return nil
+                    +            }
+                    +        } else if !buildFastDiffData(
+                    +            currentArchive: current.recordArchiveData,
+                    +            previousArchive: previous?.recordArchiveData,
+                    +            metadata: metadata,
+                    +            accumulator: &accumulator
+                    +        ) {
+                    +            MemoryLog.log("typeCountDetailCache.build.fastPathFailedFallingBack", metadata: metadata)
+                    +            accumulator = DetailCacheAccumulator()
+                    +            guard buildBucketedDiffData(
+                    +                currentArchive: current.recordArchiveData,
+                    +                previousArchive: previous?.recordArchiveData,
+                    +                metadata: metadata,
+                    +                accumulator: &accumulator
+                    +            ) else {
+                    +                return nil
+                    +            }
+                    -        guard let currentFingerprints = HealthRecordArchive.fingerprintSet(from: current.recordArchiveData) else {
+                    -            MemoryLog.log("typeCountDetailCache.build.currentFingerprintFailed", metadata: metadata)
+                    -            return nil
+                    -        }
+                    -        MemoryLog.log("typeCountDetailCache.build.currentFingerprintsReady", metadata: metadata.merging([
+                    -            "currentFingerprintCount": "\(currentFingerprints.count)"
+                    +        let cache = TypeCountDetailCache(
+                    +            baselineSnapshotID: baselineSnapshotID,
+                    +            addedCount: accumulator.addedCount,
+                    +            disappearedCount: accumulator.disappearedCount,
+                    +            addedPreviewRecords: accumulator.addedPreview.records,
+                    +            disappearedPreviewRecords: accumulator.disappearedPreview.records,
+                    +            dailyChangeBins: accumulator.dailyBins,
+                    +            earliestRecordDate: accumulator.earliestRecordDate,
+                    +            latestRecordDate: accumulator.latestRecordDate
+                    +        )
+                    +        MemoryLog.log("typeCountDetailCache.build.finished", metadata: metadata.merging([
+                    +            "added": "\(cache.addedCount)",
+                    +            "disappeared": "\(cache.disappearedCount)",
+                    +            "dailyBins": "\(cache.dailyChangeBins.count)"
+                             ]) { _, new in new })
+                    -        guard !MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) else {
+                    -            MemoryLog.log("typeCountDetailCache.build.skippedAfterCurrentFingerprints", metadata: metadata.merging([
+                    -                "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit)
+                    +        return cache
+                    +    }
+                    +    private static func buildFastDiffData(
+                    +        currentArchive: Data?,
+                    +        previousArchive: Data?,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        switch (currentArchive, previousArchive) {
+                    +        case let (currentArchive?, previousArchive?):
+                    +            if currentArchive.count <= previousArchive.count {
+                    +                return scanUsingCurrentFingerprintSet(
+                    +                    currentArchive: currentArchive,
+                    +                    previousArchive: previousArchive,
+                    +                    metadata: metadata,
+                    +                    accumulator: &accumulator
+                    +                )
+                    +            }
+                    +            return scanUsingPreviousFingerprintSet(
+                    +                currentArchive: currentArchive,
+                    +                previousArchive: previousArchive,
+                    +                metadata: metadata,
+                    +                accumulator: &accumulator
+                    +            )
+                    +        case let (currentArchive?, nil):
+                    +            guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +                accumulator.add(record, as: .added)
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: metadata)
+                    +                return false
+                    +            }
+                    +            MemoryLog.log("typeCountDetailCache.build.currentScanFinished", metadata: metadata)
+                    +            return true
+                    +        case let (nil, previousArchive?):
+                    +            guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +                accumulator.add(record, as: .disappeared)
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: metadata)
+                    +                return false
+                    +            }
+                    +            MemoryLog.log("typeCountDetailCache.build.previousScanFinished", metadata: metadata)
+                    +            return true
+                    +        case (nil, nil):
+                    +            return true
+                    +        }
+                    +    }
+                    +    private static func buildBucketedDiffData(
+                    +        currentArchive: Data?,
+                    +        previousArchive: Data?,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        switch (currentArchive, previousArchive) {
+                    +        case let (currentArchive?, previousArchive?):
+                    +            let bucketCount = bucketCount(for: max(currentArchive.count, previousArchive.count))
+                    +            MemoryLog.log("typeCountDetailCache.build.bucketedBegin", metadata: metadata.merging([
+                    +                "bucketCount": "\(bucketCount)"
+                                 ]) { _, new in new })
+                    -            return nil
+                    +            let didBuild: Bool
+                    +            if currentArchive.count <= previousArchive.count {
+                    +                didBuild = scanBucketsUsingCurrentFingerprintSet(
+                    +                    currentArchive: currentArchive,
+                    +                    previousArchive: previousArchive,
+                    +                    bucketCount: bucketCount,
+                    +                    metadata: metadata,
+                    +                    accumulator: &accumulator
+                    +                )
+                    +            } else {
+                    +                didBuild = scanBucketsUsingPreviousFingerprintSet(
+                    +                    currentArchive: currentArchive,
+                    +                    previousArchive: previousArchive,
+                    +                    bucketCount: bucketCount,
+                    +                    metadata: metadata,
+                    +                    accumulator: &accumulator
+                    +                )
+                    +            }
+                    +            if didBuild {
+                    +                MemoryLog.log("typeCountDetailCache.build.bucketedEnd", metadata: metadata.merging([
+                    +                    "bucketCount": "\(bucketCount)"
+                    +                ]) { _, new in new })
+                    +            }
+                    +            return didBuild
+                    +        case let (currentArchive?, nil):
+                    +            guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +                accumulator.add(record, as: .added)
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: metadata)
+                    +                return false
+                    +            }
+                    +            MemoryLog.log("typeCountDetailCache.build.currentScanFinished", metadata: metadata)
+                    +            return true
+                    +        case let (nil, previousArchive?):
+                    +            guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +                accumulator.add(record, as: .disappeared)
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: metadata)
+                    +                return false
+                    +            }
+                    +            MemoryLog.log("typeCountDetailCache.build.previousScanFinished", metadata: metadata)
+                    +            return true
+                    +        case (nil, nil):
+                    +            return true
+                    +    }
+                    -        guard let previousFingerprints = HealthRecordArchive.fingerprintSet(from: previous?.recordArchiveData) else {
+                    +    private static func scanUsingPreviousFingerprintSet(
+                    +        currentArchive: Data,
+                    +        previousArchive: Data,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        guard var unmatchedPreviousFingerprints = HealthRecordArchive.fingerprintSet(from: previousArchive) else {
+                                 MemoryLog.log("typeCountDetailCache.build.previousFingerprintFailed", metadata: metadata)
+                    -            return nil
+                    +            return false
+                             MemoryLog.log("typeCountDetailCache.build.previousFingerprintsReady", metadata: metadata.merging([
+                    -            "previousFingerprintCount": "\(previousFingerprints.count)"
+                    +            "previousFingerprintCount": "\(unmatchedPreviousFingerprints.count)",
+                    +            "fingerprintStrategy": "previousOnly"
+                             ]) { _, new in new })
+                             guard !MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) else {
+                                 MemoryLog.log("typeCountDetailCache.build.skippedAfterPreviousFingerprints", metadata: metadata.merging([
+                                     "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit)
+                                 ]) { _, new in new })
+                    -            return nil
+                    +            return false
+                    -        if current.count > 0, current.recordArchiveData == nil { return nil }
+                    -        if let previous, previous.count > 0, previous.recordArchiveData == nil { return nil }
+                    +        guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +            if unmatchedPreviousFingerprints.remove(record.recordFingerprint) != nil {
+                    +                accumulator.add(record, as: .unchanged)
+                    +            } else {
+                    +                accumulator.add(record, as: .added)
+                    +            }
+                    +        }) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: metadata)
+                    +            return false
+                    +        }
+                    +        MemoryLog.log("typeCountDetailCache.build.currentScanFinished", metadata: metadata)
+                    -        var accumulator = DetailCacheAccumulator()
+                    +        guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +            if unmatchedPreviousFingerprints.contains(record.recordFingerprint) {
+                    +                accumulator.add(record, as: .disappeared)
+                    +            }
+                    +        }) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: metadata)
+                    +            return false
+                    +        }
+                    +        MemoryLog.log("typeCountDetailCache.build.previousScanFinished", metadata: metadata)
+                    +        return true
+                    +    }
+                    -        if let previousArchive = previous?.recordArchiveData {
+                    +    private static func scanUsingCurrentFingerprintSet(
+                    +        currentArchive: Data,
+                    +        previousArchive: Data,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        guard var unmatchedCurrentFingerprints = HealthRecordArchive.fingerprintSet(from: currentArchive) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.currentFingerprintFailed", metadata: metadata)
+                    +            return false
+                    +        }
+                    +        MemoryLog.log("typeCountDetailCache.build.currentFingerprintsReady", metadata: metadata.merging([
+                    +            "currentFingerprintCount": "\(unmatchedCurrentFingerprints.count)",
+                    +            "fingerprintStrategy": "currentOnly"
+                    +        ]) { _, new in new })
+                    +        guard !MemoryLog.isFootprintAtOrAbove(MemoryLog.detailCacheBuildFootprintLimit) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.skippedAfterCurrentFingerprints", metadata: metadata.merging([
+                    +                "limit": MemoryLog.format(MemoryLog.detailCacheBuildFootprintLimit)
+                    +            ]) { _, new in new })
+                    +            return false
+                    +        }
+                    +        guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +            if unmatchedCurrentFingerprints.remove(record.recordFingerprint) == nil {
+                    +                accumulator.add(record, as: .disappeared)
+                    +            }
+                    +        }) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: metadata)
+                    +            return false
+                    +        }
+                    +        MemoryLog.log("typeCountDetailCache.build.previousScanFinished", metadata: metadata)
+                    +        guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +            if unmatchedCurrentFingerprints.contains(record.recordFingerprint) {
+                    +                accumulator.add(record, as: .added)
+                    +            } else {
+                    +                accumulator.add(record, as: .unchanged)
+                    +            }
+                    +        }) else {
+                    +            MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: metadata)
+                    +            return false
+                    +        }
+                    +        MemoryLog.log("typeCountDetailCache.build.currentScanFinished", metadata: metadata)
+                    +        return true
+                    +    }
+                    +    private static func scanBucketsUsingPreviousFingerprintSet(
+                    +        currentArchive: Data,
+                    +        previousArchive: Data,
+                    +        bucketCount: Int,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        for bucketNumber in 0..<bucketCount {
+                    +            var unmatchedPreviousFingerprints: Set<String> = []
+                                 guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    -                if !currentFingerprints.contains(record.recordFingerprint) {
+                    -                    accumulator.add(record, as: .disappeared)
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                unmatchedPreviousFingerprints.insert(record.recordFingerprint)
+                                 }) else {
+                    -                MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: metadata)
+                    -                return nil
+                    +                MemoryLog.log("typeCountDetailCache.build.previousFingerprintFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "previousBucketed"
+                    +                ))
+                    +                return false
+                    -            MemoryLog.log("typeCountDetailCache.build.previousScanFinished", metadata: metadata)
+                    -        }
+                    -        if let currentArchive = current.recordArchiveData {
+                                 guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    -                if previousFingerprints.contains(record.recordFingerprint) {
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                }
+                    +                if unmatchedPreviousFingerprints.remove(record.recordFingerprint) != nil {
+                                         accumulator.add(record, as: .unchanged)
+                                     } else {
+                                         accumulator.add(record, as: .added)
+                                 }) else {
+                    -                MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: metadata)
+                    -                return nil
+                    +                MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "previousBucketed"
+                    +                ))
+                    +                return false
+                    +            }
+                    +            guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                }
+                    +                if unmatchedPreviousFingerprints.contains(record.recordFingerprint) {
+                    +                    accumulator.add(record, as: .disappeared)
+                    +                }
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "previousBucketed"
+                    +                ))
+                    +                return false
+                    -            MemoryLog.log("typeCountDetailCache.build.currentScanFinished", metadata: metadata)
+                    -        let cache = TypeCountDetailCache(
+                    -            baselineSnapshotID: baselineSnapshotID,
+                    -            addedCount: accumulator.addedCount,
+                    -            disappearedCount: accumulator.disappearedCount,
+                    -            addedPreviewRecords: accumulator.addedPreview.records,
+                    -            disappearedPreviewRecords: accumulator.disappearedPreview.records,
+                    -            dailyChangeBins: accumulator.dailyBins,
+                    -            earliestRecordDate: accumulator.earliestRecordDate,
+                    -            latestRecordDate: accumulator.latestRecordDate
+                    -        )
+                    -        MemoryLog.log("typeCountDetailCache.build.finished", metadata: metadata.merging([
+                    -            "added": "\(cache.addedCount)",
+                    -            "disappeared": "\(cache.disappearedCount)",
+                    -            "dailyBins": "\(cache.dailyChangeBins.count)"
+                    -        ]) { _, new in new })
+                    -        return cache
+                    +        return true
+                    +    }
+                    +    private static func scanBucketsUsingCurrentFingerprintSet(
+                    +        currentArchive: Data,
+                    +        previousArchive: Data,
+                    +        bucketCount: Int,
+                    +        metadata: [String: String],
+                    +        accumulator: inout DetailCacheAccumulator
+                    +    ) -> Bool {
+                    +        for bucketNumber in 0..<bucketCount {
+                    +            var unmatchedCurrentFingerprints: Set<String> = []
+                    +            guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                }
+                    +                unmatchedCurrentFingerprints.insert(record.recordFingerprint)
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.currentFingerprintFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "currentBucketed"
+                    +                ))
+                    +                return false
+                    +            }
+                    +            guard HealthRecordArchive.forEachRecord(in: previousArchive, { record in
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                }
+                    +                if unmatchedCurrentFingerprints.remove(record.recordFingerprint) == nil {
+                    +                    accumulator.add(record, as: .disappeared)
+                    +                }
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.previousScanFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "currentBucketed"
+                    +                ))
+                    +                return false
+                    +            }
+                    +            guard HealthRecordArchive.forEachRecord(in: currentArchive, { record in
+                    +                guard fingerprintBucketIndex(for: record.recordFingerprint, bucketCount: bucketCount) == bucketNumber else {
+                    +                    return
+                    +                }
+                    +                if unmatchedCurrentFingerprints.contains(record.recordFingerprint) {
+                    +                    accumulator.add(record, as: .added)
+                    +                } else {
+                    +                    accumulator.add(record, as: .unchanged)
+                    +                }
+                    +            }) else {
+                    +                MemoryLog.log("typeCountDetailCache.build.currentScanFailed", metadata: bucketMetadata(
+                    +                    metadata: metadata,
+                    +                    bucketIndex: bucketNumber,
+                    +                    bucketCount: bucketCount,
+                    +                    strategy: "currentBucketed"
+                    +                ))
+                    +                return false
+                    +            }
+                    +        }
+                    +        return true
+                    +    }
+                    +    private static func bucketCount(for maxArchiveBytes: Int) -> Int {
+                    +        let rawBucketCount = max(1, Int(ceil(Double(maxArchiveBytes) / Double(bucketTargetArchiveBytes))))
+                    +        var bucketCount = 1
+                    +        while bucketCount < rawBucketCount {
+                    +            bucketCount <<= 1
+                    +        }
+                    +        return min(max(bucketCount, minBucketCount), maxBucketCount)
+                    +    }
+                    +    private static func fingerprintBucketIndex(for fingerprint: String, bucketCount: Int) -> Int {
+                    +        var hash: UInt64 = 1_469_598_103_934_665_603
+                    +        for byte in fingerprint.utf8.prefix(12) {
+                    +            hash ^= UInt64(byte)
+                    +            hash &*= 1_099_511_628_211
+                    +        }
+                    +        return Int(hash % UInt64(bucketCount))
+                    +    }
+                    +    private static func bucketMetadata(
+                    +        metadata: [String: String],
+                    +        bucketIndex: Int,
+                    +        bucketCount: Int,
+                    +        strategy: String
+                    +    ) -> [String: String] {
+                    +        metadata.merging([
+                    +            "bucket": "\(bucketIndex + 1)/\(bucketCount)",
+                    +            "fingerprintStrategy": strategy
+                    +        ]) { _, new in new }
+                         private static func buildMetadata(current: TypeCount, previous: TypeCount?) -> [String: String] {

+54 -0

HealthProbe/Services/DeltaService.swift

View

@@ -36,6 +36,7 @@ enum DeltaService {
         if current.isContentAlias,
            current.contentEquivalentSnapshotID == previous.contentRepresentativeSnapshotID {
             delta.typeDeltas = []
+            updateListSummary(for: delta, typeDeltas: [])
             context.insert(delta)
             try context.save()
             return delta
@@ -75,11 +76,33 @@ enum DeltaService {
         }
 
         delta.typeDeltas = typeDeltas
+        updateListSummary(for: delta, typeDeltas: typeDeltas)
         context.insert(delta)
         try context.save()
         return delta
     }
 
+    @discardableResult
+    static func rebuildMissingListSummaries(context: ModelContext, maxCount: Int) throws -> Bool {
+        guard maxCount > 0 else { return false }
+
+        let summaryVersion = SnapshotDelta.currentListSummaryVersion
+        var descriptor = FetchDescriptor<SnapshotDelta>(
+            predicate: #Predicate<SnapshotDelta> { $0.listSummaryVersion < summaryVersion }
+        )
+        descriptor.fetchLimit = maxCount
+
+        let deltas = try context.fetch(descriptor)
+        guard !deltas.isEmpty else { return false }
+
+        for delta in deltas {
+            updateListSummary(for: delta, typeDeltas: delta.typeDeltas ?? [])
+        }
+
+        try context.save()
+        return true
+    }
+
     // MARK: - Delta merge (for intermediate snapshot deletion)
 
     // snapshotBefore and snapshotAfter are the real surrounding snapshots (N-1 and N+1).
@@ -127,6 +150,7 @@ enum DeltaService {
             }
         }
         merged.typeDeltas = mergedTypeDeltas
+        updateListSummary(for: merged, typeDeltas: mergedTypeDeltas)
         return merged
     }
 
@@ -197,6 +221,36 @@ enum DeltaService {
         return td
     }
 
+    private static func updateListSummary(for delta: SnapshotDelta, typeDeltas: [TypeDelta]) {
+        var absoluteRecordChangeCount = 0
+        var changedMetricCount = 0
+        var appearedMetricCount = 0
+        var disappearedMetricCount = 0
+
+        for typeDelta in typeDeltas {
+            switch typeDelta.transition {
+            case .unchanged:
+                continue
+            case .changed:
+                changedMetricCount += 1
+                if typeDelta.qualityBefore == .complete,
+                   typeDelta.qualityAfter == .complete {
+                    absoluteRecordChangeCount += abs(typeDelta.countDelta)
+                }
+            case .appeared:
+                appearedMetricCount += 1
+            case .disappeared:
+                disappearedMetricCount += 1
+            }
+        }
+
+        delta.absoluteRecordChangeCount = absoluteRecordChangeCount
+        delta.changedMetricCount = changedMetricCount
+        delta.appearedMetricCount = appearedMetricCount
+        delta.disappearedMetricCount = disappearedMetricCount
+        delta.listSummaryVersion = SnapshotDelta.currentListSummaryVersion
+    }
+
     private static func historicalBaselinePreviousTypeCount(
         typeID: String,
         prev: TypeCount?,


+20 -0

HealthProbe/Services/HealthKitService.swift

View

@@ -133,6 +133,7 @@ final class HealthKitService {
         }
 
         snapshot.snapshotQuality = deriveSnapshotQuality(from: typeCounts)
+        updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
 
         configureSnapshotMetadata(
             snapshot,
@@ -171,6 +172,8 @@ final class HealthKitService {
             return snapshot
         }
 
+        updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
+
         configureSnapshotMetadata(
             snapshot,
             typeCounts: typeCounts,
@@ -199,6 +202,8 @@ final class HealthKitService {
             return try await savePartialSnapshot(snapshot, in: context)
         }
 
+        updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
+
         configureSnapshotMetadata(
             snapshot,
             typeCounts: typeCounts,
@@ -245,6 +250,21 @@ final class HealthKitService {
         try await runPostSavePipeline(snapshot: snapshot, typeCounts: typeCounts, context: context)
     }
 
+    private func updateSnapshotSummaryCache(
+        snapshot: HealthSnapshot,
+        typeCounts: [TypeCount]
+    ) {
+        snapshot.cachedSummaryVersion = HealthSnapshot.currentCachedSummaryVersion
+        snapshot.cachedTypeCount = typeCounts.count
+        snapshot.cachedRecordCount = typeCounts.reduce(0) { partial, typeCount in
+            typeCount.count > 0 ? partial + typeCount.count : partial
+        }
+
+        let datedTypeCounts = typeCounts.filter { !$0.isUnsupported && $0.count > 0 }
+        snapshot.cachedEarliestRecordDate = datedTypeCounts.compactMap(\.earliestDate).min()
+        snapshot.cachedLatestRecordDate = datedTypeCounts.compactMap(\.latestDate).max()
+    }
+
     private func configureSnapshotMetadata(
         _ snapshot: HealthSnapshot,
         typeCounts: [TypeCount],


+13 -13

HealthProbe/Services/ObserverService.swift

View

@@ -55,12 +55,12 @@ final class ObserverService {
     // MARK: - Callback handling
 
     private func handleObserverCallback(typeID: String) {
-        lock.lock()
-        let now = Date()
-        lastCallbackTimestamp = now
-        accumulatedTypeIDs.insert(typeID)
-        let alreadyScheduled = debounceTask != nil
-        lock.unlock()
+        let alreadyScheduled = lock.withLock {
+            let now = Date()
+            lastCallbackTimestamp = now
+            accumulatedTypeIDs.insert(typeID)
+            return debounceTask != nil
+        }
 
         guard !alreadyScheduled else { return }
 
@@ -74,9 +74,9 @@ final class ObserverService {
 
     @MainActor
     private func tryCreateObserverSnapshot() async {
-        lock.lock()
-        debounceTask = nil
-        lock.unlock()
+        lock.withLock {
+            debounceTask = nil
+        }
 
         guard let container = modelContainer else {
             logger.error("ObserverService: no modelContainer — cannot create snapshot")
@@ -111,10 +111,10 @@ final class ObserverService {
             logger.error("ObserverService: failed to create snapshot — \(error)")
         }
 
-        lock.lock()
-        accumulatedTypeIDs.removeAll()
-        lastCallbackTimestamp = nil
-        lock.unlock()
+        lock.withLock {
+            accumulatedTypeIDs.removeAll()
+            lastCallbackTimestamp = nil
+        }
     }
 
     // MARK: - Type classification


+20 -37

HealthProbe/Services/SnapshotLifecycleService.swift

View

@@ -14,9 +14,8 @@ enum SnapshotLifecycleService {
     }
 
     static func previewDeletion(of snapshot: HealthSnapshot, context: ModelContext) throws -> DeletionPreview {
-        let allDeltas = try fetchDeltas(context: context)
-        let incomingDelta = allDeltas.first { $0.toSnapshotID == snapshot.id }
-        let outgoingDelta = allDeltas.first { $0.fromSnapshotID == snapshot.id }
+        let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)
+        let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)
 
         var willBreakChain = false
         var description = ""
@@ -62,9 +61,8 @@ enum SnapshotLifecycleService {
     }
 
     static func delete(_ snapshot: HealthSnapshot, context: ModelContext) throws {
-        let allDeltas = try fetchDeltas(context: context)
-        let incomingDelta = allDeltas.first { $0.toSnapshotID == snapshot.id }
-        let outgoingDelta = allDeltas.first { $0.fromSnapshotID == snapshot.id }
+        let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)
+        let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)
 
         let deviceID = snapshot.deviceID
         let version = Bundle.main.appBuildVersion
@@ -92,7 +90,7 @@ enum SnapshotLifecycleService {
                 for typeCount in nextSnap.typeCounts ?? [] {
                     typeCount.contentEquivalentTypeCountID = nil
                 }
-                refreshDetailCaches(for: nextSnap, baseline: nil)
+                invalidateDetailCaches(for: nextSnap)
             }
             context.delete(outgoing)
             context.delete(snapshot)
@@ -119,7 +117,7 @@ enum SnapshotLifecycleService {
 
             nextSnap.previousSnapshotID = prevSnap.id
             _ = refreshContentEquivalence(for: nextSnap, baseline: prevSnap)
-            refreshDetailCaches(for: nextSnap, baseline: prevSnap)
+            invalidateDetailCaches(for: nextSnap)
             context.delete(d1)
             context.delete(d2)
             context.delete(snapshot)
@@ -155,9 +153,6 @@ enum SnapshotLifecycleService {
             "maxTypeCounts": "\(maxTypeCounts)"
         ])
 
-        let descriptor = FetchDescriptor<HealthSnapshot>(
-            sortBy: [SortDescriptor(\.timestamp, order: .forward)]
-        )
         let snapshotIDs = try context.fetch(FetchDescriptor<HealthSnapshot>()).map { $0.id }
         MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.snapshotsFetched", metadata: [
             "snapshotCount": "\(snapshotIDs.count)"
@@ -279,8 +274,18 @@ enum SnapshotLifecycleService {
 
     // MARK: - Fetch helpers
 
-    private static func fetchDeltas(context: ModelContext) throws -> [SnapshotDelta] {
-        try context.fetch(FetchDescriptor<SnapshotDelta>())
+    private static func fetchIncomingDelta(toSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {
+        let descriptor = FetchDescriptor<SnapshotDelta>(
+            predicate: #Predicate<SnapshotDelta> { $0.toSnapshotID == snapshotID }
+        )
+        return try context.fetch(descriptor).first
+    }
+
+    private static func fetchOutgoingDelta(fromSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {
+        let descriptor = FetchDescriptor<SnapshotDelta>(
+            predicate: #Predicate<SnapshotDelta> { $0.fromSnapshotID == snapshotID }
+        )
+        return try context.fetch(descriptor).first
     }
 
     private static func fetchSnapshot(id: UUID, context: ModelContext) throws -> HealthSnapshot? {
@@ -290,31 +295,9 @@ enum SnapshotLifecycleService {
         return try context.fetch(descriptor).first
     }
 
-    private static func refreshDetailCaches(for snapshot: HealthSnapshot, baseline: HealthSnapshot?) {
-        guard let baseline else {
-            for typeCount in snapshot.typeCounts ?? [] {
-                typeCount.setDetailCache(nil)
-            }
-            return
-        }
-
-        let baselineByType = Dictionary(
-            uniqueKeysWithValues: (baseline.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
-        )
-
+    private static func invalidateDetailCaches(for snapshot: HealthSnapshot) {
         for typeCount in snapshot.typeCounts ?? [] {
-            if typeCount.isContentAlias {
-                typeCount.setDetailCache(nil)
-                continue
-            }
-
-            typeCount.setDetailCache(
-                TypeCountDetailCacheBuilder.build(
-                    current: typeCount,
-                    previous: baselineByType[typeCount.typeIdentifier],
-                    baselineSnapshotID: baseline.id
-                )
-            )
+            typeCount.setDetailCache(nil)
         }
     }
 


+6 -6

HealthProbe/Utilities/MemoryLog.swift

View

@@ -10,7 +10,7 @@ struct MemorySample: Sendable {
 enum MemoryLog {
     static let detailCacheBuildFootprintLimit: UInt64 = 1_500 * 1_024 * 1_024
 
-    static func log(_ event: String, metadata: [String: String] = [:]) {
+    nonisolated static func log(_ event: String, metadata: [String: String] = [:]) {
         let sample = currentSample()
         let metadataText = metadata
             .sorted { $0.key < $1.key }
@@ -27,7 +27,7 @@ enum MemoryLog {
         print(line)
     }
 
-    static func startPulse(_ event: String, metadata: [String: String] = [:], intervalSeconds: UInt64 = 1) -> Task<Void, Never> {
+    nonisolated static func startPulse(_ event: String, metadata: [String: String] = [:], intervalSeconds: UInt64 = 1) -> Task<Void, Never> {
         Task.detached(priority: .background) {
             var previousSample = currentSample()
             var previousTime = Date()
@@ -59,23 +59,23 @@ enum MemoryLog {
         }
     }
 
-    static func format(_ bytes: UInt64) -> String {
+    nonisolated static func format(_ bytes: UInt64) -> String {
         ByteCountFormatter.string(fromByteCount: Int64(bytes), countStyle: .memory)
     }
 
-    static func isFootprintAtOrAbove(_ bytes: UInt64) -> Bool {
+    nonisolated static func isFootprintAtOrAbove(_ bytes: UInt64) -> Bool {
         guard let currentSample = currentSample() else { return false }
         return currentSample.physicalFootprintBytes >= bytes
     }
 
-    private static func signedFormat(_ bytes: Int64) -> String {
+    nonisolated private static func signedFormat(_ bytes: Int64) -> String {
         if bytes >= 0 {
             return "+\(format(UInt64(bytes)))"
         }
         return "-\(format(UInt64(-bytes)))"
     }
 
-    private static func currentSample() -> MemorySample? {
+    nonisolated private static func currentSample() -> MemorySample? {
         var info = task_vm_info_data_t()
         var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)
         let result = withUnsafeMutablePointer(to: &info) { pointer in


+168 -0

HealthProbe/Utilities/TypeCountArchiveRepair.swift

View

+                    +import Foundation
+                    +import SwiftData
+                    +struct TypeCountDetailCacheResolution: Sendable {
+                    +    let cache: TypeCountDetailCache?
+                    +    let diagnostic: String
+                    +}
+                    +extension TypeCount {
+                    +    private static let detailCacheResolverVersion = "resolver-v5"
+                    +    @MainActor
+                    +    func ensureRecordArchiveDataIfNeeded() -> Bool {
+                    +        if count <= 0 {
+                    +            return true
+                    +        }
+                    +        if let existingArchive = recordArchiveData {
+                    +            if HealthRecordArchive.isCompact(existingArchive) {
+                    +                return true
+                    +            }
+                    +            guard let compactArchive = HealthRecordArchive.compactedIfNeeded(existingArchive) else {
+                    +                return false
+                    +            }
+                    +            recordArchiveData = compactArchive
+                    +            return true
+                    +        }
+                    +        let legacyRecords = records ?? []
+                    +        guard !legacyRecords.isEmpty else {
+                    +            return false
+                    +        }
+                    +        let values = legacyRecords.map { record in
+                    +            HealthRecordValue(
+                    +                typeIdentifier: record.typeIdentifier,
+                    +                sampleUUIDHash: record.sampleUUIDHash,
+                    +                recordFingerprint: record.recordFingerprint,
+                    +                startDate: record.startDate,
+                    +                endDate: record.endDate,
+                    +                displayValue: record.displayValue
+                    +            )
+                    +        }
+                    +        guard let archive = HealthRecordArchive.encode(values) else {
+                    +            return false
+                    +        }
+                    +        recordArchiveData = archive
+                    +        records?.removeAll()
+                    +        return true
+                    +    }
+                    +    @MainActor
+                    +    func resolveDetailCache(
+                    +        previous: TypeCount?,
+                    +        baselineSnapshotID: UUID?,
+                    +        context: ModelContext,
+                    +        source: String
+                    +    ) -> TypeCountDetailCache? {
+                    +        resolveDetailCacheWithDiagnostics(
+                    +            previous: previous,
+                    +            baselineSnapshotID: baselineSnapshotID,
+                    +            context: context,
+                    +            source: source
+                    +        ).cache
+                    +    }
+                    +    @MainActor
+                    +    func resolveDetailCacheWithDiagnostics(
+                    +        previous: TypeCount?,
+                    +        baselineSnapshotID: UUID?,
+                    +        context: ModelContext,
+                    +        source: String
+                    +    ) -> TypeCountDetailCacheResolution {
+                    +        if let cache = detailCache,
+                    +           cache.matchesBaseline(baselineSnapshotID) {
+                    +            return TypeCountDetailCacheResolution(
+                    +                cache: cache,
+                    +                diagnostic: detailCacheDiagnostic(
+                    +                    previous: previous,
+                    +                    baselineSnapshotID: baselineSnapshotID,
+                    +                    phase: "cache-hit"
+                    +                )
+                    +            )
+                    +        }
+                    +        let currentArchiveWasMissing = count > 0 && recordArchiveData == nil
+                    +        let previousArchiveWasMissing = (previous?.count ?? 0) > 0 && previous?.recordArchiveData == nil
+                    +        let currentArchiveAvailable = ensureRecordArchiveDataIfNeeded()
+                    +        let previousArchiveAvailable = previous?.ensureRecordArchiveDataIfNeeded() ?? true
+                    +        guard currentArchiveAvailable, previousArchiveAvailable else {
+                    +            let diagnostic = detailCacheDiagnostic(
+                    +                previous: previous,
+                    +                baselineSnapshotID: baselineSnapshotID,
+                    +                phase: "missing-archive"
+                    +            )
+                    +            MemoryLog.log("\(source).detailCache.resolveUnavailable", metadata: detailCacheMetadata(previous: previous).merging([
+                    +                "diagnostic": diagnostic
+                    +            ]) { _, new in new })
+                    +            return TypeCountDetailCacheResolution(cache: nil, diagnostic: diagnostic)
+                    +        }
+                    +        MemoryLog.log("\(source).detailCache.buildBegin", metadata: detailCacheMetadata(previous: previous))
+                    +        let cache = TypeCountDetailCacheBuilder.build(
+                    +            current: self,
+                    +            previous: previous,
+                    +            baselineSnapshotID: baselineSnapshotID
+                    +        )
+                    +        let diagnostic = detailCacheDiagnostic(
+                    +            previous: previous,
+                    +            baselineSnapshotID: baselineSnapshotID,
+                    +            phase: cache == nil ? "build-nil" : "built"
+                    +        )
+                    +        MemoryLog.log("\(source).detailCache.buildEnd", metadata: [
+                    +            "source": source,
+                    +            "type": typeIdentifier,
+                    +            "cacheBuilt": "\(cache != nil)",
+                    +            "diagnostic": diagnostic
+                    +        ])
+                    +        if let cache {
+                    +            setDetailCache(cache)
+                    +        }
+                    +        if cache != nil ||
+                    +            (currentArchiveWasMissing && recordArchiveData != nil) ||
+                    +            (previousArchiveWasMissing && previous?.recordArchiveData != nil) {
+                    +            try? context.save()
+                    +        }
+                    +        return TypeCountDetailCacheResolution(cache: cache, diagnostic: diagnostic)
+                    +    }
+                    +    private func detailCacheMetadata(previous: TypeCount?) -> [String: String] {
+                    +        [
+                    +            "type": typeIdentifier,
+                    +            "currentCount": "\(count)",
+                    +            "previousCount": "\(previous?.count ?? 0)",
+                    +            "currentArchive": recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",
+                    +            "previousArchive": previous?.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil"
+                    +        ]
+                    +    }
+                    +    private func detailCacheDiagnostic(
+                    +        previous: TypeCount?,
+                    +        baselineSnapshotID: UUID?,
+                    +        phase: String
+                    +    ) -> String {
+                    +        let baseline = baselineSnapshotID?.uuidString.prefix(6) ?? "none"
+                    +        let currentArchive = archiveDebugLabel(for: self)
+                    +        let previousArchive = archiveDebugLabel(for: previous)
+                    +        return "\(Self.detailCacheResolverVersion) phase=\(phase) base=\(baseline) curr=\(currentArchive) prev=\(previousArchive)"
+                    +    }
+                    +    private func archiveDebugLabel(for typeCount: TypeCount?) -> String {
+                    +        guard let typeCount else { return "none" }
+                    +        if let archive = typeCount.recordArchiveData {
+                    +            let formatSuffix = HealthRecordArchive.isCompact(archive) ? "-c" : "-p"
+                    +            return "\(MemoryLog.format(UInt64(archive.count)))\(formatSuffix)"
+                    +        }
+                    +        if typeCount.count <= 0 {
+                    +            return "empty"
+                    +        }
+                    +        return "missing"
+                    +    }
+                    +}

+19 -4

HealthProbe/ViewModels/DataTypeTemporalDistributionViewModel.swift

View

@@ -1,4 +1,5 @@
 import Foundation
+import SwiftData
 
 enum BinningStrategy: String, CaseIterable, Equatable {
     case day = "Zi"
@@ -114,17 +115,18 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
     private var disappearedByDate: [Date: Int] = [:]
     private var unchangedByDate: [Date: Int] = [:]
 
-    func load(current: TypeCount?, previous: TypeCount?) async {
+    func load(current: TypeCount?, previous: TypeCount?, context: ModelContext) async {
         defer { isLoading = false }
+        error = nil
+        hasData = false
 
         guard let current else {
             error = "No current snapshot data"
             return
         }
 
-        guard let cache = current.detailCache,
-              cache.matchesBaseline(previous?.snapshot?.id) else {
-            error = "Precomputed detail data is unavailable for this snapshot. Create a new snapshot to generate temporal detail caches."
+        guard let cache = resolveDetailCache(current: current, previous: previous, context: context) else {
+            error = "Record detail data could not be computed for this snapshot pair."
             return
         }
 
@@ -141,6 +143,19 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
         await rebuildBinsBackground()
     }
 
+    private func resolveDetailCache(
+        current: TypeCount,
+        previous: TypeCount?,
+        context: ModelContext
+    ) -> TypeCountDetailCache? {
+        let baselineID = previous?.snapshot?.id
+        guard let cache = current.detailCache,
+              cache.matchesBaseline(baselineID) else {
+            return nil
+        }
+        return cache
+    }
+
     private func indexDailyBins(_ bins: [TypeCountDailyChangeBin]) {
         addedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.added) })
         disappearedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.disappeared) })


+25 -2

HealthProbe/ViewModels/SnapshotsViewModel.swift

View

@@ -26,11 +26,34 @@ final class SnapshotsViewModel {
     var comparisonMode: ComparisonMode = .previous
     var selectedBaseline: HealthSnapshot?
 
+    func baselines(for snapshots: [HealthSnapshot]) -> [UUID: HealthSnapshot] {
+        let orderedDescending = snapshots.sorted { $0.timestamp > $1.timestamp }
+
+        return snapshots.reduce(into: [UUID: HealthSnapshot]()) { partial, snapshot in
+            partial[snapshot.id] = baseline(
+                for: snapshot,
+                in: snapshots,
+                orderedDescending: orderedDescending
+            )
+        }
+    }
+
     func baseline(for snapshot: HealthSnapshot, in snapshots: [HealthSnapshot]) -> HealthSnapshot? {
-        let sorted = snapshots.sorted { $0.timestamp > $1.timestamp }
+        baseline(
+            for: snapshot,
+            in: snapshots,
+            orderedDescending: snapshots.sorted { $0.timestamp > $1.timestamp }
+        )
+    }
+
+    private func baseline(
+        for snapshot: HealthSnapshot,
+        in snapshots: [HealthSnapshot],
+        orderedDescending: [HealthSnapshot]
+    ) -> HealthSnapshot? {
         switch comparisonMode {
         case .previous:
-            return sorted.first { $0.timestamp < snapshot.timestamp }
+            return orderedDescending.first { $0.timestamp < snapshot.timestamp }
         case .selected:
             return selectedBaseline
         case .relativeTime(let interval):


+7 -10

HealthProbe/Views/DataTypes/DataTypeTemporalDistributionView.swift

View

@@ -6,6 +6,7 @@ struct DataTypeTemporalDistributionView: View {
     let previous: TypeCount?
     let displayName: String
 
+    @Environment(\.modelContext) private var modelContext
     @State private var viewModel = DataTypeTemporalDistributionViewModel()
     @State private var isRecomputing = false
     @State private var isZoomed: Bool = false
@@ -30,21 +31,17 @@ struct DataTypeTemporalDistributionView: View {
     }
 
     private var timelineSnapshots: [HealthSnapshot] {
-        allSnapshots.filter { current?.snapshot?.deviceID ?? "" == $0.deviceID }
+        allSnapshots
+            .filter { current?.snapshot?.deviceID ?? "" == $0.deviceID }
+            .sorted(by: HealthSnapshot.timelineSort)
     }
 
     private var previousSnapshot: HealthSnapshot? {
-        guard let current = currentSnapshot,
-              let idx = timelineSnapshots.firstIndex(where: { $0.id == current.id }),
-              idx > 0 else { return nil }
-        return timelineSnapshots[idx - 1]
+        currentSnapshot?.previousInTimeline(timelineSnapshots)
     }
 
     private var nextSnapshot: HealthSnapshot? {
-        guard let current = currentSnapshot,
-              let idx = timelineSnapshots.firstIndex(where: { $0.id == current.id }),
-              idx < timelineSnapshots.count - 1 else { return nil }
-        return timelineSnapshots[idx + 1]
+        currentSnapshot?.nextInTimeline(timelineSnapshots)
     }
 
     var body: some View {
@@ -83,7 +80,7 @@ struct DataTypeTemporalDistributionView: View {
             }
         }
         .task {
-            await viewModel.load(current: current, previous: previous)
+            await viewModel.load(current: current, previous: previous, context: modelContext)
         }
     }
 


+32 -13

HealthProbe/Views/DataTypes/RecordChangeEvolutionChart.swift

View

@@ -1,4 +1,5 @@
 import SwiftUI
+import SwiftData
 
 struct RecordChangeEvolutionChart: View {
     let snapshots: [HealthSnapshot]
@@ -6,8 +7,10 @@ struct RecordChangeEvolutionChart: View {
     let typeIdentifier: String
     let displayName: String
 
+    @Query private var allDeltas: [SnapshotDelta]
+
     private var sortedSnapshots: [HealthSnapshot] {
-        snapshots.sorted { $0.timestamp < $1.timestamp }
+        snapshots.sorted(by: HealthSnapshot.timelineSort)
     }
 
     private var currentIndex: Int? {
@@ -21,6 +24,10 @@ struct RecordChangeEvolutionChart: View {
         return Array(sortedSnapshots[start..<end])
     }
 
+    private var diffTaskID: String {
+        ([typeIdentifier, currentSnapshotID.uuidString] + contextSnapshots.map { $0.id.uuidString }).joined(separator: "|")
+    }
+
     private var maxCount: Int {
         let counts = contextSnapshots.compactMap { snapshot in
             snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }?.count
@@ -30,9 +37,8 @@ struct RecordChangeEvolutionChart: View {
 
     private var maxNegativeCount: Int {
         var max = 0
-        for i in 0..<contextSnapshots.count {
-            let snapshot = contextSnapshots[i]
-            let previousSnapshot = i > 0 ? contextSnapshots[i - 1] : nil
+        for snapshot in contextSnapshots {
+            let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
             let diff = recordDiff(current: snapshot, previous: previousSnapshot)
             max = Swift.max(max, diff.disappeared)
         }
@@ -41,19 +47,31 @@ struct RecordChangeEvolutionChart: View {
 
     private func recordDiff(current: HealthSnapshot, previous: HealthSnapshot?) -> (added: Int, disappeared: Int) {
         guard let previous = previous else { return (0, 0) }
-        guard let currentType = current.typeCounts?
-            .first(where: { $0.typeIdentifier == typeIdentifier }) else {
+
+        guard let delta = allDeltas.first(where: {
+            $0.fromSnapshotID == previous.id &&
+            $0.toSnapshotID == current.id
+        }),
+        let typeDelta = delta.typeDeltas?.first(where: { $0.typeIdentifier == typeIdentifier }) else {
             return (0, 0)
         }
 
-        if let previousType = previous.typeCounts?.first(where: { $0.typeIdentifier == typeIdentifier }),
-           currentType.contentEquivalentTypeCountID == previousType.contentRepresentativeTypeCountID {
+        switch typeDelta.transition {
+        case .unchanged:
             return (0, 0)
+        case .changed:
+            if typeDelta.countDelta > 0 {
+                return (typeDelta.countDelta, 0)
+            }
+            if typeDelta.countDelta < 0 {
+                return (0, abs(typeDelta.countDelta))
+            }
+            return (0, 0)
+        case .appeared:
+            return (max(typeDelta.countDelta, 1), 0)
+        case .disappeared:
+            return (0, max(abs(typeDelta.countDelta), 1))
         }
-
-        guard let cache = currentType.detailCache,
-              cache.matchesBaseline(previous.id) else { return (0, 0) }
-        return (cache.addedCount, cache.disappearedCount)
     }
 
     var body: some View {
@@ -155,7 +173,7 @@ struct RecordChangeEvolutionChart: View {
         let typeCount = snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }
         let count = typeCount?.count ?? 0
         let isCurrent = snapshot.id == currentSnapshotID
-        let previousSnapshot = index > 0 ? contextSnapshots[index - 1] : nil
+        let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
         let diff = recordDiff(current: snapshot, previous: previousSnapshot)
         let unchanged = count - diff.added
 
@@ -204,6 +222,7 @@ struct RecordChangeEvolutionChart: View {
         }
         .frame(maxWidth: .infinity)
     }
+
 }
 
 #Preview {


+156 -39

HealthProbe/Views/Snapshots/DataTypeSnapshotDetailView.swift

View

@@ -8,12 +8,14 @@ struct DataTypeSnapshotDetailView: View {
 
     @Environment(\.modelContext) private var modelContext
     @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]
+    @Query private var allDeltas: [SnapshotDelta]
 
     @State private var displayedSnapshot: HealthSnapshot?
     @State private var diffState: RecordDiffState = .idle
     @State private var showAddedRecords = false
     @State private var showDisappearedRecords = false
     @State private var showTemporalDistribution = false
+    @State private var detailCacheDiagnostic: String?
 
     private var currentSnapshot: HealthSnapshot {
         displayedSnapshot ?? snapshot
@@ -26,12 +28,11 @@ struct DataTypeSnapshotDetailView: View {
             }
             return candidate.deviceID == currentSnapshot.deviceID
         }
+        .sorted(by: HealthSnapshot.timelineSort)
     }
 
     private var previousSnapshot: HealthSnapshot? {
-        guard let currentSnapshotIndex = timelineSnapshots.firstIndex(where: { $0.id == currentSnapshot.id }),
-              currentSnapshotIndex > 0 else { return nil }
-        return timelineSnapshots[currentSnapshotIndex - 1]
+        currentSnapshot.previousInTimeline(timelineSnapshots)
     }
 
     private var currentTypeCount: TypeCount? {
@@ -48,6 +49,24 @@ struct DataTypeSnapshotDetailView: View {
         return currentTypeCount.contentEquivalentTypeCountID == previousTypeCount.contentRepresentativeTypeCountID
     }
 
+    private var hasTemporalDistributionCache: Bool {
+        guard let currentTypeCount,
+              let previousSnapshot else { return false }
+        return currentTypeCount.detailCache?.matchesBaseline(previousSnapshot.id) == true
+    }
+
+    private var currentDelta: SnapshotDelta? {
+        guard let previousSnapshot else { return nil }
+        return allDeltas.first {
+            $0.toSnapshotID == currentSnapshot.id &&
+            $0.fromSnapshotID == previousSnapshot.id
+        }
+    }
+
+    private var currentTypeDelta: TypeDelta? {
+        currentDelta?.typeDeltas?.first { $0.typeIdentifier == typeIdentifier }
+    }
+
     private var diffTaskID: String {
         [
             currentSnapshot.id.uuidString,
@@ -71,6 +90,25 @@ struct DataTypeSnapshotDetailView: View {
         countText(for: previousTypeCount)
     }
 
+    private var quickCurrentCountValue: Int {
+        max(currentTypeCount?.count ?? 0, 0)
+    }
+
+    private var quickPreviousCountValue: Int {
+        max(previousTypeCount?.count ?? 0, 0)
+    }
+
+    private var quickAddedDisappeared: (added: Int, disappeared: Int, exact: Bool) {
+        if let previousSnapshot,
+           let cache = currentTypeCount?.detailCache,
+           cache.matchesBaseline(previousSnapshot.id) {
+            return (cache.addedCount, cache.disappearedCount, true)
+        }
+
+        let net = (currentTypeDelta?.countDelta ?? (quickCurrentCountValue - quickPreviousCountValue))
+        return (max(net, 0), max(-net, 0), false)
+    }
+
     var body: some View {
         ScrollView {
             VStack(spacing: 16) {
@@ -194,10 +232,10 @@ struct DataTypeSnapshotDetailView: View {
         }
     }
 
-    @ViewBuilder
     private var recordChangeComparisonSection: some View {
-        if previousSnapshot != nil {
-            switch diffState {
+        Group {
+            if previousSnapshot != nil {
+                switch diffState {
             case .loaded(let diff):
                 RecordChangeComparisonCard(
                     displayName: displayName,
@@ -237,13 +275,55 @@ struct DataTypeSnapshotDetailView: View {
                     )
                 }
 
+            case .idle:
+                VStack(alignment: .leading, spacing: 10) {
+                    let quick = quickAddedDisappeared
+
+                    VStack(alignment: .leading, spacing: 8) {
+                        Text("Quick Counts")
+                            .font(.subheadline.weight(.semibold))
+
+                        HStack {
+                            quickStat(label: "Current", value: "\(quickCurrentCountValue)")
+                            quickStat(label: "Previous", value: "\(quickPreviousCountValue)")
+                        }
+
+                        HStack {
+                            quickStat(label: "New", value: "\(quick.added)", color: .healthyGreen)
+                            quickStat(label: "Disappeared", value: "\(quick.disappeared)", color: .criticalRed)
+                        }
+
+                        if !quick.exact {
+                            Text("New/Disappeared are net values from snapshot delta. Exact split needs deep record analysis.")
+                                .font(.caption2)
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                    .padding(12)
+                    .background(Color(.systemBackground).opacity(0.35), in: RoundedRectangle(cornerRadius: 8))
+                }
+                .padding(12)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
+
             case .unavailable:
-                Label(
-                    "Record detail cache is unavailable for this snapshot pair.",
-                    systemImage: "exclamationmark.triangle.fill"
-                )
-                .font(.subheadline)
-                .foregroundStyle(Color.warningAmber)
+                VStack(alignment: .leading, spacing: 8) {
+                    Label(
+                        "Record detail cache is unavailable for this snapshot pair.",
+                        systemImage: "exclamationmark.triangle.fill"
+                    )
+                    .font(.subheadline)
+                    .foregroundStyle(Color.warningAmber)
+
+                    #if DEBUG
+                    if let detailCacheDiagnostic {
+                        Text(detailCacheDiagnostic)
+                            .font(.caption2.monospaced())
+                            .foregroundStyle(.secondary)
+                            .textSelection(.enabled)
+                    }
+                    #endif
+                }
                 .padding(12)
                 .frame(maxWidth: .infinity, alignment: .leading)
                 .background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))
@@ -256,7 +336,7 @@ struct DataTypeSnapshotDetailView: View {
                     .frame(maxWidth: .infinity, alignment: .leading)
                     .background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))
 
-            case .idle, .loading:
+            case .loading:
                 HStack(spacing: 8) {
                     ProgressView()
                     Text("Analyzing record changes...")
@@ -266,6 +346,7 @@ struct DataTypeSnapshotDetailView: View {
                 .frame(maxWidth: .infinity, alignment: .leading)
                 .padding(12)
                 .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
+                }
             }
         }
     }
@@ -285,6 +366,19 @@ struct DataTypeSnapshotDetailView: View {
     @ViewBuilder
     private var temporalDistributionSection: some View {
         if previousSnapshot != nil, currentTypeCount != nil, !isCurrentTypeContentAliasToPrevious {
+            if !hasTemporalDistributionCache {
+                VStack(alignment: .leading, spacing: 8) {
+                    Label(
+                        "Temporal distribution is available only when precomputed cache exists for this snapshot pair.",
+                        systemImage: "info.circle"
+                    )
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                }
+                .padding(12)
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
+            } else {
             Button {
                 showTemporalDistribution = true
             } label: {
@@ -313,6 +407,7 @@ struct DataTypeSnapshotDetailView: View {
                 .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
             }
             .buttonStyle(.plain)
+            }
         }
     }
 
@@ -332,14 +427,45 @@ struct DataTypeSnapshotDetailView: View {
         .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 12))
     }
 
+    private func typeDeltaSummaryText(_ typeDelta: TypeDelta) -> String {
+        switch typeDelta.transition {
+        case .unchanged:
+            return "No metric-level change recorded."
+        case .changed:
+            if typeDelta.countDelta == 0 {
+                return "Content changed while count stayed the same."
+            }
+            let prefix = typeDelta.countDelta > 0 ? "+" : ""
+            return "Count delta: \(prefix)\(typeDelta.countDelta)."
+        case .appeared:
+            return "Metric appeared in this snapshot."
+        case .disappeared:
+            return "Metric disappeared in this snapshot."
+        }
+    }
+
+    private func quickStat(label: String, value: String, color: Color = .primary) -> some View {
+        VStack(alignment: .leading, spacing: 2) {
+            Text(label)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+            Text(value)
+                .font(.subheadline.weight(.semibold).monospacedDigit())
+                .foregroundStyle(color)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+
     @MainActor
     private func loadRecordDiff() async {
         guard previousSnapshot != nil else {
+            detailCacheDiagnostic = nil
             diffState = .loaded(.empty)
             return
         }
 
         if isCurrentTypeContentAliasToPrevious {
+            detailCacheDiagnostic = nil
             diffState = .loaded(.empty)
             return
         }
@@ -348,11 +474,14 @@ struct DataTypeSnapshotDetailView: View {
         let previousCount = previousTypeCount?.count ?? 0
 
         guard currentCount >= 0, previousCount >= 0 else {
+            detailCacheDiagnostic = "counts-invalid current=\(currentCount) previous=\(previousCount)"
             diffState = .unavailable
             return
         }
 
-        guard let cache = currentDetailCache() else {
+        let resolution = currentDetailCacheResolution()
+        detailCacheDiagnostic = resolution?.diagnostic
+        guard let cache = resolution?.cache else {
             diffState = .unavailable
             return
         }
@@ -361,14 +490,20 @@ struct DataTypeSnapshotDetailView: View {
     }
 
     @MainActor
-    private func currentDetailCache() -> TypeCountDetailCache? {
+    private func currentDetailCacheResolution() -> TypeCountDetailCacheResolution? {
         if isCurrentTypeContentAliasToPrevious {
-            return nil
+            return TypeCountDetailCacheResolution(
+                cache: nil,
+                diagnostic: "alias-to-previous"
+            )
         }
 
         if let cache = currentTypeCount?.detailCache,
            cache.matchesBaseline(previousSnapshot?.id) {
-            return cache
+            return TypeCountDetailCacheResolution(
+                cache: cache,
+                diagnostic: "resolver-v4 phase=cache-hit-view"
+            )
         }
 
         guard let currentTypeCount,
@@ -376,30 +511,12 @@ struct DataTypeSnapshotDetailView: View {
             return nil
         }
 
-        MemoryLog.log("dataTypeDetail.detailCache.buildBegin", metadata: [
-            "source": "detailView",
-            "type": currentTypeCount.typeIdentifier,
-            "currentCount": "\(currentTypeCount.count)",
-            "previousCount": "\(previousTypeCount?.count ?? 0)",
-            "currentArchive": currentTypeCount.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",
-            "previousArchive": previousTypeCount?.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",
-            "isAlias": "\(currentTypeCount.isContentAlias)"
-        ])
-        let cache = TypeCountDetailCacheBuilder.build(
-            current: currentTypeCount,
+        return currentTypeCount.resolveDetailCacheWithDiagnostics(
             previous: previousTypeCount,
-            baselineSnapshotID: previousSnapshot.id
+            baselineSnapshotID: previousSnapshot.id,
+            context: modelContext,
+            source: "dataTypeDetail"
         )
-        MemoryLog.log("dataTypeDetail.detailCache.buildEnd", metadata: [
-            "source": "detailView",
-            "type": currentTypeCount.typeIdentifier,
-            "cacheBuilt": "\(cache != nil)"
-        ])
-        currentTypeCount.setDetailCache(cache)
-        if cache != nil {
-            try? modelContext.save()
-        }
-        return cache
     }
 }
 


+105 -164

HealthProbe/Views/Snapshots/SnapshotDetailView.swift

View

+                         let snapshot: HealthSnapshot
+                         let baseline: HealthSnapshot?
+                         let profile: DeviceProfile?
+                    -    private let contextRadius = 3
+                         @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]
+                    -    private let diffService = SnapshotDiffService.shared
+                    -    @State private var xAxisMode: EvolutionXAxisMode = .snapshots
+                    +    @Query private var allDeltas: [SnapshotDelta]
+                         @State private var displayedSnapshot: HealthSnapshot?
+                         private var currentSnapshot: HealthSnapshot {
+                             displayedSnapshot ?? snapshot
+                    -    private var sortedTypeCounts: [TypeCount] {
+                    -        (currentSnapshot.typeCounts ?? []).sorted {
+                    -            $0.displayName.localizedCompare($1.displayName) == .orderedAscending
+                    -        }
+                    +    private var currentDelta: SnapshotDelta? {
+                    +        allDeltas.first { $0.toSnapshotID == currentSnapshot.id }
+                    -    private var baselineTypeMap: [String: TypeCount] {
+                    -        Dictionary(
+                    -            uniqueKeysWithValues: (baseline?.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
+                    -        )
+                    +    private var currentDeltaSummary: SnapshotDeltaListSummary? {
+                    +        currentDelta?.listSummary
+                    -    private var totalCount: Int {
+                    -        sortedTypeCounts.reduce(0) { partial, typeCount in
+                    -            typeCount.count > 0 ? partial + typeCount.count : partial
+                    -        }
+                    -    }
+                    -    private var snapshotEarliestRecordDate: Date? {
+                    -        sortedTypeCounts
+                    -            .filter { !$0.isUnsupported && $0.count > 0 }
+                    -            .compactMap(\.earliestDate)
+                    -            .min()
+                    -    }
+                    -    private var snapshotNewestRecordDate: Date? {
+                    -        sortedTypeCounts
+                    -            .filter { !$0.isUnsupported && $0.count > 0 }
+                    -            .compactMap(\.latestDate)
+                    -            .max()
+                    +    private var allTypeDeltas: [TypeDelta] {
+                    +        (currentDelta?.typeDeltas ?? [])
+                    +            .sorted { $0.displayName.localizedCompare($1.displayName) == .orderedAscending }
+                         private var deviceDisplayName: String {
+                    -    private var timelineContextSnapshots: [HealthSnapshot] {
+                    -        guard let currentIndex = timelineSnapshots.firstIndex(where: { $0.id == currentSnapshot.id }) else {
+                    -            return [currentSnapshot]
+                    -        }
+                    -        let desiredCount = contextRadius * 2 + 1
+                    -        var start = max(0, currentIndex - contextRadius)
+                    -        var end = min(timelineSnapshots.count - 1, currentIndex + contextRadius)
+                    -        let currentCount = end - start + 1
+                    -        if currentCount < desiredCount {
+                    -            let missing = desiredCount - currentCount
+                    -            let extraBefore = min(start, missing)
+                    -            start -= extraBefore
+                    -            let remaining = missing - extraBefore
+                    -            let availableAfter = timelineSnapshots.count - 1 - end
+                    -            let extraAfter = min(availableAfter, remaining)
+                    -            end += extraAfter
+                    -            if extraAfter < remaining {
+                    -                let finalRemaining = remaining - extraAfter
+                    -                let availableBefore = start
+                    -                let finalExtraBefore = min(availableBefore, finalRemaining)
+                    -                start -= finalExtraBefore
+                    -            }
+                    -        }
+                    -        return Array(timelineSnapshots[start...end])
+                    -    }
+                    -    private var isTimelineContextTrimmed: Bool {
+                    -        timelineContextSnapshots.count < timelineSnapshots.count
+                    -    }
+                    -    private var timelineSnapshotNumbers: [UUID: Int] {
+                    -        Dictionary(
+                    -            uniqueKeysWithValues: timelineSnapshots.enumerated().map { index, snapshot in
+                    -                (snapshot.id, index + 1)
+                    -            }
+                    -        )
+                    -    }
+                    -    private var evolutionSeries: [TypeEvolutionSeries] {
+                    -        sortedTypeCounts.compactMap { typeCount in
+                    -            let points = timelineContextSnapshots.compactMap { candidate -> TypeEvolutionPoint? in
+                    -                guard let candidateTypeCount = candidate.typeCounts?.first(where: {
+                    -                    $0.typeIdentifier == typeCount.typeIdentifier
+                    -                }),
+                    -                      candidateTypeCount.count >= 0
+                    -                else {
+                    -                    return nil
+                    -                }
+                    -                return TypeEvolutionPoint(
+                    -                    snapshotID: candidate.id,
+                    -                    timestamp: candidate.timestamp,
+                    -                    count: candidateTypeCount.count
+                    -                )
+                    -            }
+                    -            guard !points.isEmpty else { return nil }
+                    -            return TypeEvolutionSeries(
+                    -                typeIdentifier: typeCount.typeIdentifier,
+                    -                displayName: typeCount.displayName,
+                    -                points: points
+                    -            )
+                    -        }
+                    -    }
+                         @State private var showShareSheet = false
+                         @State private var pdfExportURL: URL?
+                         @State private var isExporting = false
+                                         // Data Range
+                                         SnapshotDataRangeIndicator(
+                    -                        oldestRecordDate: snapshotEarliestRecordDate,
+                    -                        newestRecordDate: snapshotNewestRecordDate,
+                    +                        oldestRecordDate: currentSnapshot.cachedEarliestRecordDate,
+                    +                        newestRecordDate: currentSnapshot.cachedLatestRecordDate,
+                                             quality: currentSnapshot.snapshotQuality
+                                         // Summary Stats (compact)
+                                         VStack(spacing: 12) {
+                    -                        HStack(spacing: 16) {
+                    -                            statCompact(label: "Types", value: "\(sortedTypeCounts.count)")
+                    -                            Divider()
+                    -                            statCompact(label: "Records", value: "\(totalCount)")
+                    +                        if currentSnapshot.hasCurrentCachedSummary {
+                    +                            HStack(spacing: 16) {
+                    +                                statCompact(label: "Types", value: "\(currentSnapshot.cachedTypeCount)")
+                    +                                Divider()
+                    +                                statCompact(label: "Records", value: "\(currentSnapshot.cachedRecordCount)")
+                    +                            }
+                    +                            .font(.caption)
+                    +                            .foregroundStyle(.secondary)
+                    +                        } else {
+                    +                            Text("Snapshot summary unavailable")
+                    +                                .font(.caption)
+                    +                                .foregroundStyle(.secondary)
+                    +                                .frame(maxWidth: .infinity, alignment: .center)
+                    -                        .font(.caption)
+                    -                        .foregroundStyle(.secondary)
+                                         .padding(12)
+                                         .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 12))
+                         @ViewBuilder
+                         private func comparisonSection(baseline: HealthSnapshot) -> some View {
+                    -        let delta = diffService.totalAbsoluteChange(current: currentSnapshot, baseline: baseline)
+                    +        let delta = currentDeltaSummary?.absoluteRecordChangeCount ?? 0
+                             let deltaPercent = computeDeltaPercent(delta: delta, baseline: baseline)
+                    -        let isSignificant = delta > 0 || (deltaPercent > 10)
+                    +        let affectedMetricCount = currentDeltaSummary?.affectedMetricCount ?? 0
+                    +        let isSignificant = delta > 0 || affectedMetricCount > 0 || (deltaPercent > 10)
+                             DisclosureGroup {
+                                 VStack(alignment: .leading, spacing: 12) {
+                                         Text(days == 0 ? "Same day" : "\(days) days")
+                                             .foregroundStyle(.secondary)
+                    +                if let summary = currentDeltaSummary {
+                    +                    Divider()
+                    +                    DetailRow(label: "Changed Metrics") {
+                    +                        Text("\(summary.affectedMetricCount)")
+                    +                            .foregroundStyle(.secondary)
+                    +                    }
+                    +                    Divider()
+                    +                    DetailRow(label: "Record Changes") {
+                    +                        Text("\(summary.absoluteRecordChangeCount)")
+                    +                            .foregroundStyle(.secondary)
+                    +                    }
+                    +                }
+                                 .padding(.top, 8)
+                             } label: {
+                         private func computeDeltaPercent(delta: Int, baseline: HealthSnapshot) -> Double {
+                    -        let baselineTotal = (baseline.typeCounts ?? [])
+                    -            .filter { $0.count > 0 }
+                    -            .reduce(0) { $0 + $1.count }
+                    +        let baselineTotal = baseline.hasCurrentCachedSummary ? baseline.cachedRecordCount : 0
+                             return baselineTotal > 0 ? Double(delta) / Double(baselineTotal) * 100 : 0
+                         private var evolutionSection: some View {
+                             Section("Data Types") {
+                    -            HStack {
+                    -                Spacer()
+                    -                Picker("X-Axis", selection: $xAxisMode) {
+                    -                    ForEach(EvolutionXAxisMode.allCases.reversed()) { mode in
+                    -                        Text(mode.title).tag(mode)
+                    -                    }
+                    -                }
+                    -                .pickerStyle(.segmented)
+                    -                Spacer()
+                    -            }
+                    -            if evolutionSeries.isEmpty {
+                    -                if sortedTypeCounts.isEmpty {
+                    -                    Text("No tracked data types in this snapshot.")
+                    -                        .foregroundStyle(.secondary)
+                    -                } else {
+                    -                    ForEach(sortedTypeCounts) { typeCount in
+                    -                        NavigationLink {
+                    -                            DataTypeSnapshotDetailView(
+                    -                                snapshot: currentSnapshot,
+                    -                                typeIdentifier: typeCount.typeIdentifier,
+                    -                                displayName: typeCount.displayName
+                    -                            )
+                    -                        } label: {
+                    -                            SnapshotTypeCountRow(
+                    -                                typeCount: typeCount,
+                    -                                baselineTypeCount: baselineTypeMap[typeCount.typeIdentifier]
+                    -                            )
+                    -                        }
+                    -                    }
+                    -                }
+                    +            if baseline == nil {
+                    +                Text("This snapshot starts the chain, so no baseline comparison is available.")
+                    +                    .foregroundStyle(.secondary)
+                    +            } else if currentDelta == nil {
+                    +                Text("Cached metric summary unavailable for this snapshot.")
+                    +                    .foregroundStyle(.secondary)
+                    +            } else if allTypeDeltas.isEmpty {
+                    +                Text("No data types are available for this snapshot.")
+                    +                    .foregroundStyle(.secondary)
+                                 } else {
+                    -                ForEach(evolutionSeries) { series in
+                    +                ForEach(allTypeDeltas) { typeDelta in
+                                         NavigationLink {
+                                             DataTypeSnapshotDetailView(
+                                                 snapshot: currentSnapshot,
+                    -                            typeIdentifier: series.typeIdentifier,
+                    -                            displayName: series.displayName
+                    +                            typeIdentifier: typeDelta.typeIdentifier,
+                    +                            displayName: typeDelta.displayName
+                                         } label: {
+                    -                        TypeEvolutionChart(
+                    -                            series: series,
+                    -                            contextSnapshots: timelineContextSnapshots,
+                    -                            xAxisMode: xAxisMode,
+                    -                            selectedSnapshotID: currentSnapshot.id,
+                    -                            selectedTimestamp: currentSnapshot.timestamp,
+                    -                            snapshotNumbers: timelineSnapshotNumbers,
+                    -                            baselineTypeCount: baselineTypeMap[series.typeIdentifier]
+                    -                        )
+                    +                        SnapshotTypeDeltaRow(typeDelta: typeDelta)
+                    +            }
+                    +        }
+                    +    }
+                    +}
+                    -                if isTimelineContextTrimmed {
+                    -                    Text("Charts show only the local window: 3 snapshots before and 3 after the current one.")
+                    -                        .font(.caption)
+                    -                        .foregroundStyle(.secondary)
+                    -                }
+                    +private struct SnapshotTypeDeltaRow: View {
+                    +    let typeDelta: TypeDelta
+                    +    private var deltaLabel: String {
+                    +        switch typeDelta.transition {
+                    +        case .changed:
+                    +            if typeDelta.countDelta == 0 {
+                    +                return "Content changed"
+                    +            let prefix = typeDelta.countDelta > 0 ? "+" : ""
+                    +            return "\(prefix)\(typeDelta.countDelta) records"
+                    +        case .appeared:
+                    +            return "Appeared"
+                    +        case .disappeared:
+                    +            return "Disappeared"
+                    +        case .unchanged:
+                    +            return "No changes"
+                    +        }
+                    +    }
+                    +    private var deltaColor: Color {
+                    +        switch typeDelta.transition {
+                    +        case .disappeared:
+                    +            return .criticalRed
+                    +        case .changed, .appeared:
+                    +            return .warningAmber
+                    +        case .unchanged:
+                    +            return .secondary
+                    +    var body: some View {
+                    +        HStack(spacing: 12) {
+                    +            VStack(alignment: .leading, spacing: 3) {
+                    +                Text(typeDelta.displayName)
+                    +                    .font(.subheadline)
+                    +                Text(typeDelta.typeIdentifier)
+                    +                    .font(.caption2)
+                    +                    .foregroundStyle(.secondary)
+                    +                    .lineLimit(1)
+                    +                    .truncationMode(.middle)
+                    +            }
+                    +            Spacer()
+                    +            Text(deltaLabel)
+                    +                .font(.caption.weight(.semibold))
+                    +                .foregroundStyle(deltaColor)
+                    +        }
+                    +        .accessibilityElement(children: .combine)
+                    +    }
+                     private enum EvolutionXAxisMode: String, CaseIterable, Identifiable {
+                                 profile: DeviceProfile(deviceID: "preview-device")
+                    -    .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
+                    +    .modelContainer(for: [HealthSnapshot.self, SnapshotDelta.self, TypeDelta.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)

+102 -26

HealthProbe/Views/Snapshots/SnapshotsView.swift

View

@@ -6,6 +6,7 @@ struct SnapshotsView: View {
     @Environment(\.modelContext) private var modelContext
     @Environment(AppSettings.self) private var appSettings
     @Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]
+    @Query private var allDeltas: [SnapshotDelta]
     @Query private var deviceProfiles: [DeviceProfile]
     @State private var viewModel = SnapshotsViewModel()
 
@@ -21,6 +22,22 @@ struct SnapshotsView: View {
         return allSnapshots.filter { selected.contains($0.deviceID) }
     }
 
+    private var snapshotItems: [SnapshotListItem] {
+        let baselines = viewModel.baselines(for: displayedSnapshots)
+        let deltaSummaryBySnapshotID = allDeltas.reduce(into: [UUID: SnapshotDeltaListSummary]()) { partial, delta in
+            partial[delta.toSnapshotID] = delta.listSummary
+        }
+
+        return displayedSnapshots.map { snapshot in
+            SnapshotListItem(
+                snapshot: snapshot,
+                baseline: baselines[snapshot.id] ?? nil,
+                deltaSummary: deltaSummaryBySnapshotID[snapshot.id],
+                showsDeltaSummary: viewModel.comparisonMode == .previous
+            )
+        }
+    }
+
     private var knownDevices: [DeviceEntry] {
         let currentID = AppSettings.currentDeviceID
         var ids = Set(allSnapshots.map { $0.deviceID })
@@ -57,6 +74,9 @@ struct SnapshotsView: View {
             }
             .navigationTitle("Snapshots")
             .toolbar { toolbarContent }
+            .task(id: allDeltas.count) {
+                repairDeltaListSummariesIfNeeded()
+            }
             .onChange(of: appSettings.selectedDeviceIDs) {
                 if let baseline = viewModel.selectedBaseline,
                    !displayedSnapshots.contains(where: { $0.id == baseline.id }) {
@@ -70,29 +90,31 @@ struct SnapshotsView: View {
     // MARK: - List
 
     private var snapshotList: some View {
-        List(displayedSnapshots) { snapshot in
+        List(snapshotItems) { item in
             NavigationLink {
                 SnapshotDetailView(
-                    snapshot: snapshot,
-                    baseline: viewModel.baseline(for: snapshot, in: displayedSnapshots),
-                    profile: profileMap[snapshot.deviceID]
+                    snapshot: item.snapshot,
+                    baseline: item.baseline,
+                    profile: profileMap[item.snapshot.deviceID]
                 )
             } label: {
                 SnapshotRow(
-                    snapshot: snapshot,
-                    baseline: viewModel.baseline(for: snapshot, in: displayedSnapshots),
-                    isSelectedBaseline: viewModel.selectedBaseline?.id == snapshot.id,
-                    profile: profileMap[snapshot.deviceID]
+                    snapshot: item.snapshot,
+                    baseline: item.baseline,
+                    deltaSummary: item.deltaSummary,
+                    showsDeltaSummary: item.showsDeltaSummary,
+                    isSelectedBaseline: viewModel.selectedBaseline?.id == item.snapshot.id,
+                    profile: profileMap[item.snapshot.deviceID]
                 )
             }
             .swipeActions(edge: .leading) {
                 Button {
-                    viewModel.toggleBaseline(snapshot)
+                    viewModel.toggleBaseline(item.snapshot)
                     viewModel.comparisonMode = .selected
                 } label: {
                     Label(
-                        viewModel.selectedBaseline?.id == snapshot.id ? "Unset Baseline" : "Set as Baseline",
-                        systemImage: viewModel.selectedBaseline?.id == snapshot.id ? "pin.slash" : "pin"
+                        viewModel.selectedBaseline?.id == item.snapshot.id ? "Unset Baseline" : "Set as Baseline",
+                        systemImage: viewModel.selectedBaseline?.id == item.snapshot.id ? "pin.slash" : "pin"
                     )
                 }
                 .tint(.indigo)
@@ -100,7 +122,7 @@ struct SnapshotsView: View {
             .swipeActions(edge: .trailing) {
                 Button(role: .destructive) {
                     do {
-                        try SnapshotLifecycleService.delete(snapshot, context: modelContext)
+                        try SnapshotLifecycleService.delete(item.snapshot, context: modelContext)
                     } catch {
                         // Failure is surfaced via the navigation stack; no silent discard
                     }
@@ -161,6 +183,23 @@ struct SnapshotsView: View {
         .tint(isMulti ? .orange : .accentColor)
         .accessibilityLabel("Select devices – \(selected.count) selected")
     }
+
+    private func repairDeltaListSummariesIfNeeded() {
+        do {
+            _ = try DeltaService.rebuildMissingListSummaries(context: modelContext, maxCount: 64)
+        } catch {
+            // Keep the list responsive even if summary repair fails.
+        }
+    }
+}
+
+private struct SnapshotListItem: Identifiable {
+    let snapshot: HealthSnapshot
+    let baseline: HealthSnapshot?
+    let deltaSummary: SnapshotDeltaListSummary?
+    let showsDeltaSummary: Bool
+
+    var id: UUID { snapshot.id }
 }
 
 // MARK: - Row
@@ -168,10 +207,11 @@ struct SnapshotsView: View {
 private struct SnapshotRow: View {
     let snapshot: HealthSnapshot
     let baseline: HealthSnapshot?
+    let deltaSummary: SnapshotDeltaListSummary?
+    let showsDeltaSummary: Bool
     let isSelectedBaseline: Bool
     let profile: DeviceProfile?
 
-    private let diffService = SnapshotDiffService.shared
     private static let dateFormatter: DateFormatter = {
         let f = DateFormatter()
         f.dateStyle = .medium
@@ -188,12 +228,44 @@ private struct SnapshotRow: View {
         DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
     }
 
-    private var metricCount: Int {
-        snapshot.typeCounts?.count ?? 0
+    private var metricCountLabel: String? {
+        guard snapshot.hasCurrentCachedSummary else { return nil }
+        return snapshot.cachedTypeCount == 1 ? "1 metric" : "\(snapshot.cachedTypeCount) metrics"
+    }
+
+    private var deltaSummaryText: String? {
+        guard let deltaSummary else { return nil }
+
+        var parts: [String] = []
+
+        if deltaSummary.absoluteRecordChangeCount > 0 {
+            parts.append("\(deltaSummary.absoluteRecordChangeCount) record change\(deltaSummary.absoluteRecordChangeCount == 1 ? "" : "s")")
+        }
+
+        if deltaSummary.changedMetricCount > 0 {
+            parts.append("\(deltaSummary.changedMetricCount) metric change\(deltaSummary.changedMetricCount == 1 ? "" : "s")")
+        }
+
+        if deltaSummary.appearedMetricCount > 0 {
+            parts.append("\(deltaSummary.appearedMetricCount) metric appeared")
+        }
+
+        if deltaSummary.disappearedMetricCount > 0 {
+            parts.append("\(deltaSummary.disappearedMetricCount) metric disappeared")
+        }
+
+        if parts.isEmpty {
+            return "No changes"
+        }
+
+        return parts.joined(separator: " • ")
     }
 
-    private var metricCountLabel: String {
-        metricCount == 1 ? "1 metric" : "\(metricCount) metrics"
+    private var deltaSummaryColor: Color {
+        guard let deltaSummary else { return .secondary }
+        if deltaSummary.disappearedMetricCount > 0 { return Color.criticalRed }
+        if deltaSummary.hasChanges { return Color.warningAmber }
+        return Color.healthyGreen
     }
 
     private var hasOSVersionChange: Bool {
@@ -230,9 +302,11 @@ private struct SnapshotRow: View {
                 Text(deviceDisplayName)
                     .font(.caption)
                     .foregroundStyle(.secondary)
-                Label(metricCountLabel, systemImage: "list.bullet.rectangle")
-                    .font(.caption)
-                    .foregroundStyle(.secondary)
+                if let metricCountLabel {
+                    Label(metricCountLabel, systemImage: "list.bullet.rectangle")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
                 if hasOSVersionChange {
                     Label("OS \(snapshot.osVersion)", systemImage: "gearshape.fill")
                         .font(.caption)
@@ -250,14 +324,16 @@ private struct SnapshotRow: View {
                     .foregroundStyle(Color.warningAmber)
             }
 
-            if let baseline {
-                let delta = diffService.totalAbsoluteChange(current: snapshot, baseline: baseline)
+            if showsDeltaSummary,
+               let deltaSummaryText {
                 HStack(spacing: 4) {
-                    Image(systemName: "arrow.triangle.2.circlepath")
-                    Text(delta == 0 ? "No changes" : "\(delta) record changes")
+                    Image(systemName: deltaSummary == nil || deltaSummary?.hasChanges == false
+                          ? "checkmark.circle"
+                          : "arrow.triangle.2.circlepath")
+                    Text(deltaSummaryText)
                 }
                 .font(.caption)
-                .foregroundStyle(delta == 0 ? Color.healthyGreen : Color.warningAmber)
+                .foregroundStyle(deltaSummaryColor)
             }
         }
         .padding(.vertical, 2)
@@ -294,6 +370,6 @@ private struct SnapshotRow: View {
 
 #Preview {
     SnapshotsView()
-        .modelContainer(for: [HealthSnapshot.self, TypeCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
+    .modelContainer(for: [HealthSnapshot.self, SnapshotDelta.self, TypeDelta.self, TypeCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
         .environment(AppSettings())
 }


	@@ -152,6 +152,18 @@ final class TypeDistributionBin {
152	152	// snapshot to contain real changes for some metrics while long-stable metrics behave
153	153	// as temporal aliases and skip per-type detail cache/diff work.
154	154
	155	+// Interface updated 2026-05-17 — see AGENTS.md
	156	+// Models/HealthSnapshot stores cached overview scalars for UI consumption:
	157	+// tracked type count, aggregate record count, and overall oldest/newest record dates.
	158	+// These values must be computed during snapshot save while TypeCount data is already
	159	+// in memory, so snapshot list/detail screens never recompute them by traversing
	160	+// snapshot.typeCounts on the UI thread.
	161	+
	162	+// Interface updated 2026-05-17 — see AGENTS.md
	163	+// Models/SnapshotDelta stores cached list/detail summary scalars derived from TypeDelta.
	164	+// Overview screens consume these scalars and type-delta summaries directly instead of
	165	+// recalculating per-snapshot changes from HealthSnapshot.typeCounts.
	166	+
155	167	// Models/DetectedAnomaly.swift
156	168	enum AnomalyType: String, Codable {
157	169	case historicalInsertion = "historical_insertion"

	@@ -14,6 +14,21 @@ struct HealthRecordValue: Codable, Hashable, Identifiable, Sendable {
14	14	enum HealthRecordArchive {
15	15	private static let compactMagic = Data([0x48, 0x50, 0x52, 0x41, 0x32]) // HPRA2
16	16
	17	+ static func isCompact(_ data: Data) -> Bool {
	18	+ data.starts(with: compactMagic)
	19	+ }
	20	+
	21	+ static func compactedIfNeeded(_ data: Data) -> Data? {
	22	+ if isCompact(data) {
	23	+ return data
	24	+ }
	25	+
	26	+ guard let decoded = decode(data) else {
	27	+ return nil
	28	+ }
	29	+ return encode(decoded)
	30	+ }
	31	+
17	32	static func encode(_ values: [HealthRecordValue]) -> Data? {
18	33	guard let typeIdentifier = values.first?.typeIdentifier else {
19	34	return encodeCompact(typeIdentifier: "", values: [])
	@@ -29,7 +44,7 @@ enum HealthRecordArchive {
29	44	}
30	45
31	46	static func forEachRecord(in data: Data, _ body: (HealthRecordValue) -> Void) -> Bool {
32		- if data.starts(with: compactMagic) {
	47	+ if isCompact(data) {
33	48	return forEachCompactRecord(in: data, body)
34	49	}
35	50
	@@ -47,9 +62,9 @@ enum HealthRecordArchive {
47	62
48	63	MemoryLog.log("healthRecordArchive.fingerprintSet.begin", metadata: [
49	64	"archive": MemoryLog.format(UInt64(data.count)),
50		- "format": data.starts(with: compactMagic) ? "compact" : "plist"
	65	+ "format": isCompact(data) ? "compact" : "plist"
51	66	])
52		- if data.starts(with: compactMagic) {
	67	+ if isCompact(data) {
53	68	let fingerprints = compactFingerprintSet(from: data)
54	69	MemoryLog.log("healthRecordArchive.fingerprintSet.end", metadata: [
55	70	"archive": MemoryLog.format(UInt64(data.count)),

	@@ -1,6 +1,7 @@
1	1	import Foundation
2	2	import SwiftData
3	3
	4	+// Interface updated 2026-05-17 — see AGENTS.md
4	5	@Model final class HealthSnapshot {
5	6	var id: UUID = UUID()
6	7	var timestamp: Date = Date.now
	@@ -24,6 +25,11 @@ import SwiftData
24	25	var monitoredTypeSetHash: String = ""
25	26	var monitoredRegistryVersion: Int = 0
26	27	var yearlyCountTimezoneIdentifier: String = ""
	28	+ var cachedSummaryVersion: Int = 0
	29	+ var cachedTypeCount: Int = 0
	30	+ var cachedRecordCount: Int = 0
	31	+ var cachedEarliestRecordDate: Date?
	32	+ var cachedLatestRecordDate: Date?
27	33	@Relationship(deleteRule: .cascade, inverse: \TypeCount.snapshot)
28	34	var typeCounts: [TypeCount]? = []
29	35
	@@ -38,6 +44,41 @@ import SwiftData
38	44	}
39	45
40	46	extension HealthSnapshot {
	47	+ static let currentCachedSummaryVersion = 1
	48	+
	49	+ static func timelineSort(_ lhs: HealthSnapshot, _ rhs: HealthSnapshot) -> Bool {
	50	+ if lhs.timestamp != rhs.timestamp {
	51	+ return lhs.timestamp < rhs.timestamp
	52	+ }
	53	+ if lhs.localSequenceNumber != rhs.localSequenceNumber {
	54	+ return lhs.localSequenceNumber < rhs.localSequenceNumber
	55	+ }
	56	+ return lhs.id.uuidString < rhs.id.uuidString
	57	+ }
	58	+
	59	+ func previousInTimeline(_ snapshots: [HealthSnapshot]) -> HealthSnapshot? {
	60	+ if let previousSnapshotID,
	61	+ let previous = snapshots.first(where: { $0.id == previousSnapshotID }) {
	62	+ return previous
	63	+ }
	64	+
	65	+ let orderedSnapshots = snapshots.sorted(by: Self.timelineSort)
	66	+ guard let index = orderedSnapshots.firstIndex(where: { $0.id == id }),
	67	+ index > 0 else {
	68	+ return nil
	69	+ }
	70	+ return orderedSnapshots[index - 1]
	71	+ }
	72	+
	73	+ func nextInTimeline(_ snapshots: [HealthSnapshot]) -> HealthSnapshot? {
	74	+ let orderedSnapshots = snapshots.sorted(by: Self.timelineSort)
	75	+ guard let index = orderedSnapshots.firstIndex(where: { $0.id == id }),
	76	+ index < orderedSnapshots.count - 1 else {
	77	+ return nil
	78	+ }
	79	+ return orderedSnapshots[index + 1]
	80	+ }
	81	+
41	82	var snapshotQuality: SnapshotQuality {
42	83	get { SnapshotQuality(rawValue: snapshotQualityRaw) ?? .complete }
43	84	set { snapshotQualityRaw = newValue.rawValue }
	@@ -55,4 +96,8 @@ extension HealthSnapshot {
55	96	var contentRepresentativeSnapshotID: UUID {
56	97	contentEquivalentSnapshotID ?? id
57	98	}
	99	+
	100	+ var hasCurrentCachedSummary: Bool {
	101	+ cachedSummaryVersion >= Self.currentCachedSummaryVersion
	102	+ }
58	103	}

	@@ -36,6 +36,7 @@ enum DeltaService {
36	36	if current.isContentAlias,
37	37	current.contentEquivalentSnapshotID == previous.contentRepresentativeSnapshotID {
38	38	delta.typeDeltas = []
	39	+ updateListSummary(for: delta, typeDeltas: [])
39	40	context.insert(delta)
40	41	try context.save()
41	42	return delta
	@@ -75,11 +76,33 @@ enum DeltaService {
75	76	}
76	77
77	78	delta.typeDeltas = typeDeltas
	79	+ updateListSummary(for: delta, typeDeltas: typeDeltas)
78	80	context.insert(delta)
79	81	try context.save()
80	82	return delta
81	83	}
82	84
	85	+ @discardableResult
	86	+ static func rebuildMissingListSummaries(context: ModelContext, maxCount: Int) throws -> Bool {
	87	+ guard maxCount > 0 else { return false }
	88	+
	89	+ let summaryVersion = SnapshotDelta.currentListSummaryVersion
	90	+ var descriptor = FetchDescriptor<SnapshotDelta>(
	91	+ predicate: #Predicate<SnapshotDelta> { $0.listSummaryVersion < summaryVersion }
	92	+ )
	93	+ descriptor.fetchLimit = maxCount
	94	+
	95	+ let deltas = try context.fetch(descriptor)
	96	+ guard !deltas.isEmpty else { return false }
	97	+
	98	+ for delta in deltas {
	99	+ updateListSummary(for: delta, typeDeltas: delta.typeDeltas ?? [])
	100	+ }
	101	+
	102	+ try context.save()
	103	+ return true
	104	+ }
	105	+
83	106	// MARK: - Delta merge (for intermediate snapshot deletion)
84	107
85	108	// snapshotBefore and snapshotAfter are the real surrounding snapshots (N-1 and N+1).
	@@ -127,6 +150,7 @@ enum DeltaService {
127	150	}
128	151	}
129	152	merged.typeDeltas = mergedTypeDeltas
	153	+ updateListSummary(for: merged, typeDeltas: mergedTypeDeltas)
130	154	return merged
131	155	}
132	156
	@@ -197,6 +221,36 @@ enum DeltaService {
197	221	return td
198	222	}
199	223
	224	+ private static func updateListSummary(for delta: SnapshotDelta, typeDeltas: [TypeDelta]) {
	225	+ var absoluteRecordChangeCount = 0
	226	+ var changedMetricCount = 0
	227	+ var appearedMetricCount = 0
	228	+ var disappearedMetricCount = 0
	229	+
	230	+ for typeDelta in typeDeltas {
	231	+ switch typeDelta.transition {
	232	+ case .unchanged:
	233	+ continue
	234	+ case .changed:
	235	+ changedMetricCount += 1
	236	+ if typeDelta.qualityBefore == .complete,
	237	+ typeDelta.qualityAfter == .complete {
	238	+ absoluteRecordChangeCount += abs(typeDelta.countDelta)
	239	+ }
	240	+ case .appeared:
	241	+ appearedMetricCount += 1
	242	+ case .disappeared:
	243	+ disappearedMetricCount += 1
	244	+ }
	245	+ }
	246	+
	247	+ delta.absoluteRecordChangeCount = absoluteRecordChangeCount
	248	+ delta.changedMetricCount = changedMetricCount
	249	+ delta.appearedMetricCount = appearedMetricCount
	250	+ delta.disappearedMetricCount = disappearedMetricCount
	251	+ delta.listSummaryVersion = SnapshotDelta.currentListSummaryVersion
	252	+ }
	253	+
200	254	private static func historicalBaselinePreviousTypeCount(
201	255	typeID: String,
202	256	prev: TypeCount?,

	@@ -133,6 +133,7 @@ final class HealthKitService {
133	133	}
134	134
135	135	snapshot.snapshotQuality = deriveSnapshotQuality(from: typeCounts)
	136	+ updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
136	137
137	138	configureSnapshotMetadata(
138	139	snapshot,
	@@ -171,6 +172,8 @@ final class HealthKitService {
171	172	return snapshot
172	173	}
173	174
	175	+ updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
	176	+
174	177	configureSnapshotMetadata(
175	178	snapshot,
176	179	typeCounts: typeCounts,
	@@ -199,6 +202,8 @@ final class HealthKitService {
199	202	return try await savePartialSnapshot(snapshot, in: context)
200	203	}
201	204
	205	+ updateSnapshotSummaryCache(snapshot: snapshot, typeCounts: typeCounts)
	206	+
202	207	configureSnapshotMetadata(
203	208	snapshot,
204	209	typeCounts: typeCounts,
	@@ -245,6 +250,21 @@ final class HealthKitService {
245	250	try await runPostSavePipeline(snapshot: snapshot, typeCounts: typeCounts, context: context)
246	251	}
247	252
	253	+ private func updateSnapshotSummaryCache(
	254	+ snapshot: HealthSnapshot,
	255	+ typeCounts: [TypeCount]
	256	+ ) {
	257	+ snapshot.cachedSummaryVersion = HealthSnapshot.currentCachedSummaryVersion
	258	+ snapshot.cachedTypeCount = typeCounts.count
	259	+ snapshot.cachedRecordCount = typeCounts.reduce(0) { partial, typeCount in
	260	+ typeCount.count > 0 ? partial + typeCount.count : partial
	261	+ }
	262	+
	263	+ let datedTypeCounts = typeCounts.filter { !$0.isUnsupported && $0.count > 0 }
	264	+ snapshot.cachedEarliestRecordDate = datedTypeCounts.compactMap(\.earliestDate).min()
	265	+ snapshot.cachedLatestRecordDate = datedTypeCounts.compactMap(\.latestDate).max()
	266	+ }
	267	+
248	268	private func configureSnapshotMetadata(
249	269	_ snapshot: HealthSnapshot,
250	270	typeCounts: [TypeCount],

	@@ -55,12 +55,12 @@ final class ObserverService {
55	55	// MARK: - Callback handling
56	56
57	57	private func handleObserverCallback(typeID: String) {
58		- lock.lock()
59		- let now = Date()
60		- lastCallbackTimestamp = now
61		- accumulatedTypeIDs.insert(typeID)
62		- let alreadyScheduled = debounceTask != nil
63		- lock.unlock()
	58	+ let alreadyScheduled = lock.withLock {
	59	+ let now = Date()
	60	+ lastCallbackTimestamp = now
	61	+ accumulatedTypeIDs.insert(typeID)
	62	+ return debounceTask != nil
	63	+ }
64	64
65	65	guard !alreadyScheduled else { return }
66	66
	@@ -74,9 +74,9 @@ final class ObserverService {
74	74
75	75	@MainActor
76	76	private func tryCreateObserverSnapshot() async {
77		- lock.lock()
78		- debounceTask = nil
79		- lock.unlock()
	77	+ lock.withLock {
	78	+ debounceTask = nil
	79	+ }
80	80
81	81	guard let container = modelContainer else {
82	82	logger.error("ObserverService: no modelContainer — cannot create snapshot")
	@@ -111,10 +111,10 @@ final class ObserverService {
111	111	logger.error("ObserverService: failed to create snapshot — \(error)")
112	112	}
113	113
114		- lock.lock()
115		- accumulatedTypeIDs.removeAll()
116		- lastCallbackTimestamp = nil
117		- lock.unlock()
	114	+ lock.withLock {
	115	+ accumulatedTypeIDs.removeAll()
	116	+ lastCallbackTimestamp = nil
	117	+ }
118	118	}
119	119
120	120	// MARK: - Type classification

	@@ -14,9 +14,8 @@ enum SnapshotLifecycleService {
14	14	}
15	15
16	16	static func previewDeletion(of snapshot: HealthSnapshot, context: ModelContext) throws -> DeletionPreview {
17		- let allDeltas = try fetchDeltas(context: context)
18		- let incomingDelta = allDeltas.first { $0.toSnapshotID == snapshot.id }
19		- let outgoingDelta = allDeltas.first { $0.fromSnapshotID == snapshot.id }
	17	+ let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)
	18	+ let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)
20	19
21	20	var willBreakChain = false
22	21	var description = ""
	@@ -62,9 +61,8 @@ enum SnapshotLifecycleService {
62	61	}
63	62
64	63	static func delete(_ snapshot: HealthSnapshot, context: ModelContext) throws {
65		- let allDeltas = try fetchDeltas(context: context)
66		- let incomingDelta = allDeltas.first { $0.toSnapshotID == snapshot.id }
67		- let outgoingDelta = allDeltas.first { $0.fromSnapshotID == snapshot.id }
	64	+ let incomingDelta = try fetchIncomingDelta(toSnapshotID: snapshot.id, context: context)
	65	+ let outgoingDelta = try fetchOutgoingDelta(fromSnapshotID: snapshot.id, context: context)
68	66
69	67	let deviceID = snapshot.deviceID
70	68	let version = Bundle.main.appBuildVersion
	@@ -92,7 +90,7 @@ enum SnapshotLifecycleService {
92	90	for typeCount in nextSnap.typeCounts ?? [] {
93	91	typeCount.contentEquivalentTypeCountID = nil
94	92	}
95		- refreshDetailCaches(for: nextSnap, baseline: nil)
	93	+ invalidateDetailCaches(for: nextSnap)
96	94	}
97	95	context.delete(outgoing)
98	96	context.delete(snapshot)
	@@ -119,7 +117,7 @@ enum SnapshotLifecycleService {
119	117
120	118	nextSnap.previousSnapshotID = prevSnap.id
121	119	_ = refreshContentEquivalence(for: nextSnap, baseline: prevSnap)
122		- refreshDetailCaches(for: nextSnap, baseline: prevSnap)
	120	+ invalidateDetailCaches(for: nextSnap)
123	121	context.delete(d1)
124	122	context.delete(d2)
125	123	context.delete(snapshot)
	@@ -155,9 +153,6 @@ enum SnapshotLifecycleService {
155	153	"maxTypeCounts": "\(maxTypeCounts)"
156	154	])
157	155
158		- let descriptor = FetchDescriptor<HealthSnapshot>(
159		- sortBy: [SortDescriptor(\.timestamp, order: .forward)]
160		- )
161	156	let snapshotIDs = try context.fetch(FetchDescriptor<HealthSnapshot>()).map { $0.id }
162	157	MemoryLog.log("snapshotLifecycle.rebuildMissingDetailCaches.snapshotsFetched", metadata: [
163	158	"snapshotCount": "\(snapshotIDs.count)"
	@@ -279,8 +274,18 @@ enum SnapshotLifecycleService {
279	274
280	275	// MARK: - Fetch helpers
281	276
282		- private static func fetchDeltas(context: ModelContext) throws -> [SnapshotDelta] {
283		- try context.fetch(FetchDescriptor<SnapshotDelta>())
	277	+ private static func fetchIncomingDelta(toSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {
	278	+ let descriptor = FetchDescriptor<SnapshotDelta>(
	279	+ predicate: #Predicate<SnapshotDelta> { $0.toSnapshotID == snapshotID }
	280	+ )
	281	+ return try context.fetch(descriptor).first
	282	+ }
	283	+
	284	+ private static func fetchOutgoingDelta(fromSnapshotID snapshotID: UUID, context: ModelContext) throws -> SnapshotDelta? {
	285	+ let descriptor = FetchDescriptor<SnapshotDelta>(
	286	+ predicate: #Predicate<SnapshotDelta> { $0.fromSnapshotID == snapshotID }
	287	+ )
	288	+ return try context.fetch(descriptor).first
284	289	}
285	290
286	291	private static func fetchSnapshot(id: UUID, context: ModelContext) throws -> HealthSnapshot? {
	@@ -290,31 +295,9 @@ enum SnapshotLifecycleService {
290	295	return try context.fetch(descriptor).first
291	296	}
292	297
293		- private static func refreshDetailCaches(for snapshot: HealthSnapshot, baseline: HealthSnapshot?) {
294		- guard let baseline else {
295		- for typeCount in snapshot.typeCounts ?? [] {
296		- typeCount.setDetailCache(nil)
297		- }
298		- return
299		- }
300		-
301		- let baselineByType = Dictionary(
302		- uniqueKeysWithValues: (baseline.typeCounts ?? []).map { ($0.typeIdentifier, $0) }
303		- )
304		-
	298	+ private static func invalidateDetailCaches(for snapshot: HealthSnapshot) {
305	299	for typeCount in snapshot.typeCounts ?? [] {
306		- if typeCount.isContentAlias {
307		- typeCount.setDetailCache(nil)
308		- continue
309		- }
310		-
311		- typeCount.setDetailCache(
312		- TypeCountDetailCacheBuilder.build(
313		- current: typeCount,
314		- previous: baselineByType[typeCount.typeIdentifier],
315		- baselineSnapshotID: baseline.id
316		- )
317		- )
	300	+ typeCount.setDetailCache(nil)
318	301	}
319	302	}
320	303

	@@ -10,7 +10,7 @@ struct MemorySample: Sendable {
10	10	enum MemoryLog {
11	11	static let detailCacheBuildFootprintLimit: UInt64 = 1_500 * 1_024 * 1_024
12	12
13		- static func log(_ event: String, metadata: [String: String] = [:]) {
	13	+ nonisolated static func log(_ event: String, metadata: [String: String] = [:]) {
14	14	let sample = currentSample()
15	15	let metadataText = metadata
16	16	.sorted { $0.key < $1.key }
	@@ -27,7 +27,7 @@ enum MemoryLog {
27	27	print(line)
28	28	}
29	29
30		- static func startPulse(_ event: String, metadata: [String: String] = [:], intervalSeconds: UInt64 = 1) -> Task<Void, Never> {
	30	+ nonisolated static func startPulse(_ event: String, metadata: [String: String] = [:], intervalSeconds: UInt64 = 1) -> Task<Void, Never> {
31	31	Task.detached(priority: .background) {
32	32	var previousSample = currentSample()
33	33	var previousTime = Date()
	@@ -59,23 +59,23 @@ enum MemoryLog {
59	59	}
60	60	}
61	61
62		- static func format(_ bytes: UInt64) -> String {
	62	+ nonisolated static func format(_ bytes: UInt64) -> String {
63	63	ByteCountFormatter.string(fromByteCount: Int64(bytes), countStyle: .memory)
64	64	}
65	65
66		- static func isFootprintAtOrAbove(_ bytes: UInt64) -> Bool {
	66	+ nonisolated static func isFootprintAtOrAbove(_ bytes: UInt64) -> Bool {
67	67	guard let currentSample = currentSample() else { return false }
68	68	return currentSample.physicalFootprintBytes >= bytes
69	69	}
70	70
71		- private static func signedFormat(_ bytes: Int64) -> String {
	71	+ nonisolated private static func signedFormat(_ bytes: Int64) -> String {
72	72	if bytes >= 0 {
73	73	return "+\(format(UInt64(bytes)))"
74	74	}
75	75	return "-\(format(UInt64(-bytes)))"
76	76	}
77	77
78		- private static func currentSample() -> MemorySample? {
	78	+ nonisolated private static func currentSample() -> MemorySample? {
79	79	var info = task_vm_info_data_t()
80	80	var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size / MemoryLayout<integer_t>.size)
81	81	let result = withUnsafeMutablePointer(to: &info) { pointer in

	@@ -1,4 +1,5 @@
1	1	import Foundation
	2	+import SwiftData
2	3
3	4	enum BinningStrategy: String, CaseIterable, Equatable {
4	5	case day = "Zi"
	@@ -114,17 +115,18 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
114	115	private var disappearedByDate: [Date: Int] = [:]
115	116	private var unchangedByDate: [Date: Int] = [:]
116	117
117		- func load(current: TypeCount?, previous: TypeCount?) async {
	118	+ func load(current: TypeCount?, previous: TypeCount?, context: ModelContext) async {
118	119	defer { isLoading = false }
	120	+ error = nil
	121	+ hasData = false
119	122
120	123	guard let current else {
121	124	error = "No current snapshot data"
122	125	return
123	126	}
124	127
125		- guard let cache = current.detailCache,
126		- cache.matchesBaseline(previous?.snapshot?.id) else {
127		- error = "Precomputed detail data is unavailable for this snapshot. Create a new snapshot to generate temporal detail caches."
	128	+ guard let cache = resolveDetailCache(current: current, previous: previous, context: context) else {
	129	+ error = "Record detail data could not be computed for this snapshot pair."
128	130	return
129	131	}
130	132
	@@ -141,6 +143,19 @@ final class DataTypeTemporalDistributionViewModel: Sendable {
141	143	await rebuildBinsBackground()
142	144	}
143	145
	146	+ private func resolveDetailCache(
	147	+ current: TypeCount,
	148	+ previous: TypeCount?,
	149	+ context: ModelContext
	150	+ ) -> TypeCountDetailCache? {
	151	+ let baselineID = previous?.snapshot?.id
	152	+ guard let cache = current.detailCache,
	153	+ cache.matchesBaseline(baselineID) else {
	154	+ return nil
	155	+ }
	156	+ return cache
	157	+ }
	158	+
144	159	private func indexDailyBins(_ bins: [TypeCountDailyChangeBin]) {
145	160	addedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.added) })
146	161	disappearedByDate = Dictionary(uniqueKeysWithValues: bins.map { ($0.dayStart, $0.disappeared) })

	@@ -26,11 +26,34 @@ final class SnapshotsViewModel {
26	26	var comparisonMode: ComparisonMode = .previous
27	27	var selectedBaseline: HealthSnapshot?
28	28
	29	+ func baselines(for snapshots: [HealthSnapshot]) -> [UUID: HealthSnapshot] {
	30	+ let orderedDescending = snapshots.sorted { $0.timestamp > $1.timestamp }
	31	+
	32	+ return snapshots.reduce(into: [UUID: HealthSnapshot]()) { partial, snapshot in
	33	+ partial[snapshot.id] = baseline(
	34	+ for: snapshot,
	35	+ in: snapshots,
	36	+ orderedDescending: orderedDescending
	37	+ )
	38	+ }
	39	+ }
	40	+
29	41	func baseline(for snapshot: HealthSnapshot, in snapshots: [HealthSnapshot]) -> HealthSnapshot? {
30		- let sorted = snapshots.sorted { $0.timestamp > $1.timestamp }
	42	+ baseline(
	43	+ for: snapshot,
	44	+ in: snapshots,
	45	+ orderedDescending: snapshots.sorted { $0.timestamp > $1.timestamp }
	46	+ )
	47	+ }
	48	+
	49	+ private func baseline(
	50	+ for snapshot: HealthSnapshot,
	51	+ in snapshots: [HealthSnapshot],
	52	+ orderedDescending: [HealthSnapshot]
	53	+ ) -> HealthSnapshot? {
31	54	switch comparisonMode {
32	55	case .previous:
33		- return sorted.first { $0.timestamp < snapshot.timestamp }
	56	+ return orderedDescending.first { $0.timestamp < snapshot.timestamp }
34	57	case .selected:
35	58	return selectedBaseline
36	59	case .relativeTime(let interval):

	@@ -6,6 +6,7 @@ struct DataTypeTemporalDistributionView: View {
6	6	let previous: TypeCount?
7	7	let displayName: String
8	8
	9	+ @Environment(\.modelContext) private var modelContext
9	10	@State private var viewModel = DataTypeTemporalDistributionViewModel()
10	11	@State private var isRecomputing = false
11	12	@State private var isZoomed: Bool = false
	@@ -30,21 +31,17 @@ struct DataTypeTemporalDistributionView: View {
30	31	}
31	32
32	33	private var timelineSnapshots: [HealthSnapshot] {
33		- allSnapshots.filter { current?.snapshot?.deviceID ?? "" == $0.deviceID }
	34	+ allSnapshots
	35	+ .filter { current?.snapshot?.deviceID ?? "" == $0.deviceID }
	36	+ .sorted(by: HealthSnapshot.timelineSort)
34	37	}
35	38
36	39	private var previousSnapshot: HealthSnapshot? {
37		- guard let current = currentSnapshot,
38		- let idx = timelineSnapshots.firstIndex(where: { $0.id == current.id }),
39		- idx > 0 else { return nil }
40		- return timelineSnapshots[idx - 1]
	40	+ currentSnapshot?.previousInTimeline(timelineSnapshots)
41	41	}
42	42
43	43	private var nextSnapshot: HealthSnapshot? {
44		- guard let current = currentSnapshot,
45		- let idx = timelineSnapshots.firstIndex(where: { $0.id == current.id }),
46		- idx < timelineSnapshots.count - 1 else { return nil }
47		- return timelineSnapshots[idx + 1]
	44	+ currentSnapshot?.nextInTimeline(timelineSnapshots)
48	45	}
49	46
50	47	var body: some View {
	@@ -83,7 +80,7 @@ struct DataTypeTemporalDistributionView: View {
83	80	}
84	81	}
85	82	.task {
86		- await viewModel.load(current: current, previous: previous)
	83	+ await viewModel.load(current: current, previous: previous, context: modelContext)
87	84	}
88	85	}
89	86

	@@ -1,4 +1,5 @@
1	1	import SwiftUI
	2	+import SwiftData
2	3
3	4	struct RecordChangeEvolutionChart: View {
4	5	let snapshots: [HealthSnapshot]
	@@ -6,8 +7,10 @@ struct RecordChangeEvolutionChart: View {
6	7	let typeIdentifier: String
7	8	let displayName: String
8	9
	10	+ @Query private var allDeltas: [SnapshotDelta]
	11	+
9	12	private var sortedSnapshots: [HealthSnapshot] {
10		- snapshots.sorted { $0.timestamp < $1.timestamp }
	13	+ snapshots.sorted(by: HealthSnapshot.timelineSort)
11	14	}
12	15
13	16	private var currentIndex: Int? {
	@@ -21,6 +24,10 @@ struct RecordChangeEvolutionChart: View {
21	24	return Array(sortedSnapshots[start..<end])
22	25	}
23	26
	27	+ private var diffTaskID: String {
	28	+ ([typeIdentifier, currentSnapshotID.uuidString] + contextSnapshots.map { $0.id.uuidString }).joined(separator: "\|")
	29	+ }
	30	+
24	31	private var maxCount: Int {
25	32	let counts = contextSnapshots.compactMap { snapshot in
26	33	snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }?.count
	@@ -30,9 +37,8 @@ struct RecordChangeEvolutionChart: View {
30	37
31	38	private var maxNegativeCount: Int {
32	39	var max = 0
33		- for i in 0..<contextSnapshots.count {
34		- let snapshot = contextSnapshots[i]
35		- let previousSnapshot = i > 0 ? contextSnapshots[i - 1] : nil
	40	+ for snapshot in contextSnapshots {
	41	+ let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
36	42	let diff = recordDiff(current: snapshot, previous: previousSnapshot)
37	43	max = Swift.max(max, diff.disappeared)
38	44	}
	@@ -41,19 +47,31 @@ struct RecordChangeEvolutionChart: View {
41	47
42	48	private func recordDiff(current: HealthSnapshot, previous: HealthSnapshot?) -> (added: Int, disappeared: Int) {
43	49	guard let previous = previous else { return (0, 0) }
44		- guard let currentType = current.typeCounts?
45		- .first(where: { $0.typeIdentifier == typeIdentifier }) else {
	50	+
	51	+ guard let delta = allDeltas.first(where: {
	52	+ $0.fromSnapshotID == previous.id &&
	53	+ $0.toSnapshotID == current.id
	54	+ }),
	55	+ let typeDelta = delta.typeDeltas?.first(where: { $0.typeIdentifier == typeIdentifier }) else {
46	56	return (0, 0)
47	57	}
48	58
49		- if let previousType = previous.typeCounts?.first(where: { $0.typeIdentifier == typeIdentifier }),
50		- currentType.contentEquivalentTypeCountID == previousType.contentRepresentativeTypeCountID {
	59	+ switch typeDelta.transition {
	60	+ case .unchanged:
51	61	return (0, 0)
	62	+ case .changed:
	63	+ if typeDelta.countDelta > 0 {
	64	+ return (typeDelta.countDelta, 0)
	65	+ }
	66	+ if typeDelta.countDelta < 0 {
	67	+ return (0, abs(typeDelta.countDelta))
	68	+ }
	69	+ return (0, 0)
	70	+ case .appeared:
	71	+ return (max(typeDelta.countDelta, 1), 0)
	72	+ case .disappeared:
	73	+ return (0, max(abs(typeDelta.countDelta), 1))
52	74	}
53		-
54		- guard let cache = currentType.detailCache,
55		- cache.matchesBaseline(previous.id) else { return (0, 0) }
56		- return (cache.addedCount, cache.disappearedCount)
57	75	}
58	76
59	77	var body: some View {
	@@ -155,7 +173,7 @@ struct RecordChangeEvolutionChart: View {
155	173	let typeCount = snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }
156	174	let count = typeCount?.count ?? 0
157	175	let isCurrent = snapshot.id == currentSnapshotID
158		- let previousSnapshot = index > 0 ? contextSnapshots[index - 1] : nil
	176	+ let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
159	177	let diff = recordDiff(current: snapshot, previous: previousSnapshot)
160	178	let unchanged = count - diff.added
161	179
	@@ -204,6 +222,7 @@ struct RecordChangeEvolutionChart: View {
204	222	}
205	223	.frame(maxWidth: .infinity)
206	224	}
	225	+
207	226	}
208	227
209	228	#Preview {

	@@ -8,12 +8,14 @@ struct DataTypeSnapshotDetailView: View {
8	8
9	9	@Environment(\.modelContext) private var modelContext
10	10	@Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]
	11	+ @Query private var allDeltas: [SnapshotDelta]
11	12
12	13	@State private var displayedSnapshot: HealthSnapshot?
13	14	@State private var diffState: RecordDiffState = .idle
14	15	@State private var showAddedRecords = false
15	16	@State private var showDisappearedRecords = false
16	17	@State private var showTemporalDistribution = false
	18	+ @State private var detailCacheDiagnostic: String?
17	19
18	20	private var currentSnapshot: HealthSnapshot {
19	21	displayedSnapshot ?? snapshot
	@@ -26,12 +28,11 @@ struct DataTypeSnapshotDetailView: View {
26	28	}
27	29	return candidate.deviceID == currentSnapshot.deviceID
28	30	}
	31	+ .sorted(by: HealthSnapshot.timelineSort)
29	32	}
30	33
31	34	private var previousSnapshot: HealthSnapshot? {
32		- guard let currentSnapshotIndex = timelineSnapshots.firstIndex(where: { $0.id == currentSnapshot.id }),
33		- currentSnapshotIndex > 0 else { return nil }
34		- return timelineSnapshots[currentSnapshotIndex - 1]
	35	+ currentSnapshot.previousInTimeline(timelineSnapshots)
35	36	}
36	37
37	38	private var currentTypeCount: TypeCount? {
	@@ -48,6 +49,24 @@ struct DataTypeSnapshotDetailView: View {
48	49	return currentTypeCount.contentEquivalentTypeCountID == previousTypeCount.contentRepresentativeTypeCountID
49	50	}
50	51
	52	+ private var hasTemporalDistributionCache: Bool {
	53	+ guard let currentTypeCount,
	54	+ let previousSnapshot else { return false }
	55	+ return currentTypeCount.detailCache?.matchesBaseline(previousSnapshot.id) == true
	56	+ }
	57	+
	58	+ private var currentDelta: SnapshotDelta? {
	59	+ guard let previousSnapshot else { return nil }
	60	+ return allDeltas.first {
	61	+ $0.toSnapshotID == currentSnapshot.id &&
	62	+ $0.fromSnapshotID == previousSnapshot.id
	63	+ }
	64	+ }
	65	+
	66	+ private var currentTypeDelta: TypeDelta? {
	67	+ currentDelta?.typeDeltas?.first { $0.typeIdentifier == typeIdentifier }
	68	+ }
	69	+
51	70	private var diffTaskID: String {
52	71	[
53	72	currentSnapshot.id.uuidString,
	@@ -71,6 +90,25 @@ struct DataTypeSnapshotDetailView: View {
71	90	countText(for: previousTypeCount)
72	91	}
73	92
	93	+ private var quickCurrentCountValue: Int {
	94	+ max(currentTypeCount?.count ?? 0, 0)
	95	+ }
	96	+
	97	+ private var quickPreviousCountValue: Int {
	98	+ max(previousTypeCount?.count ?? 0, 0)
	99	+ }
	100	+
	101	+ private var quickAddedDisappeared: (added: Int, disappeared: Int, exact: Bool) {
	102	+ if let previousSnapshot,
	103	+ let cache = currentTypeCount?.detailCache,
	104	+ cache.matchesBaseline(previousSnapshot.id) {
	105	+ return (cache.addedCount, cache.disappearedCount, true)
	106	+ }
	107	+
	108	+ let net = (currentTypeDelta?.countDelta ?? (quickCurrentCountValue - quickPreviousCountValue))
	109	+ return (max(net, 0), max(-net, 0), false)
	110	+ }
	111	+
74	112	var body: some View {
75	113	ScrollView {
76	114	VStack(spacing: 16) {
	@@ -194,10 +232,10 @@ struct DataTypeSnapshotDetailView: View {
194	232	}
195	233	}
196	234
197		- @ViewBuilder
198	235	private var recordChangeComparisonSection: some View {
199		- if previousSnapshot != nil {
200		- switch diffState {
	236	+ Group {
	237	+ if previousSnapshot != nil {
	238	+ switch diffState {
201	239	case .loaded(let diff):
202	240	RecordChangeComparisonCard(
203	241	displayName: displayName,
	@@ -237,13 +275,55 @@ struct DataTypeSnapshotDetailView: View {
237	275	)
238	276	}
239	277
	278	+ case .idle:
	279	+ VStack(alignment: .leading, spacing: 10) {
	280	+ let quick = quickAddedDisappeared
	281	+
	282	+ VStack(alignment: .leading, spacing: 8) {
	283	+ Text("Quick Counts")
	284	+ .font(.subheadline.weight(.semibold))
	285	+
	286	+ HStack {
	287	+ quickStat(label: "Current", value: "\(quickCurrentCountValue)")
	288	+ quickStat(label: "Previous", value: "\(quickPreviousCountValue)")
	289	+ }
	290	+
	291	+ HStack {
	292	+ quickStat(label: "New", value: "\(quick.added)", color: .healthyGreen)
	293	+ quickStat(label: "Disappeared", value: "\(quick.disappeared)", color: .criticalRed)
	294	+ }
	295	+
	296	+ if !quick.exact {
	297	+ Text("New/Disappeared are net values from snapshot delta. Exact split needs deep record analysis.")
	298	+ .font(.caption2)
	299	+ .foregroundStyle(.secondary)
	300	+ }
	301	+ }
	302	+ .padding(12)
	303	+ .background(Color(.systemBackground).opacity(0.35), in: RoundedRectangle(cornerRadius: 8))
	304	+ }
	305	+ .padding(12)
	306	+ .frame(maxWidth: .infinity, alignment: .leading)
	307	+ .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
	308	+
240	309	case .unavailable:
241		- Label(
242		- "Record detail cache is unavailable for this snapshot pair.",
243		- systemImage: "exclamationmark.triangle.fill"
244		- )
245		- .font(.subheadline)
246		- .foregroundStyle(Color.warningAmber)
	310	+ VStack(alignment: .leading, spacing: 8) {
	311	+ Label(
	312	+ "Record detail cache is unavailable for this snapshot pair.",
	313	+ systemImage: "exclamationmark.triangle.fill"
	314	+ )
	315	+ .font(.subheadline)
	316	+ .foregroundStyle(Color.warningAmber)
	317	+
	318	+ #if DEBUG
	319	+ if let detailCacheDiagnostic {
	320	+ Text(detailCacheDiagnostic)
	321	+ .font(.caption2.monospaced())
	322	+ .foregroundStyle(.secondary)
	323	+ .textSelection(.enabled)
	324	+ }
	325	+ #endif
	326	+ }
247	327	.padding(12)
248	328	.frame(maxWidth: .infinity, alignment: .leading)
249	329	.background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))
	@@ -256,7 +336,7 @@ struct DataTypeSnapshotDetailView: View {
256	336	.frame(maxWidth: .infinity, alignment: .leading)
257	337	.background(Color.warningAmber.opacity(0.12), in: RoundedRectangle(cornerRadius: 8))
258	338
259		- case .idle, .loading:
	339	+ case .loading:
260	340	HStack(spacing: 8) {
261	341	ProgressView()
262	342	Text("Analyzing record changes...")
	@@ -266,6 +346,7 @@ struct DataTypeSnapshotDetailView: View {
266	346	.frame(maxWidth: .infinity, alignment: .leading)
267	347	.padding(12)
268	348	.background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
	349	+ }
269	350	}
270	351	}
271	352	}
	@@ -285,6 +366,19 @@ struct DataTypeSnapshotDetailView: View {
285	366	@ViewBuilder
286	367	private var temporalDistributionSection: some View {
287	368	if previousSnapshot != nil, currentTypeCount != nil, !isCurrentTypeContentAliasToPrevious {
	369	+ if !hasTemporalDistributionCache {
	370	+ VStack(alignment: .leading, spacing: 8) {
	371	+ Label(
	372	+ "Temporal distribution is available only when precomputed cache exists for this snapshot pair.",
	373	+ systemImage: "info.circle"
	374	+ )
	375	+ .font(.caption)
	376	+ .foregroundStyle(.secondary)
	377	+ }
	378	+ .padding(12)
	379	+ .frame(maxWidth: .infinity, alignment: .leading)
	380	+ .background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
	381	+ } else {
288	382	Button {
289	383	showTemporalDistribution = true
290	384	} label: {
	@@ -313,6 +407,7 @@ struct DataTypeSnapshotDetailView: View {
313	407	.background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
314	408	}
315	409	.buttonStyle(.plain)
	410	+ }
316	411	}
317	412	}
318	413
	@@ -332,14 +427,45 @@ struct DataTypeSnapshotDetailView: View {
332	427	.background(Color(.systemBackground).opacity(0.5), in: RoundedRectangle(cornerRadius: 12))
333	428	}
334	429
	430	+ private func typeDeltaSummaryText(_ typeDelta: TypeDelta) -> String {
	431	+ switch typeDelta.transition {
	432	+ case .unchanged:
	433	+ return "No metric-level change recorded."
	434	+ case .changed:
	435	+ if typeDelta.countDelta == 0 {
	436	+ return "Content changed while count stayed the same."
	437	+ }
	438	+ let prefix = typeDelta.countDelta > 0 ? "+" : ""
	439	+ return "Count delta: \(prefix)\(typeDelta.countDelta)."
	440	+ case .appeared:
	441	+ return "Metric appeared in this snapshot."
	442	+ case .disappeared:
	443	+ return "Metric disappeared in this snapshot."
	444	+ }
	445	+ }
	446	+
	447	+ private func quickStat(label: String, value: String, color: Color = .primary) -> some View {
	448	+ VStack(alignment: .leading, spacing: 2) {
	449	+ Text(label)
	450	+ .font(.caption2)
	451	+ .foregroundStyle(.secondary)
	452	+ Text(value)
	453	+ .font(.subheadline.weight(.semibold).monospacedDigit())
	454	+ .foregroundStyle(color)
	455	+ }
	456	+ .frame(maxWidth: .infinity, alignment: .leading)
	457	+ }
	458	+
335	459	@MainActor
336	460	private func loadRecordDiff() async {
337	461	guard previousSnapshot != nil else {
	462	+ detailCacheDiagnostic = nil
338	463	diffState = .loaded(.empty)
339	464	return
340	465	}
341	466
342	467	if isCurrentTypeContentAliasToPrevious {
	468	+ detailCacheDiagnostic = nil
343	469	diffState = .loaded(.empty)
344	470	return
345	471	}
	@@ -348,11 +474,14 @@ struct DataTypeSnapshotDetailView: View {
348	474	let previousCount = previousTypeCount?.count ?? 0
349	475
350	476	guard currentCount >= 0, previousCount >= 0 else {
	477	+ detailCacheDiagnostic = "counts-invalid current=\(currentCount) previous=\(previousCount)"
351	478	diffState = .unavailable
352	479	return
353	480	}
354	481
355		- guard let cache = currentDetailCache() else {
	482	+ let resolution = currentDetailCacheResolution()
	483	+ detailCacheDiagnostic = resolution?.diagnostic
	484	+ guard let cache = resolution?.cache else {
356	485	diffState = .unavailable
357	486	return
358	487	}
	@@ -361,14 +490,20 @@ struct DataTypeSnapshotDetailView: View {
361	490	}
362	491
363	492	@MainActor
364		- private func currentDetailCache() -> TypeCountDetailCache? {
	493	+ private func currentDetailCacheResolution() -> TypeCountDetailCacheResolution? {
365	494	if isCurrentTypeContentAliasToPrevious {
366		- return nil
	495	+ return TypeCountDetailCacheResolution(
	496	+ cache: nil,
	497	+ diagnostic: "alias-to-previous"
	498	+ )
367	499	}
368	500
369	501	if let cache = currentTypeCount?.detailCache,
370	502	cache.matchesBaseline(previousSnapshot?.id) {
371		- return cache
	503	+ return TypeCountDetailCacheResolution(
	504	+ cache: cache,
	505	+ diagnostic: "resolver-v4 phase=cache-hit-view"
	506	+ )
372	507	}
373	508
374	509	guard let currentTypeCount,
	@@ -376,30 +511,12 @@ struct DataTypeSnapshotDetailView: View {
376	511	return nil
377	512	}
378	513
379		- MemoryLog.log("dataTypeDetail.detailCache.buildBegin", metadata: [
380		- "source": "detailView",
381		- "type": currentTypeCount.typeIdentifier,
382		- "currentCount": "\(currentTypeCount.count)",
383		- "previousCount": "\(previousTypeCount?.count ?? 0)",
384		- "currentArchive": currentTypeCount.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",
385		- "previousArchive": previousTypeCount?.recordArchiveData.map { MemoryLog.format(UInt64($0.count)) } ?? "nil",
386		- "isAlias": "\(currentTypeCount.isContentAlias)"
387		- ])
388		- let cache = TypeCountDetailCacheBuilder.build(
389		- current: currentTypeCount,
	514	+ return currentTypeCount.resolveDetailCacheWithDiagnostics(
390	515	previous: previousTypeCount,
391		- baselineSnapshotID: previousSnapshot.id
	516	+ baselineSnapshotID: previousSnapshot.id,
	517	+ context: modelContext,
	518	+ source: "dataTypeDetail"
392	519	)
393		- MemoryLog.log("dataTypeDetail.detailCache.buildEnd", metadata: [
394		- "source": "detailView",
395		- "type": currentTypeCount.typeIdentifier,
396		- "cacheBuilt": "\(cache != nil)"
397		- ])
398		- currentTypeCount.setDetailCache(cache)
399		- if cache != nil {
400		- try? modelContext.save()
401		- }
402		- return cache
403	520	}
404	521	}
405	522

	@@ -6,6 +6,7 @@ struct SnapshotsView: View {
6	6	@Environment(\.modelContext) private var modelContext
7	7	@Environment(AppSettings.self) private var appSettings
8	8	@Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]
	9	+ @Query private var allDeltas: [SnapshotDelta]
9	10	@Query private var deviceProfiles: [DeviceProfile]
10	11	@State private var viewModel = SnapshotsViewModel()
11	12
	@@ -21,6 +22,22 @@ struct SnapshotsView: View {
21	22	return allSnapshots.filter { selected.contains($0.deviceID) }
22	23	}
23	24
	25	+ private var snapshotItems: [SnapshotListItem] {
	26	+ let baselines = viewModel.baselines(for: displayedSnapshots)
	27	+ let deltaSummaryBySnapshotID = allDeltas.reduce(into: [UUID: SnapshotDeltaListSummary]()) { partial, delta in
	28	+ partial[delta.toSnapshotID] = delta.listSummary
	29	+ }
	30	+
	31	+ return displayedSnapshots.map { snapshot in
	32	+ SnapshotListItem(
	33	+ snapshot: snapshot,
	34	+ baseline: baselines[snapshot.id] ?? nil,
	35	+ deltaSummary: deltaSummaryBySnapshotID[snapshot.id],
	36	+ showsDeltaSummary: viewModel.comparisonMode == .previous
	37	+ )
	38	+ }
	39	+ }
	40	+
24	41	private var knownDevices: [DeviceEntry] {
25	42	let currentID = AppSettings.currentDeviceID
26	43	var ids = Set(allSnapshots.map { $0.deviceID })
	@@ -57,6 +74,9 @@ struct SnapshotsView: View {
57	74	}
58	75	.navigationTitle("Snapshots")
59	76	.toolbar { toolbarContent }
	77	+ .task(id: allDeltas.count) {
	78	+ repairDeltaListSummariesIfNeeded()
	79	+ }
60	80	.onChange(of: appSettings.selectedDeviceIDs) {
61	81	if let baseline = viewModel.selectedBaseline,
62	82	!displayedSnapshots.contains(where: { $0.id == baseline.id }) {
	@@ -70,29 +90,31 @@ struct SnapshotsView: View {
70	90	// MARK: - List
71	91
72	92	private var snapshotList: some View {
73		- List(displayedSnapshots) { snapshot in
	93	+ List(snapshotItems) { item in
74	94	NavigationLink {
75	95	SnapshotDetailView(
76		- snapshot: snapshot,
77		- baseline: viewModel.baseline(for: snapshot, in: displayedSnapshots),
78		- profile: profileMap[snapshot.deviceID]
	96	+ snapshot: item.snapshot,
	97	+ baseline: item.baseline,
	98	+ profile: profileMap[item.snapshot.deviceID]
79	99	)
80	100	} label: {
81	101	SnapshotRow(
82		- snapshot: snapshot,
83		- baseline: viewModel.baseline(for: snapshot, in: displayedSnapshots),
84		- isSelectedBaseline: viewModel.selectedBaseline?.id == snapshot.id,
85		- profile: profileMap[snapshot.deviceID]
	102	+ snapshot: item.snapshot,
	103	+ baseline: item.baseline,
	104	+ deltaSummary: item.deltaSummary,
	105	+ showsDeltaSummary: item.showsDeltaSummary,
	106	+ isSelectedBaseline: viewModel.selectedBaseline?.id == item.snapshot.id,
	107	+ profile: profileMap[item.snapshot.deviceID]
86	108	)
87	109	}
88	110	.swipeActions(edge: .leading) {
89	111	Button {
90		- viewModel.toggleBaseline(snapshot)
	112	+ viewModel.toggleBaseline(item.snapshot)
91	113	viewModel.comparisonMode = .selected
92	114	} label: {
93	115	Label(
94		- viewModel.selectedBaseline?.id == snapshot.id ? "Unset Baseline" : "Set as Baseline",
95		- systemImage: viewModel.selectedBaseline?.id == snapshot.id ? "pin.slash" : "pin"
	116	+ viewModel.selectedBaseline?.id == item.snapshot.id ? "Unset Baseline" : "Set as Baseline",
	117	+ systemImage: viewModel.selectedBaseline?.id == item.snapshot.id ? "pin.slash" : "pin"
96	118	)
97	119	}
98	120	.tint(.indigo)
	@@ -100,7 +122,7 @@ struct SnapshotsView: View {
100	122	.swipeActions(edge: .trailing) {
101	123	Button(role: .destructive) {
102	124	do {
103		- try SnapshotLifecycleService.delete(snapshot, context: modelContext)
	125	+ try SnapshotLifecycleService.delete(item.snapshot, context: modelContext)
104	126	} catch {
105	127	// Failure is surfaced via the navigation stack; no silent discard
106	128	}
	@@ -161,6 +183,23 @@ struct SnapshotsView: View {
161	183	.tint(isMulti ? .orange : .accentColor)
162	184	.accessibilityLabel("Select devices – \(selected.count) selected")
163	185	}
	186	+
	187	+ private func repairDeltaListSummariesIfNeeded() {
	188	+ do {
	189	+ _ = try DeltaService.rebuildMissingListSummaries(context: modelContext, maxCount: 64)
	190	+ } catch {
	191	+ // Keep the list responsive even if summary repair fails.
	192	+ }
	193	+ }
	194	+}
	195	+
	196	+private struct SnapshotListItem: Identifiable {
	197	+ let snapshot: HealthSnapshot
	198	+ let baseline: HealthSnapshot?
	199	+ let deltaSummary: SnapshotDeltaListSummary?
	200	+ let showsDeltaSummary: Bool
	201	+
	202	+ var id: UUID { snapshot.id }
164	203	}
165	204
166	205	// MARK: - Row
	@@ -168,10 +207,11 @@ struct SnapshotsView: View {
168	207	private struct SnapshotRow: View {
169	208	let snapshot: HealthSnapshot
170	209	let baseline: HealthSnapshot?
	210	+ let deltaSummary: SnapshotDeltaListSummary?
	211	+ let showsDeltaSummary: Bool
171	212	let isSelectedBaseline: Bool
172	213	let profile: DeviceProfile?
173	214
174		- private let diffService = SnapshotDiffService.shared
175	215	private static let dateFormatter: DateFormatter = {
176	216	let f = DateFormatter()
177	217	f.dateStyle = .medium
	@@ -188,12 +228,44 @@ private struct SnapshotRow: View {
188	228	DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
189	229	}
190	230
191		- private var metricCount: Int {
192		- snapshot.typeCounts?.count ?? 0
	231	+ private var metricCountLabel: String? {
	232	+ guard snapshot.hasCurrentCachedSummary else { return nil }
	233	+ return snapshot.cachedTypeCount == 1 ? "1 metric" : "\(snapshot.cachedTypeCount) metrics"
	234	+ }
	235	+
	236	+ private var deltaSummaryText: String? {
	237	+ guard let deltaSummary else { return nil }
	238	+
	239	+ var parts: [String] = []
	240	+
	241	+ if deltaSummary.absoluteRecordChangeCount > 0 {
	242	+ parts.append("\(deltaSummary.absoluteRecordChangeCount) record change\(deltaSummary.absoluteRecordChangeCount == 1 ? "" : "s")")
	243	+ }
	244	+
	245	+ if deltaSummary.changedMetricCount > 0 {
	246	+ parts.append("\(deltaSummary.changedMetricCount) metric change\(deltaSummary.changedMetricCount == 1 ? "" : "s")")
	247	+ }
	248	+
	249	+ if deltaSummary.appearedMetricCount > 0 {
	250	+ parts.append("\(deltaSummary.appearedMetricCount) metric appeared")
	251	+ }
	252	+
	253	+ if deltaSummary.disappearedMetricCount > 0 {
	254	+ parts.append("\(deltaSummary.disappearedMetricCount) metric disappeared")
	255	+ }
	256	+
	257	+ if parts.isEmpty {
	258	+ return "No changes"
	259	+ }
	260	+
	261	+ return parts.joined(separator: " • ")
193	262	}
194	263
195		- private var metricCountLabel: String {
196		- metricCount == 1 ? "1 metric" : "\(metricCount) metrics"
	264	+ private var deltaSummaryColor: Color {
	265	+ guard let deltaSummary else { return .secondary }
	266	+ if deltaSummary.disappearedMetricCount > 0 { return Color.criticalRed }
	267	+ if deltaSummary.hasChanges { return Color.warningAmber }
	268	+ return Color.healthyGreen
197	269	}
198	270
199	271	private var hasOSVersionChange: Bool {
	@@ -230,9 +302,11 @@ private struct SnapshotRow: View {
230	302	Text(deviceDisplayName)
231	303	.font(.caption)
232	304	.foregroundStyle(.secondary)
233		- Label(metricCountLabel, systemImage: "list.bullet.rectangle")
234		- .font(.caption)
235		- .foregroundStyle(.secondary)
	305	+ if let metricCountLabel {
	306	+ Label(metricCountLabel, systemImage: "list.bullet.rectangle")
	307	+ .font(.caption)
	308	+ .foregroundStyle(.secondary)
	309	+ }
236	310	if hasOSVersionChange {
237	311	Label("OS \(snapshot.osVersion)", systemImage: "gearshape.fill")
238	312	.font(.caption)
	@@ -250,14 +324,16 @@ private struct SnapshotRow: View {
250	324	.foregroundStyle(Color.warningAmber)
251	325	}
252	326
253		- if let baseline {
254		- let delta = diffService.totalAbsoluteChange(current: snapshot, baseline: baseline)
	327	+ if showsDeltaSummary,
	328	+ let deltaSummaryText {
255	329	HStack(spacing: 4) {
256		- Image(systemName: "arrow.triangle.2.circlepath")
257		- Text(delta == 0 ? "No changes" : "\(delta) record changes")
	330	+ Image(systemName: deltaSummary == nil \|\| deltaSummary?.hasChanges == false
	331	+ ? "checkmark.circle"
	332	+ : "arrow.triangle.2.circlepath")
	333	+ Text(deltaSummaryText)
258	334	}
259	335	.font(.caption)
260		- .foregroundStyle(delta == 0 ? Color.healthyGreen : Color.warningAmber)
	336	+ .foregroundStyle(deltaSummaryColor)
261	337	}
262	338	}
263	339	.padding(.vertical, 2)
	@@ -294,6 +370,6 @@ private struct SnapshotRow: View {
294	370
295	371	#Preview {
296	372	SnapshotsView()
297		- .modelContainer(for: [HealthSnapshot.self, TypeCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
	373	+ .modelContainer(for: [HealthSnapshot.self, SnapshotDelta.self, TypeDelta.self, TypeCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
298	374	.environment(AppSettings())
299	375	}