Refine local snapshot data type UI · f4491e3

Refine local snapshot data type UI
Browse files

bogdan committed 2 weeks ago

main

1 parent 3d4c7fb

commit f4491e3

Showing 12 changed files with 606 additions and 381 deletions

+59 -59

HealthProbe.xcodeproj/project.pbxproj

+                     	objectVersion = 77;
+                     	objects = {
+                    -/* Begin PBXFileReference section */
+                    -		439832792FA4933E003C0182 /* HealthProbe.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = HealthProbe.app; sourceTree = BUILT_PRODUCTS_DIR; };
+                    -		43A100012FA5000000000001 /* HealthProbeTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = HealthProbeTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+                    -/* End PBXFileReference section */
+                     /* Begin PBXContainerItemProxy section */
+A1000B2FA5000000000001 /* PBXContainerItemProxy */ = {
+                     			isa = PBXContainerItemProxy;
+                     		};
+                     /* End PBXContainerItemProxy section */
+                    +/* Begin PBXFileReference section */
+                    +		439832792FA4933E003C0182 /* HealthProbe.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = HealthProbe.app; sourceTree = BUILT_PRODUCTS_DIR; };
+                    +		43A100012FA5000000000001 /* HealthProbeTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = HealthProbeTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+                    +/* End PBXFileReference section */
+                     /* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
+                     		439832862FA4933F003C0182 /* Exceptions for "HealthProbe" folder in "HealthProbe" target */ = {
+                     			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+                     			};
+                     			name = Release;
+                     		};
+                    -		43A100072FA5000000000001 /* Debug */ = {
+                    -			isa = XCBuildConfiguration;
+                    -			buildSettings = {
+                    -				BUNDLE_LOADER = "$(TEST_HOST)";
+                    -				CODE_SIGN_STYLE = Automatic;
+                    -				CURRENT_PROJECT_VERSION = 1;
+                    -				DEVELOPMENT_TEAM = 9K2U3V9GZF;
+                    -				GENERATE_INFOPLIST_FILE = YES;
+                    -				IPHONEOS_DEPLOYMENT_TARGET = 26.4;
+                    -				LD_RUNPATH_SEARCH_PATHS = (
+                    -					"$(inherited)",
+                    -					"@executable_path/Frameworks",
+                    -					"@loader_path/Frameworks",
+                    -				);
+                    -				MARKETING_VERSION = 1.0;
+                    -				PRODUCT_BUNDLE_IDENTIFIER = ro.xdev.HealthProbeTests;
+                    -				PRODUCT_NAME = "$(TARGET_NAME)";
+                    -				SDKROOT = iphoneos;
+                    -				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+                    -				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+                    -				SWIFT_VERSION = 5.0;
+                    -				TARGETED_DEVICE_FAMILY = 1;
+                    -				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/HealthProbe.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/HealthProbe";
+                    -				TEST_TARGET_NAME = HealthProbe;
+                    -			};
+                    -			name = Debug;
+                    -		};
+                    -		43A100082FA5000000000001 /* Release */ = {
+                    -			isa = XCBuildConfiguration;
+                    -			buildSettings = {
+                    -				BUNDLE_LOADER = "$(TEST_HOST)";
+                    -				CODE_SIGN_STYLE = Automatic;
+                    -				CURRENT_PROJECT_VERSION = 1;
+                    -				DEVELOPMENT_TEAM = 9K2U3V9GZF;
+                    -				GENERATE_INFOPLIST_FILE = YES;
+                    -				IPHONEOS_DEPLOYMENT_TARGET = 26.4;
+                    -				LD_RUNPATH_SEARCH_PATHS = (
+                    -					"$(inherited)",
+                    -					"@executable_path/Frameworks",
+                    -					"@loader_path/Frameworks",
+                    -				);
+                    -				MARKETING_VERSION = 1.0;
+                    -				PRODUCT_BUNDLE_IDENTIFIER = ro.xdev.HealthProbeTests;
+                    -				PRODUCT_NAME = "$(TARGET_NAME)";
+                    -				SDKROOT = iphoneos;
+                    -				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+                    -				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+                    -				SWIFT_VERSION = 5.0;
+                    -				TARGETED_DEVICE_FAMILY = 1;
+                    -				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/HealthProbe.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/HealthProbe";
+                    -				TEST_TARGET_NAME = HealthProbe;
+                    -			};
+                    -			name = Release;
+                    -		};
+                     		4398328A2FA4933F003C0182 /* Debug */ = {
+                     			isa = XCBuildConfiguration;
+                     			buildSettings = {
+                     			};
+                     			name = Release;
+                     		};
+                    +		43A100072FA5000000000001 /* Debug */ = {
+                    +			isa = XCBuildConfiguration;
+                    +			buildSettings = {
+                    +				BUNDLE_LOADER = "$(TEST_HOST)";
+                    +				CODE_SIGN_STYLE = Automatic;
+                    +				CURRENT_PROJECT_VERSION = 1;
+                    +				DEVELOPMENT_TEAM = 9K2U3V9GZF;
+                    +				GENERATE_INFOPLIST_FILE = YES;
+                    +				IPHONEOS_DEPLOYMENT_TARGET = 26.4;
+                    +				LD_RUNPATH_SEARCH_PATHS = (
+                    +					"$(inherited)",
+                    +					"@executable_path/Frameworks",
+                    +					"@loader_path/Frameworks",
+                    +				);
+                    +				MARKETING_VERSION = 1.0;
+                    +				PRODUCT_BUNDLE_IDENTIFIER = ro.xdev.HealthProbeTests;
+                    +				PRODUCT_NAME = "$(TARGET_NAME)";
+                    +				SDKROOT = iphoneos;
+                    +				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+                    +				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+                    +				SWIFT_VERSION = 5.0;
+                    +				TARGETED_DEVICE_FAMILY = 1;
+                    +				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/HealthProbe.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/HealthProbe";
+                    +				TEST_TARGET_NAME = HealthProbe;
+                    +			};
+                    +			name = Debug;
+                    +		};
+                    +		43A100082FA5000000000001 /* Release */ = {
+                    +			isa = XCBuildConfiguration;
+                    +			buildSettings = {
+                    +				BUNDLE_LOADER = "$(TEST_HOST)";
+                    +				CODE_SIGN_STYLE = Automatic;
+                    +				CURRENT_PROJECT_VERSION = 1;
+                    +				DEVELOPMENT_TEAM = 9K2U3V9GZF;
+                    +				GENERATE_INFOPLIST_FILE = YES;
+                    +				IPHONEOS_DEPLOYMENT_TARGET = 26.4;
+                    +				LD_RUNPATH_SEARCH_PATHS = (
+                    +					"$(inherited)",
+                    +					"@executable_path/Frameworks",
+                    +					"@loader_path/Frameworks",
+                    +				);
+                    +				MARKETING_VERSION = 1.0;
+                    +				PRODUCT_BUNDLE_IDENTIFIER = ro.xdev.HealthProbeTests;
+                    +				PRODUCT_NAME = "$(TARGET_NAME)";
+                    +				SDKROOT = iphoneos;
+                    +				SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
+                    +				SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+                    +				SWIFT_VERSION = 5.0;
+                    +				TARGETED_DEVICE_FAMILY = 1;
+                    +				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/HealthProbe.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/HealthProbe";
+                    +				TEST_TARGET_NAME = HealthProbe;
+                    +			};
+                    +			name = Release;
+                    +		};
+                     /* End XCBuildConfiguration section */
+                     /* Begin XCConfigurationList section */

+1 -1

HealthProbe.xcodeproj/xcshareddata/xcschemes/HealthProbe.xcscheme

View

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "2640"
+   LastUpgradeVersion = "2650"
    version = "1.7">
    <BuildAction
       parallelizeBuildables = "YES"


+5 -0

HealthProbe.xcodeproj/xcuserdata/bogdan.xcuserdatad/xcschemes/xcschememanagement.plist

View

@@ -9,6 +9,11 @@
 			<key>orderHint</key>
 			<integer>0</integer>
 		</dict>
+		<key>HealthProbeTests.xcscheme_^#shared#^_</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>1</integer>
+		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>
 	<dict>


+1 -1

HealthProbe/Doc/04-project/IMPLEMENTATION_STATUS.md

View

@@ -28,7 +28,7 @@ There are no real deployments, only test installations. Existing prototype datab
 | SQLite archive | Archive v2 schema, differential write path, v2 verification/delete bookkeeping, daily aggregate rebuilds, integrity report, v2 record reads, SQL diff/count/aggregate/provenance/consolidation-evidence APIs, large synthetic diff pagination coverage, formal timing/memory metrics, and XCTest coverage are in place; the legacy `archive_samples` mirror has been removed | Start Core Data cache work |
 | Core Data cache | Initial programmatic Core Data model and full-cache rebuild service are in place for observation rows, type summaries, daily aggregates, diff summaries, export manifest rows, and archive health | Wire cache reads into UI-facing view models and add targeted partial invalidation |
 | SwiftData cache | Exists | Treat as disposable prototype data; reset/ignore during v2 transition |
-| UI | Prototype exists | Reframe screens around observations, diffs, export, archive status |
+| UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker, and record-change detail uses a separate preview/paged list view with archive-value enrichment and scoped export action | Reframe remaining screens around observations, diffs, export, archive status |
 | Diff/change explanation | Prototype/legacy anomaly logic exists | Move heavy diffing into SQLite and use neutral change classifications |
 | Export | Prototype scoped JSON export exists | Add recovery-compatible manifests and streaming/paged export |
 | Legacy device support | Not implemented | Remove SwiftData dependency and simplify heavy views for low-memory devices |


+0 -32

HealthProbe/Utilities/AppSettings.swift

View

@@ -1,10 +1,8 @@
 import Foundation
-import UIKit
 
 @Observable
 final class AppSettings {
     private static let selectedTypeIDsKey   = "hp_selectedTypeIDs"
-    private static let selectedDeviceIDsKey = "hp_selectedDeviceIDs"
     static let adaptiveTimeoutsEnabledKey = "hp_adaptiveTimeoutsEnabled"
     static let typeDetailCacheBackfillVersionKey = "hp_typeDetailCacheBackfillVersion"
     static let currentTypeDetailCacheBackfillVersion = 2
@@ -13,10 +11,6 @@ final class AppSettings {
         didSet { persistTypes() }
     }
 
-    var selectedDeviceIDs: Set<String> {
-        didSet { persistDevices() }
-    }
-
     var adaptiveTimeoutsEnabled: Bool {
         didSet {
             UserDefaults.standard.set(adaptiveTimeoutsEnabled, forKey: Self.adaptiveTimeoutsEnabledKey)
@@ -35,27 +29,11 @@ final class AppSettings {
             selectedTypeIDs = Set(HealthKitService.allTypes.filter { $0.isEnabledByDefault }.map { $0.id })
         }
 
-        if let data = UserDefaults.standard.data(forKey: Self.selectedDeviceIDsKey),
-           let ids  = try? JSONDecoder().decode([String].self, from: data) {
-            let storedIDs = Set(ids)
-            let oldCurrentID = UIDevice.current.identifierForVendor?.uuidString
-            if let oldCurrentID, storedIDs == [oldCurrentID] {
-                selectedDeviceIDs = [Self.currentDeviceID]
-            } else {
-                selectedDeviceIDs = storedIDs
-            }
-        } else {
-            let currentID = Self.currentDeviceID
-            selectedDeviceIDs = currentID.isEmpty ? [] : [currentID]
-        }
-
         if UserDefaults.standard.object(forKey: Self.adaptiveTimeoutsEnabledKey) == nil {
             adaptiveTimeoutsEnabled = true
         } else {
             adaptiveTimeoutsEnabled = UserDefaults.standard.bool(forKey: Self.adaptiveTimeoutsEnabledKey)
         }
-
-        persistDevices()
     }
 
     func isEnabled(_ type: MonitoredType) -> Bool { selectedTypeIDs.contains(type.id) }
@@ -65,18 +43,8 @@ final class AppSettings {
         else { selectedTypeIDs.insert(type.id) }
     }
 
-    func toggleDevice(_ id: String) {
-        if selectedDeviceIDs.contains(id) { selectedDeviceIDs.remove(id) }
-        else { selectedDeviceIDs.insert(id) }
-    }
-
     private func persistTypes() {
         UserDefaults.standard.set(try? JSONEncoder().encode(Array(selectedTypeIDs)),
                                   forKey: Self.selectedTypeIDsKey)
     }
-
-    private func persistDevices() {
-        UserDefaults.standard.set(try? JSONEncoder().encode(Array(selectedDeviceIDs)),
-                                  forKey: Self.selectedDeviceIDsKey)
-    }
 }


+0 -7

HealthProbe/Utilities/DesignSystem.swift

View

@@ -26,13 +26,6 @@ enum DeviceColor: String, CaseIterable, Identifiable {
     }
 }
 
-struct DeviceEntry: Identifiable {
-    let id: String          // deviceID; "" = unidentified
-    let displayName: String
-    let color: Color
-    let isCurrent: Bool
-}
-
 struct SeverityBadge: View {
     let delta: Int
     var dimmed: Bool = false


+143 -0

HealthProbe/ViewModels/DataTypeRecordListViewModel.swift

View

+                    +import Foundation
+                    +import Observation
+                    +enum RecordListMode {
+                    +    case disappeared(typeIdentifier: String)
+                    +    case added(typeIdentifier: String, afterDate: Date, beforeDate: Date)
+                    +    var typeIdentifier: String {
+                    +        switch self {
+                    +        case .disappeared(let typeID):
+                    +            return typeID
+                    +        case .added(let typeID, _, _):
+                    +            return typeID
+                    +        }
+                    +    }
+                    +}
+                    +enum ExportState: Equatable {
+                    +    case idle
+                    +    case loading
+                    +    case ready(URL)
+                    +    case failed(String)
+                    +}
+                    +@MainActor
+                    +@Observable
+                    +final class DataTypeRecordListViewModel {
+                    +    let typeIdentifier: String
+                    +    let displayName: String
+                    +    let totalCount: Int
+                    +    let mode: RecordListMode
+                    +    let previewRecords: [HealthRecordValue]
+                    +    var displayRecords: [HealthRecordValue] = []
+                    +    var isLoadingMore = false
+                    +    var hasMore: Bool { displayRecords.count < min(totalCount, previewRecords.count) }
+                    +    var exportState: ExportState = .idle
+                    +    private var pageIndex = 0
+                    +    private let pageSize = 50
+                    +    private let archiveStore: HealthArchiveStore
+                    +    init(
+                    +        typeIdentifier: String,
+                    +        displayName: String,
+                    +        totalCount: Int,
+                    +        mode: RecordListMode,
+                    +        previewRecords: [HealthRecordValue] = [],
+                    +        archiveStore: HealthArchiveStore
+                    +    ) {
+                    +        self.typeIdentifier = typeIdentifier
+                    +        self.displayName = displayName
+                    +        self.totalCount = totalCount
+                    +        self.mode = mode
+                    +        self.previewRecords = previewRecords
+                    +        self.archiveStore = archiveStore
+                    +    }
+                    +    func loadFirstPage() async {
+                    +        guard displayRecords.isEmpty else { return }
+                    +        pageIndex = 0
+                    +        await loadNextPage()
+                    +    }
+                    +    func loadNextPage() async {
+                    +        guard !isLoadingMore, hasMore else { return }
+                    +        isLoadingMore = true
+                    +        defer { isLoadingMore = false }
+                    +        let batchStart = pageIndex
+                    +        let batchEnd = min(pageIndex + pageSize, previewRecords.count)
+                    +        guard batchStart < previewRecords.count else {
+                    +            return
+                    +        }
+                    +        let batch = Array(previewRecords[batchStart..<batchEnd])
+                    +        // Enrich batch with actual values from archive store
+                    +        var enrichedBatch = batch
+                    +        do {
+                    +            let fingerprints = Set(batch.map { $0.recordFingerprint })
+                    +            let request = HealthArchiveRecordRequest(
+                    +                sampleTypeIdentifier: typeIdentifier,
+                    +                fingerprints: fingerprints,
+                    +                limit: nil
+                    +            )
+                    +            let archivedRecords = try await archiveStore.records(for: request)
+                    +            let archiveByFingerprint = Dictionary(grouping: archivedRecords, by: { $0.strictFingerprint })
+                    +            enrichedBatch = batch.map { cached in
+                    +                guard let archived = archiveByFingerprint[cached.recordFingerprint]?.first,
+                    +                      cached.displayValue == nil else { return cached }
+                    +                return HealthRecordValue(
+                    +                    typeIdentifier: cached.typeIdentifier,
+                    +                    sampleUUIDHash: cached.sampleUUIDHash,
+                    +                    recordFingerprint: cached.recordFingerprint,
+                    +                    startDate: cached.startDate,
+                    +                    endDate: cached.endDate,
+                    +                    displayValue: archived.displayValue
+                    +                )
+                    +            }
+                    +        } catch {
+                    +            // Cached preview records remain usable when the archive cannot enrich display values.
+                    +        }
+                    +        displayRecords.append(contentsOf: enrichedBatch)
+                    +        pageIndex = batchEnd
+                    +    }
+                    +    func exportAllRecords() async {
+                    +        exportState = .loading
+                    +        do {
+                    +            let reportRequest = buildExportRequest()
+                    +            let exportURL = try await archiveStore.exportReport(reportRequest)
+                    +            exportState = .ready(exportURL)
+                    +        } catch {
+                    +            exportState = .failed(error.localizedDescription)
+                    +        }
+                    +    }
+                    +    private func buildExportRequest() -> HealthArchiveReportRequest {
+                    +        switch mode {
+                    +        case .disappeared(let typeID):
+                    +            return HealthArchiveReportRequest(
+                    +                reportID: UUID(),
+                    +                title: "Disappeared Records - \(displayName)",
+                    +                typeIdentifierFilter: typeID,
+                    +                disappearedOnly: true
+                    +            )
+                    +        case .added(let typeID, let afterDate, let beforeDate):
+                    +            return HealthArchiveReportRequest(
+                    +                reportID: UUID(),
+                    +                title: "Added Records - \(displayName)",
+                    +                typeIdentifierFilter: typeID,
+                    +                firstSeenAfter: afterDate,
+                    +                firstSeenBefore: beforeDate
+                    +            )
+                    +        }
+                    +    }
+                    +}

+9 -58

HealthProbe/Views/DataTypes/DataTypesView.swift

View

@@ -2,41 +2,23 @@ import SwiftUI
 import SwiftData
 
 struct DataTypesView: View {
-    @Environment(AppSettings.self) private var appSettings
     @Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]
-    @Query private var deviceProfiles: [DeviceProfile]
     @State private var viewModel = DataTypesViewModel()
 
-    private var profileMap: [String: DeviceProfile] {
-        Dictionary(uniqueKeysWithValues: deviceProfiles.compactMap {
-            $0.deviceID.isEmpty ? nil : ($0.deviceID, $0)
-        })
-    }
-
     private var displayedSnapshots: [HealthSnapshot] {
-        let selected = appSettings.selectedDeviceIDs
-        guard !selected.isEmpty else { return [] }
-        return allSnapshots.filter { selected.contains($0.deviceID) }
+        guard let deviceID = localDeviceID else { return [] }
+        return allSnapshots.filter { $0.deviceID == deviceID }
     }
 
     private var latest: HealthSnapshot? { displayedSnapshots.first }
 
-    private var knownDevices: [DeviceEntry] {
+    private var localDeviceID: String? {
         let currentID = AppSettings.currentDeviceID
-        var ids = Set(allSnapshots.map { $0.deviceID })
-        if !currentID.isEmpty { ids.insert(currentID) }
-        return ids.map { id in
-            let profile = profileMap[id]
-            let name: String
-            if let n = profile?.name, !n.isEmpty { name = n }
-            else if id.isEmpty { name = "Unidentified" }
-            else { name = "Unknown Device" }
-            let color = DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
-            return DeviceEntry(id: id, displayName: name, color: color, isCurrent: id == currentID)
-        }.sorted {
-            if $0.isCurrent != $1.isCurrent { return $0.isCurrent }
-            return $0.displayName < $1.displayName
+        if allSnapshots.contains(where: { $0.deviceID == currentID }) {
+            return currentID
         }
+
+        return allSnapshots.first?.deviceID
     }
 
     var body: some View {
@@ -45,10 +27,8 @@ struct DataTypesView: View {
                 if displayedSnapshots.count < 2 {
                     EmptyStateView(
                         icon: "waveform.path.ecg",
-                        title: appSettings.selectedDeviceIDs.isEmpty ? "No Devices Selected" : "Not Enough Data",
-                        message: appSettings.selectedDeviceIDs.isEmpty
-                            ? "Select at least one device using the filter above."
-                            : "Create at least two snapshots to compare data types."
+                        title: "Not Enough Data",
+                        message: "Create at least two local snapshots to compare data types."
                     )
                 } else {
                     typeList
@@ -106,9 +86,6 @@ struct DataTypesView: View {
 
     @ToolbarContentBuilder
     private var filterPicker: some ToolbarContent {
-        ToolbarItem(placement: .topBarLeading) {
-            devicePickerMenu
-        }
         ToolbarItem(placement: .navigationBarTrailing) {
             Menu {
                 Picker("Filter", selection: $viewModel.filter) {
@@ -122,32 +99,6 @@ struct DataTypesView: View {
             }
         }
     }
-
-    private var devicePickerMenu: some View {
-        let selected = appSettings.selectedDeviceIDs
-        let isMulti  = selected.count > 1
-        return Menu {
-            ForEach(knownDevices) { entry in
-                Button {
-                    appSettings.toggleDevice(entry.id)
-                } label: {
-                    Label {
-                        Text(entry.isCurrent
-                             ? "\(entry.displayName) (This Device)"
-                             : entry.displayName)
-                    } icon: {
-                        Image(systemName: selected.contains(entry.id)
-                              ? "checkmark.circle.fill" : "circle.fill")
-                            .foregroundStyle(entry.color)
-                    }
-                }
-            }
-        } label: {
-            Image(systemName: "iphone")
-        }
-        .tint(isMulti ? .orange : .accentColor)
-        .accessibilityLabel("Select devices – \(selected.count) selected")
-    }
 }
 
 // MARK: - Row


+153 -52

HealthProbe/Views/DataTypes/RecordChangeEvolutionChart.swift

View

+                             return counts.max() ?? 1
+                    -    private var maxNegativeCount: Int {
+                    -        var max = 0
+                    -        for snapshot in contextSnapshots {
+                    +    private var chartPoints: [ChartPoint] {
+                    +        contextSnapshots.map { snapshot in
+                    +            let typeCount = snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }
+                                 let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
+                    -            let diff = recordDiff(current: snapshot, previous: previousSnapshot)
+                    -            max = Swift.max(max, diff.disappeared)
+                    +            return ChartPoint(
+                    +                snapshot: snapshot,
+                    +                count: max(typeCount?.count ?? 0, 0),
+                    +                diff: recordDiff(current: snapshot, previous: previousSnapshot)
+                    +            )
+                    -        return max
+                    -    private func recordDiff(current: HealthSnapshot, previous: HealthSnapshot?) -> (added: Int, disappeared: Int) {
+                    -        guard let previous = previous else { return (0, 0) }
+                    +    private var maxChangeCount: Int {
+                    +        let maxChange = chartPoints
+                    +            .map { max($0.diff.added, $0.diff.disappeared) }
+                    +            .max() ?? 0
+                    +        return max(maxChange, 1)
+                    +    }
+                    +    private var hasAnyRecordChanges: Bool {
+                    +        chartPoints.contains { $0.diff.added > 0 || $0.diff.disappeared > 0 }
+                    +    }
+                    +    private func recordDiff(current: HealthSnapshot, previous: HealthSnapshot?) -> RecordChangeDiff {
+                    +        guard let previous = previous else { return RecordChangeDiff() }
+                    +        if let typeCount = current.typeCounts?.first(where: { $0.typeIdentifier == typeIdentifier }),
+                    +           let cache = typeCount.detailCache,
+                    +           cache.matchesBaseline(previous.id) {
+                    +            return RecordChangeDiff(
+                    +                added: cache.addedCount,
+                    +                disappeared: cache.disappearedCount,
+                    +                isExact: true
+                    +            )
+                    +        }
+                             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)
+                    +            return RecordChangeDiff()
+                             switch typeDelta.transition {
+                             case .unchanged:
+                    -            return (0, 0)
+                    +            return RecordChangeDiff()
+                             case .changed:
+                                 if typeDelta.countDelta > 0 {
+                    -                return (typeDelta.countDelta, 0)
+                    +                return RecordChangeDiff(added: typeDelta.countDelta)
+                                 if typeDelta.countDelta < 0 {
+                    -                return (0, abs(typeDelta.countDelta))
+                    +                return RecordChangeDiff(disappeared: abs(typeDelta.countDelta))
+                    -            return (0, 0)
+                    +            return RecordChangeDiff()
+                             case .appeared:
+                    -            return (max(typeDelta.countDelta, 1), 0)
+                    +            return RecordChangeDiff(added: max(typeDelta.countDelta, 1))
+                             case .disappeared:
+                    -            return (0, max(abs(typeDelta.countDelta), 1))
+                    +            return RecordChangeDiff(disappeared: max(abs(typeDelta.countDelta), 1))
+                                 evolutionChart
+                    +            if hasAnyRecordChanges {
+                    +                changeLegend
+                    +            }
+                                 HStack(spacing: 12) {
+                                     VStack(alignment: .leading, spacing: 4) {
+                                         Text("Min")
+                         @ViewBuilder
+                         private var evolutionChart: some View {
+                             HStack(alignment: .bottom, spacing: 4) {
+                    -            ForEach(Array(contextSnapshots.enumerated()), id: \.element.id) { idx, snapshot in
+                    -                chartBar(at: idx, snapshot: snapshot)
+                    +            ForEach(Array(chartPoints.enumerated()), id: \.element.snapshot.id) { idx, point in
+                    +                chartBar(at: idx, point: point)
+                    -        .frame(height: 100)
+                    +        .frame(height: 132)
+                             .padding(12)
+                             .background(Color(.systemBackground).opacity(0.3), in: RoundedRectangle(cornerRadius: 8))
+                         @ViewBuilder
+                    -    private func chartBar(at index: Int, snapshot: HealthSnapshot) -> some View {
+                    -        let typeCount = snapshot.typeCounts?.first { $0.typeIdentifier == typeIdentifier }
+                    -        let count = typeCount?.count ?? 0
+                    -        let isCurrent = snapshot.id == currentSnapshotID
+                    -        let previousSnapshot = snapshot.previousInTimeline(sortedSnapshots)
+                    -        let diff = recordDiff(current: snapshot, previous: previousSnapshot)
+                    -        let unchanged = count - diff.added
+                    -        let barTotalRange = CGFloat(diff.disappeared + count)
+                    -        let redHeight = barTotalRange > 0 ? CGFloat(diff.disappeared) / barTotalRange * 80 : 0
+                    -        let blueHeight = barTotalRange > 0 ? CGFloat(unchanged) / barTotalRange * 80 : 0
+                    -        let greenHeight = barTotalRange > 0 ? CGFloat(diff.added) / barTotalRange * 80 : 0
+                    -        let minVisibleHeight: CGFloat = 3
+                    +    private func chartBar(at index: Int, point: ChartPoint) -> some View {
+                    +        let isCurrent = point.snapshot.id == currentSnapshotID
+                    +        let totalBarHeight = CGFloat(point.count) / CGFloat(max(maxCount, 1)) * 54
+                    +        let addedHeight = changeHeight(for: point.diff.added)
+                    +        let disappearedHeight = changeHeight(for: point.diff.disappeared)
+                             VStack(spacing: 0) {
+                                 if isCurrent {
+                                         .padding(.bottom, 4)
+                    -            VStack(spacing: 0) {
+                    -                if diff.added > 0 {
+                    -                    RoundedRectangle(cornerRadius: 1)
+                    -                        .fill(Color.healthyGreen)
+                    -                        .frame(height: max(minVisibleHeight, greenHeight))
+                    -                }
+                    -                if unchanged > 0 {
+                    -                    RoundedRectangle(cornerRadius: 1)
+                    -                        .fill(Color.neutralGray.opacity(0.6))
+                    -                        .frame(height: max(1, blueHeight))
+                    -                }
+                    -                if diff.disappeared > 0 {
+                    -                    RoundedRectangle(cornerRadius: 1)
+                    -                        .fill(Color.criticalRed)
+                    -                        .frame(height: max(minVisibleHeight, redHeight))
+                    +            VStack(spacing: 3) {
+                    +                changeSegment(
+                    +                    count: point.diff.added,
+                    +                    height: addedHeight,
+                    +                    color: Color.healthyGreen,
+                    +                    pinsToBottom: true
+                    +                )
+                    +                RoundedRectangle(cornerRadius: 2)
+                    +                    .fill(Color.neutralGray.opacity(0.6))
+                    +                    .frame(height: max(4, totalBarHeight))
+                    +                    .frame(maxWidth: .infinity)
+                    +                changeSegment(
+                    +                    count: point.diff.disappeared,
+                    +                    height: disappearedHeight,
+                    +                    color: Color.criticalRed,
+                    +                    pinsToBottom: false
+                    +                )
+                    +            }
+                    +            .frame(height: 96, alignment: .bottom)
+                    +            .overlay(alignment: .bottom) {
+                    +                if point.diff.isFallback, point.diff.disappeared > 0 || point.diff.added > 0 {
+                    +                    Image(systemName: "tilde")
+                    +                        .font(.system(size: 9, weight: .bold))
+                    +                        .foregroundStyle(.secondary)
+                    +                        .offset(y: 12)
+                    -            .frame(height: 80)
+                    -            .frame(maxWidth: .infinity)
+                    -            Text(snapshot.timestamp.formatted(.dateTime.month().day()))
+                    +            Text(point.snapshot.timestamp.formatted(.dateTime.month().day()))
+                                     .font(.caption2)
+                                     .foregroundStyle(.secondary)
+                                     .lineLimit(1)
+                             .frame(maxWidth: .infinity)
+                    +    private func changeHeight(for count: Int) -> CGFloat {
+                    +        guard count > 0 else { return 0 }
+                    +        let scaled = CGFloat(count) / CGFloat(maxChangeCount) * 18
+                    +        return max(4, scaled)
+                    +    }
+                    +    @ViewBuilder
+                    +    private func changeSegment(
+                    +        count: Int,
+                    +        height: CGFloat,
+                    +        color: Color,
+                    +        pinsToBottom: Bool
+                    +    ) -> some View {
+                    +        VStack {
+                    +            if pinsToBottom {
+                    +                Spacer(minLength: 0)
+                    +            }
+                    +            if count > 0 {
+                    +                RoundedRectangle(cornerRadius: 2)
+                    +                    .fill(color)
+                    +                    .frame(height: height)
+                    +                    .frame(maxWidth: .infinity)
+                    +                    .accessibilityLabel("\(count) records")
+                    +            } else {
+                    +                Color.clear.frame(height: 0)
+                    +            }
+                    +            if !pinsToBottom {
+                    +                Spacer(minLength: 0)
+                    +            }
+                    +        }
+                    +        .frame(height: 18)
+                    +    }
+                    +    private var changeLegend: some View {
+                    +        HStack(spacing: 10) {
+                    +            legendItem(color: Color.healthyGreen, label: "Added")
+                    +            legendItem(color: Color.criticalRed, label: "Disappeared")
+                    +            Spacer(minLength: 0)
+                    +        }
+                    +        .font(.caption2)
+                    +        .foregroundStyle(.secondary)
+                    +    }
+                    +    private func legendItem(color: Color, label: String) -> some View {
+                    +        HStack(spacing: 4) {
+                    +            RoundedRectangle(cornerRadius: 2)
+                    +                .fill(color)
+                    +                .frame(width: 12, height: 4)
+                    +            Text(label)
+                    +        }
+                    +    }
+                    +}
+                    +private struct ChartPoint {
+                    +    let snapshot: HealthSnapshot
+                    +    let count: Int
+                    +    let diff: RecordChangeDiff
+                    +}
+                    +private struct RecordChangeDiff {
+                    +    let added: Int
+                    +    let disappeared: Int
+                    +    let isExact: Bool
+                    +    init(added: Int = 0, disappeared: Int = 0, isExact: Bool = false) {
+                    +        self.added = added
+                    +        self.disappeared = disappeared
+                    +        self.isExact = isExact
+                    +    }
+                    +    var isFallback: Bool {
+                    +        !isExact
+                    +    }
+                     #Preview {

+214 -0

HealthProbe/Views/Snapshots/DataTypeRecordListView.swift

View

+                    +import SwiftUI
+                    +import UIKit
+                    +struct DataTypeRecordListView: View {
+                    +    let title: String
+                    +    let displayName: String
+                    +    let totalCount: Int
+                    +    let tint: Color
+                    +    @State private var viewModel: DataTypeRecordListViewModel?
+                    +    private let recordListMode: RecordListMode
+                    +    private let previewRecords: [HealthRecordValue]
+                    +    init(
+                    +        title: String,
+                    +        displayName: String,
+                    +        totalCount: Int,
+                    +        mode: RecordListMode,
+                    +        previewRecords: [HealthRecordValue] = [],
+                    +        tint: Color
+                    +    ) {
+                    +        self.title = title
+                    +        self.displayName = displayName
+                    +        self.totalCount = totalCount
+                    +        self.tint = tint
+                    +        self.recordListMode = mode
+                    +        self.previewRecords = previewRecords
+                    +    }
+                    +    private var isTruncated: Bool {
+                    +        guard let viewModel else { return totalCount > 0 }
+                    +        return viewModel.displayRecords.count < totalCount
+                    +    }
+                    +    var body: some View {
+                    +        Group {
+                    +            if let viewModel = viewModel {
+                    +                List {
+                    +                    Section {
+                    +                        DataTypeDetailRow(label: "Data Type") {
+                    +                            Text(displayName)
+                    +                                .foregroundStyle(.secondary)
+                    +                                .lineLimit(1)
+                    +                        }
+                    +                        DataTypeDetailRow(label: "Records") {
+                    +                            Text("\(totalCount)")
+                    +                                .foregroundStyle(tint)
+                    +                                .monospacedDigit()
+                    +                        }
+                    +                        if isTruncated {
+                    +                            HStack(spacing: 4) {
+                    +                                Image(systemName: "exclamationmark.circle.fill")
+                    +                                    .font(.caption)
+                    +                                    .foregroundStyle(Color.warningAmber)
+                    +                                Text("Showing \(viewModel.displayRecords.count) of \(totalCount)")
+                    +                                    .font(.caption)
+                    +                                    .foregroundStyle(.secondary)
+                    +                            }
+                    +                            .padding(.vertical, 4)
+                    +                        }
+                    +                        Text("HealthProbe stores timestamps, fingerprints, and metadata. Export includes complete record details.")
+                    +                            .font(.caption)
+                    +                            .foregroundStyle(.secondary)
+                    +                    }
+                    +                    if viewModel.displayRecords.isEmpty {
+                    +                        Section(title) {
+                    +                            Text("No records.")
+                    +                                .foregroundStyle(.secondary)
+                    +                        }
+                    +                    } else {
+                    +                        Section(title) {
+                    +                            ForEach(viewModel.displayRecords) { record in
+                    +                                HealthRecordValueRow(record: record, tint: tint)
+                    +                                    .onAppear {
+                    +                                        if record.id == viewModel.displayRecords.last?.id {
+                    +                                            Task { await viewModel.loadNextPage() }
+                    +                                        }
+                    +                                    }
+                    +                            }
+                    +                            if viewModel.isLoadingMore {
+                    +                                HStack(spacing: 8) {
+                    +                                    ProgressView()
+                    +                                        .scaleEffect(0.8)
+                    +                                    Text("Loading more...")
+                    +                                        .font(.caption)
+                    +                                        .foregroundStyle(.secondary)
+                    +                                }
+                    +                                .frame(maxWidth: .infinity, alignment: .center)
+                    +                                .padding(.vertical, 8)
+                    +                            }
+                    +                        }
+                    +                    }
+                    +                }
+                    +                .navigationTitle(title)
+                    +                .navigationBarTitleDisplayMode(.inline)
+                    +                .toolbar {
+                    +                    ToolbarItem(placement: .topBarTrailing) {
+                    +                        Menu {
+                    +                            Button(action: { Task { await viewModel.exportAllRecords() } }) {
+                    +                                Label("Export as JSON", systemImage: "square.and.arrow.up")
+                    +                            }
+                    +                        } label: {
+                    +                            Image(systemName: "ellipsis.circle")
+                    +                                .foregroundStyle(.primary)
+                    +                        }
+                    +                    }
+                    +                }
+                    +                .onChange(of: viewModel.exportState) { _, newState in
+                    +                    if case .ready(let url) = newState {
+                    +                        shareExportURL(url)
+                    +                    }
+                    +                }
+                    +            } else {
+                    +                ProgressView()
+                    +                    .navigationTitle(title)
+                    +                    .navigationBarTitleDisplayMode(.inline)
+                    +            }
+                    +        }
+                    +        .task {
+                    +            guard viewModel == nil else { return }
+                    +            let vm = DataTypeRecordListViewModel(
+                    +                typeIdentifier: recordListMode.typeIdentifier,
+                    +                displayName: displayName,
+                    +                totalCount: totalCount,
+                    +                mode: recordListMode,
+                    +                previewRecords: previewRecords,
+                    +                archiveStore: SQLiteHealthArchiveStore.shared
+                    +            )
+                    +            viewModel = vm
+                    +            await vm.loadFirstPage()
+                    +        }
+                    +    }
+                    +    private func shareExportURL(_ url: URL) {
+                    +        let activity = UIActivityViewController(activityItems: [url], applicationActivities: nil)
+                    +        if let scene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
+                    +            scene.windows.first?.rootViewController?.present(activity, animated: true)
+                    +        }
+                    +    }
+                    +}
+                    +private struct HealthRecordValueRow: View {
+                    +    let record: HealthRecordValue
+                    +    let tint: Color
+                    +    var body: some View {
+                    +        let recordDate = record.startDate.formatted(.dateTime.year().month().day())
+                    +        let startTime = record.startDate.formatted(.dateTime.hour().minute())
+                    +        let endTime = record.endDate.formatted(.dateTime.hour().minute())
+                    +        let timeRange = (startTime == endTime) ? startTime : "\(startTime)–\(endTime)"
+                    +        VStack(alignment: .leading, spacing: 6) {
+                    +            HStack(spacing: 12) {
+                    +                VStack(alignment: .leading, spacing: 2) {
+                    +                    Text("\(recordDate) • \(timeRange)")
+                    +                        .font(.subheadline.weight(.semibold))
+                    +                        .foregroundStyle(.primary)
+                    +                    if let displayValue = record.displayValue, !displayValue.isEmpty {
+                    +                        Text(displayValue)
+                    +                            .font(.caption)
+                    +                            .foregroundStyle(.secondary)
+                    +                    } else {
+                    +                        Text("No value stored")
+                    +                            .font(.caption)
+                    +                            .foregroundStyle(.secondary)
+                    +                    }
+                    +                }
+                    +                Spacer()
+                    +                Image(systemName: "xmark.circle.fill")
+                    +                    .font(.caption)
+                    +                    .foregroundStyle(Color.criticalRed)
+                    +            }
+                    +            Text(record.recordFingerprint.suffix(8))
+                    +                .font(.caption.monospaced())
+                    +                .foregroundStyle(.tertiary)
+                    +                .lineLimit(1)
+                    +        }
+                    +        .padding(.vertical, 2)
+                    +        .accessibilityElement(children: .combine)
+                    +    }
+                    +}
+                    +private struct DataTypeDetailRow<Content: View>: View {
+                    +    let label: String
+                    +    @ViewBuilder let content: () -> Content
+                    +    var body: some View {
+                    +        HStack {
+                    +            Text(label)
+                    +            Spacer()
+                    +            content()
+                    +        }
+                    +    }
+                    +}
+                    +#Preview {
+                    +    NavigationStack {
+                    +        DataTypeRecordListView(
+                    +            title: "Disappeared Records",
+                    +            displayName: "Step Count",
+                    +            totalCount: 1500,
+                    +            mode: .disappeared(typeIdentifier: "HKQuantityTypeIdentifierStepCount"),
+                    +            tint: .criticalRed
+                    +        )
+                    +    }
+                    +}

+12 -111

HealthProbe/Views/Snapshots/DataTypeSnapshotDetailView.swift

View

+                                     .navigationDestination(isPresented: $showAddedRecords) {
+                    -                    DataTypeRecordListView(
+                    -                        title: "Added Records",
+                    -                        displayName: displayName,
+                    -                        records: diff.addedRecords,
+                    -                        totalCount: diff.addedCount,
+                    -                        tint: Color.healthyGreen
+                    -                    )
+                    +                    if let previous = previousSnapshot {
+                    +                        DataTypeRecordListView(
+                    +                            title: "Added Records",
+                    +                            displayName: displayName,
+                    +                            totalCount: diff.addedCount,
+                    +                            mode: .added(typeIdentifier: typeIdentifier, afterDate: previous.timestamp, beforeDate: currentSnapshot.timestamp),
+                    +                            previewRecords: diff.addedRecords,
+                    +                            tint: Color.healthyGreen
+                    +                        )
+                    +                    }
+                                     .navigationDestination(isPresented: $showDisappearedRecords) {
+                                         DataTypeRecordListView(
+                                             title: "Disappeared Records",
+                                             displayName: displayName,
+                    -                        records: diff.disappearedRecords,
+                                             totalCount: diff.disappearedCount,
+                    +                        mode: .disappeared(typeIdentifier: typeIdentifier),
+                    +                        previewRecords: diff.disappearedRecords,
+                                             tint: Color.criticalRed
+                    -private struct DataTypeRecordListView: View {
+                    -    let title: String
+                    -    let displayName: String
+                    -    let records: [HealthRecordValue]
+                    -    let totalCount: Int
+                    -    let tint: Color
+                    -    private var showsValueDisclaimer: Bool {
+                    -        records.contains { ($0.displayValue?.isEmpty ?? true) }
+                    -    }
+                    -    var body: some View {
+                    -        List {
+                    -            Section {
+                    -                DataTypeDetailRow(label: "Data Type") {
+                    -                    Text(displayName)
+                    -                        .foregroundStyle(.secondary)
+                    -                        .lineLimit(1)
+                    -                }
+                    -                DataTypeDetailRow(label: "Records") {
+                    -                    Text("\(totalCount)")
+                    -                        .foregroundStyle(tint)
+                    -                        .monospacedDigit()
+                    -                }
+                    -                if totalCount > records.count {
+                    -                    Text("Showing newest \(records.count) records.")
+                    -                        .font(.caption)
+                    -                        .foregroundStyle(.secondary)
+                    -                }
+                    -                if showsValueDisclaimer {
+                    -                    Text("For privacy, HealthProbe stores only timestamps and a record fingerprint here (not the raw HealthKit value).")
+                    -                        .font(.caption)
+                    -                        .foregroundStyle(.secondary)
+                    -                }
+                    -            }
+                    -            Section(title) {
+                    -                if records.isEmpty {
+                    -                    Text("No records.")
+                    -                        .foregroundStyle(.secondary)
+                    -                } else {
+                    -                    ForEach(records) { record in
+                    -                        DataTypeRecordRow(record: record, tint: tint)
+                    -                    }
+                    -                }
+                    -            }
+                    -        }
+                    -        .navigationTitle(title)
+                    -        .navigationBarTitleDisplayMode(.inline)
+                    -    }
+                    -}
+                     private enum RecordDiffState: Equatable {
+                         case idle
+                         case loading
+                    -private struct DataTypeRecordRow: View {
+                    -    let record: HealthRecordValue
+                    -    let tint: Color
+                    -    var body: some View {
+                    -        let recordDate = record.startDate.formatted(.dateTime.year().month().day())
+                    -        let startTime = record.startDate.formatted(.dateTime.hour().minute())
+                    -        let endTime = record.endDate.formatted(.dateTime.hour().minute())
+                    -        let timeRange = (startTime == endTime) ? startTime : "\(startTime)–\(endTime)"
+                    -        HStack(spacing: 12) {
+                    -            VStack(alignment: .leading, spacing: 2) {
+                    -                if let displayValue = record.displayValue, !displayValue.isEmpty {
+                    -                    Text(displayValue)
+                    -                        .font(.subheadline)
+                    -                        .foregroundStyle(.primary)
+                    -                } else {
+                    -                    Text("No value stored")
+                    -                        .font(.subheadline)
+                    -                        .foregroundStyle(.secondary)
+                    -                }
+                    -                Text("\(recordDate) • \(timeRange)")
+                    -                    .font(.caption)
+                    -                    .foregroundStyle(.secondary)
+                    -            }
+                    -            Spacer()
+                    -            if startTime != endTime {
+                    -                Text(endTime)
+                    -                    .font(.caption)
+                    -                    .foregroundStyle(tint)
+                    -                    .accessibilityLabel("End \(endTime)")
+                    -            }
+                    -        }
+                    -        .padding(.vertical, 2)
+                    -        .accessibilityElement(children: .combine)
+                    -    }
+                    -}
+                    -private struct DataTypeDetailRow<Content: View>: View {
+                    -    let label: String
+                    -    @ViewBuilder let content: () -> Content
+                    -    var body: some View {
+                    -        HStack {
+                    -            Text(label)
+                    -            Spacer()
+                    -            content()
+                    -        }
+                    -    }
+                    -}
+                     #Preview {
+                         NavigationStack {
+                             DataTypeSnapshotDetailView(

+9 -60

HealthProbe/Views/Snapshots/SnapshotsView.swift

View

@@ -1,10 +1,8 @@
 import SwiftUI
 import SwiftData
-import UIKit
 
 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]
@@ -17,9 +15,8 @@ struct SnapshotsView: View {
     }
 
     private var displayedSnapshots: [HealthSnapshot] {
-        let selected = appSettings.selectedDeviceIDs
-        guard !selected.isEmpty else { return [] }
-        return allSnapshots.filter { selected.contains($0.deviceID) }
+        guard let deviceID = localDeviceID else { return [] }
+        return allSnapshots.filter { $0.deviceID == deviceID }
     }
 
     private var snapshotItems: [SnapshotListItem] {
@@ -38,23 +35,13 @@ struct SnapshotsView: View {
         }
     }
 
-    private var knownDevices: [DeviceEntry] {
+    private var localDeviceID: String? {
         let currentID = AppSettings.currentDeviceID
-        var ids = Set(allSnapshots.map { $0.deviceID })
-        ids.insert(currentID)
-        return ids.map { id in
-            let profile = profileMap[id]
-            let name: String
-            if let n = profile?.name, !n.isEmpty { name = n }
-            else if id.isEmpty { name = "Unidentified" }
-            else { name = "Unknown Device" }
-            let color = DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
-            return DeviceEntry(id: id, displayName: name, color: color, isCurrent: id == currentID)
-        }
-        .sorted {
-            if $0.isCurrent != $1.isCurrent { return $0.isCurrent }
-            return $0.displayName < $1.displayName
+        if allSnapshots.contains(where: { $0.deviceID == currentID }) {
+            return currentID
         }
+
+        return allSnapshots.first?.deviceID
     }
 
     var body: some View {
@@ -63,10 +50,8 @@ struct SnapshotsView: View {
                 if displayedSnapshots.isEmpty {
                     EmptyStateView(
                         icon: "clock.arrow.circlepath",
-                        title: appSettings.selectedDeviceIDs.isEmpty ? "No Devices Selected" : "No Snapshots",
-                        message: appSettings.selectedDeviceIDs.isEmpty
-                            ? "Select at least one device using the filter above."
-                            : "Use the Dashboard to create your first snapshot."
+                        title: "No Snapshots",
+                        message: "Use the Dashboard to create your first local snapshot."
                     )
                 } else {
                     snapshotList
@@ -77,13 +62,6 @@ struct SnapshotsView: View {
             .task(id: allDeltas.count) {
                 repairDeltaListSummariesIfNeeded()
             }
-            .onChange(of: appSettings.selectedDeviceIDs) {
-                if let baseline = viewModel.selectedBaseline,
-                   !displayedSnapshots.contains(where: { $0.id == baseline.id }) {
-                    viewModel.selectedBaseline = nil
-                    viewModel.comparisonMode = .previous
-                }
-            }
         }
     }
 
@@ -137,9 +115,6 @@ struct SnapshotsView: View {
 
     @ToolbarContentBuilder
     private var toolbarContent: some ToolbarContent {
-        ToolbarItem(placement: .topBarLeading) {
-            devicePickerMenu
-        }
         ToolbarItem(placement: .navigationBarTrailing) {
             Menu {
                 Picker("Compare Against", selection: $viewModel.comparisonMode) {
@@ -158,32 +133,6 @@ struct SnapshotsView: View {
         }
     }
 
-    private var devicePickerMenu: some View {
-        let selected = appSettings.selectedDeviceIDs
-        let isMulti  = selected.count > 1
-        return Menu {
-            ForEach(knownDevices) { entry in
-                Button {
-                    appSettings.toggleDevice(entry.id)
-                } label: {
-                    Label {
-                        Text(entry.isCurrent
-                             ? "\(entry.displayName) (This Device)"
-                             : entry.displayName)
-                    } icon: {
-                        Image(systemName: selected.contains(entry.id)
-                              ? "checkmark.circle.fill" : "circle.fill")
-                            .foregroundStyle(entry.color)
-                    }
-                }
-            }
-        } label: {
-            Image(systemName: "iphone")
-        }
-        .tint(isMulti ? .orange : .accentColor)
-        .accessibilityLabel("Select devices – \(selected.count) selected")
-    }
-
     private func repairDeltaListSummariesIfNeeded() {
         do {
             _ = try DeltaService.rebuildMissingListSummaries(context: modelContext, maxCount: 64)


	@@ -1,6 +1,6 @@
1	1	<?xml version="1.0" encoding="UTF-8"?>
2	2	<Scheme
3		- LastUpgradeVersion = "2640"
	3	+ LastUpgradeVersion = "2650"
4	4	version = "1.7">
5	5	<BuildAction
6	6	parallelizeBuildables = "YES"

	@@ -9,6 +9,11 @@
9	9	<key>orderHint</key>
10	10	<integer>0</integer>
11	11	</dict>
	12	+ <key>HealthProbeTests.xcscheme_^#shared#^_</key>
	13	+ <dict>
	14	+ <key>orderHint</key>
	15	+ <integer>1</integer>
	16	+ </dict>
12	17	</dict>
13	18	<key>SuppressBuildableAutocreation</key>
14	19	<dict>

	@@ -28,7 +28,7 @@ There are no real deployments, only test installations. Existing prototype datab
28	28	\| SQLite archive \| Archive v2 schema, differential write path, v2 verification/delete bookkeeping, daily aggregate rebuilds, integrity report, v2 record reads, SQL diff/count/aggregate/provenance/consolidation-evidence APIs, large synthetic diff pagination coverage, formal timing/memory metrics, and XCTest coverage are in place; the legacy `archive_samples` mirror has been removed \| Start Core Data cache work \|
29	29	\| Core Data cache \| Initial programmatic Core Data model and full-cache rebuild service are in place for observation rows, type summaries, daily aggregates, diff summaries, export manifest rows, and archive health \| Wire cache reads into UI-facing view models and add targeted partial invalidation \|
30	30	\| SwiftData cache \| Exists \| Treat as disposable prototype data; reset/ignore during v2 transition \|
31		-\| UI \| Prototype exists \| Reframe screens around observations, diffs, export, archive status \|
	31	+\| UI \| Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker, and record-change detail uses a separate preview/paged list view with archive-value enrichment and scoped export action \| Reframe remaining screens around observations, diffs, export, archive status \|
32	32	\| Diff/change explanation \| Prototype/legacy anomaly logic exists \| Move heavy diffing into SQLite and use neutral change classifications \|
33	33	\| Export \| Prototype scoped JSON export exists \| Add recovery-compatible manifests and streaming/paged export \|
34	34	\| Legacy device support \| Not implemented \| Remove SwiftData dependency and simplify heavy views for low-memory devices \|

	@@ -1,10 +1,8 @@
1	1	import Foundation
2		-import UIKit
3	2
4	3	@Observable
5	4	final class AppSettings {
6	5	private static let selectedTypeIDsKey = "hp_selectedTypeIDs"
7		- private static let selectedDeviceIDsKey = "hp_selectedDeviceIDs"
8	6	static let adaptiveTimeoutsEnabledKey = "hp_adaptiveTimeoutsEnabled"
9	7	static let typeDetailCacheBackfillVersionKey = "hp_typeDetailCacheBackfillVersion"
10	8	static let currentTypeDetailCacheBackfillVersion = 2
	@@ -13,10 +11,6 @@ final class AppSettings {
13	11	didSet { persistTypes() }
14	12	}
15	13
16		- var selectedDeviceIDs: Set<String> {
17		- didSet { persistDevices() }
18		- }
19		-
20	14	var adaptiveTimeoutsEnabled: Bool {
21	15	didSet {
22	16	UserDefaults.standard.set(adaptiveTimeoutsEnabled, forKey: Self.adaptiveTimeoutsEnabledKey)
	@@ -35,27 +29,11 @@ final class AppSettings {
35	29	selectedTypeIDs = Set(HealthKitService.allTypes.filter { $0.isEnabledByDefault }.map { $0.id })
36	30	}
37	31
38		- if let data = UserDefaults.standard.data(forKey: Self.selectedDeviceIDsKey),
39		- let ids = try? JSONDecoder().decode([String].self, from: data) {
40		- let storedIDs = Set(ids)
41		- let oldCurrentID = UIDevice.current.identifierForVendor?.uuidString
42		- if let oldCurrentID, storedIDs == [oldCurrentID] {
43		- selectedDeviceIDs = [Self.currentDeviceID]
44		- } else {
45		- selectedDeviceIDs = storedIDs
46		- }
47		- } else {
48		- let currentID = Self.currentDeviceID
49		- selectedDeviceIDs = currentID.isEmpty ? [] : [currentID]
50		- }
51		-
52	32	if UserDefaults.standard.object(forKey: Self.adaptiveTimeoutsEnabledKey) == nil {
53	33	adaptiveTimeoutsEnabled = true
54	34	} else {
55	35	adaptiveTimeoutsEnabled = UserDefaults.standard.bool(forKey: Self.adaptiveTimeoutsEnabledKey)
56	36	}
57		-
58		- persistDevices()
59	37	}
60	38
61	39	func isEnabled(_ type: MonitoredType) -> Bool { selectedTypeIDs.contains(type.id) }
	@@ -65,18 +43,8 @@ final class AppSettings {
65	43	else { selectedTypeIDs.insert(type.id) }
66	44	}
67	45
68		- func toggleDevice(_ id: String) {
69		- if selectedDeviceIDs.contains(id) { selectedDeviceIDs.remove(id) }
70		- else { selectedDeviceIDs.insert(id) }
71		- }
72		-
73	46	private func persistTypes() {
74	47	UserDefaults.standard.set(try? JSONEncoder().encode(Array(selectedTypeIDs)),
75	48	forKey: Self.selectedTypeIDsKey)
76	49	}
77		-
78		- private func persistDevices() {
79		- UserDefaults.standard.set(try? JSONEncoder().encode(Array(selectedDeviceIDs)),
80		- forKey: Self.selectedDeviceIDsKey)
81		- }
82	50	}

	@@ -26,13 +26,6 @@ enum DeviceColor: String, CaseIterable, Identifiable {
26	26	}
27	27	}
28	28
29		-struct DeviceEntry: Identifiable {
30		- let id: String // deviceID; "" = unidentified
31		- let displayName: String
32		- let color: Color
33		- let isCurrent: Bool
34		-}
35		-
36	29	struct SeverityBadge: View {
37	30	let delta: Int
38	31	var dimmed: Bool = false

	@@ -2,41 +2,23 @@ import SwiftUI
2	2	import SwiftData
3	3
4	4	struct DataTypesView: View {
5		- @Environment(AppSettings.self) private var appSettings
6	5	@Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]
7		- @Query private var deviceProfiles: [DeviceProfile]
8	6	@State private var viewModel = DataTypesViewModel()
9	7
10		- private var profileMap: [String: DeviceProfile] {
11		- Dictionary(uniqueKeysWithValues: deviceProfiles.compactMap {
12		- $0.deviceID.isEmpty ? nil : ($0.deviceID, $0)
13		- })
14		- }
15		-
16	8	private var displayedSnapshots: [HealthSnapshot] {
17		- let selected = appSettings.selectedDeviceIDs
18		- guard !selected.isEmpty else { return [] }
19		- return allSnapshots.filter { selected.contains($0.deviceID) }
	9	+ guard let deviceID = localDeviceID else { return [] }
	10	+ return allSnapshots.filter { $0.deviceID == deviceID }
20	11	}
21	12
22	13	private var latest: HealthSnapshot? { displayedSnapshots.first }
23	14
24		- private var knownDevices: [DeviceEntry] {
	15	+ private var localDeviceID: String? {
25	16	let currentID = AppSettings.currentDeviceID
26		- var ids = Set(allSnapshots.map { $0.deviceID })
27		- if !currentID.isEmpty { ids.insert(currentID) }
28		- return ids.map { id in
29		- let profile = profileMap[id]
30		- let name: String
31		- if let n = profile?.name, !n.isEmpty { name = n }
32		- else if id.isEmpty { name = "Unidentified" }
33		- else { name = "Unknown Device" }
34		- let color = DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
35		- return DeviceEntry(id: id, displayName: name, color: color, isCurrent: id == currentID)
36		- }.sorted {
37		- if $0.isCurrent != $1.isCurrent { return $0.isCurrent }
38		- return $0.displayName < $1.displayName
	17	+ if allSnapshots.contains(where: { $0.deviceID == currentID }) {
	18	+ return currentID
39	19	}
	20	+
	21	+ return allSnapshots.first?.deviceID
40	22	}
41	23
42	24	var body: some View {
	@@ -45,10 +27,8 @@ struct DataTypesView: View {
45	27	if displayedSnapshots.count < 2 {
46	28	EmptyStateView(
47	29	icon: "waveform.path.ecg",
48		- title: appSettings.selectedDeviceIDs.isEmpty ? "No Devices Selected" : "Not Enough Data",
49		- message: appSettings.selectedDeviceIDs.isEmpty
50		- ? "Select at least one device using the filter above."
51		- : "Create at least two snapshots to compare data types."
	30	+ title: "Not Enough Data",
	31	+ message: "Create at least two local snapshots to compare data types."
52	32	)
53	33	} else {
54	34	typeList
	@@ -106,9 +86,6 @@ struct DataTypesView: View {
106	86
107	87	@ToolbarContentBuilder
108	88	private var filterPicker: some ToolbarContent {
109		- ToolbarItem(placement: .topBarLeading) {
110		- devicePickerMenu
111		- }
112	89	ToolbarItem(placement: .navigationBarTrailing) {
113	90	Menu {
114	91	Picker("Filter", selection: $viewModel.filter) {
	@@ -122,32 +99,6 @@ struct DataTypesView: View {
122	99	}
123	100	}
124	101	}
125		-
126		- private var devicePickerMenu: some View {
127		- let selected = appSettings.selectedDeviceIDs
128		- let isMulti = selected.count > 1
129		- return Menu {
130		- ForEach(knownDevices) { entry in
131		- Button {
132		- appSettings.toggleDevice(entry.id)
133		- } label: {
134		- Label {
135		- Text(entry.isCurrent
136		- ? "\(entry.displayName) (This Device)"
137		- : entry.displayName)
138		- } icon: {
139		- Image(systemName: selected.contains(entry.id)
140		- ? "checkmark.circle.fill" : "circle.fill")
141		- .foregroundStyle(entry.color)
142		- }
143		- }
144		- }
145		- } label: {
146		- Image(systemName: "iphone")
147		- }
148		- .tint(isMulti ? .orange : .accentColor)
149		- .accessibilityLabel("Select devices – \(selected.count) selected")
150		- }
151	102	}
152	103
153	104	// MARK: - Row

	@@ -1,10 +1,8 @@
1	1	import SwiftUI
2	2	import SwiftData
3		-import UIKit
4	3
5	4	struct SnapshotsView: View {
6	5	@Environment(\.modelContext) private var modelContext
7		- @Environment(AppSettings.self) private var appSettings
8	6	@Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]
9	7	@Query private var allDeltas: [SnapshotDelta]
10	8	@Query private var deviceProfiles: [DeviceProfile]
	@@ -17,9 +15,8 @@ struct SnapshotsView: View {
17	15	}
18	16
19	17	private var displayedSnapshots: [HealthSnapshot] {
20		- let selected = appSettings.selectedDeviceIDs
21		- guard !selected.isEmpty else { return [] }
22		- return allSnapshots.filter { selected.contains($0.deviceID) }
	18	+ guard let deviceID = localDeviceID else { return [] }
	19	+ return allSnapshots.filter { $0.deviceID == deviceID }
23	20	}
24	21
25	22	private var snapshotItems: [SnapshotListItem] {
	@@ -38,23 +35,13 @@ struct SnapshotsView: View {
38	35	}
39	36	}
40	37
41		- private var knownDevices: [DeviceEntry] {
	38	+ private var localDeviceID: String? {
42	39	let currentID = AppSettings.currentDeviceID
43		- var ids = Set(allSnapshots.map { $0.deviceID })
44		- ids.insert(currentID)
45		- return ids.map { id in
46		- let profile = profileMap[id]
47		- let name: String
48		- if let n = profile?.name, !n.isEmpty { name = n }
49		- else if id.isEmpty { name = "Unidentified" }
50		- else { name = "Unknown Device" }
51		- let color = DeviceColor(rawValue: profile?.colorTag ?? "")?.color ?? .neutralGray
52		- return DeviceEntry(id: id, displayName: name, color: color, isCurrent: id == currentID)
53		- }
54		- .sorted {
55		- if $0.isCurrent != $1.isCurrent { return $0.isCurrent }
56		- return $0.displayName < $1.displayName
	40	+ if allSnapshots.contains(where: { $0.deviceID == currentID }) {
	41	+ return currentID
57	42	}
	43	+
	44	+ return allSnapshots.first?.deviceID
58	45	}
59	46
60	47	var body: some View {
	@@ -63,10 +50,8 @@ struct SnapshotsView: View {
63	50	if displayedSnapshots.isEmpty {
64	51	EmptyStateView(
65	52	icon: "clock.arrow.circlepath",
66		- title: appSettings.selectedDeviceIDs.isEmpty ? "No Devices Selected" : "No Snapshots",
67		- message: appSettings.selectedDeviceIDs.isEmpty
68		- ? "Select at least one device using the filter above."
69		- : "Use the Dashboard to create your first snapshot."
	53	+ title: "No Snapshots",
	54	+ message: "Use the Dashboard to create your first local snapshot."
70	55	)
71	56	} else {
72	57	snapshotList
	@@ -77,13 +62,6 @@ struct SnapshotsView: View {
77	62	.task(id: allDeltas.count) {
78	63	repairDeltaListSummariesIfNeeded()
79	64	}
80		- .onChange(of: appSettings.selectedDeviceIDs) {
81		- if let baseline = viewModel.selectedBaseline,
82		- !displayedSnapshots.contains(where: { $0.id == baseline.id }) {
83		- viewModel.selectedBaseline = nil
84		- viewModel.comparisonMode = .previous
85		- }
86		- }
87	65	}
88	66	}
89	67
	@@ -137,9 +115,6 @@ struct SnapshotsView: View {
137	115
138	116	@ToolbarContentBuilder
139	117	private var toolbarContent: some ToolbarContent {
140		- ToolbarItem(placement: .topBarLeading) {
141		- devicePickerMenu
142		- }
143	118	ToolbarItem(placement: .navigationBarTrailing) {
144	119	Menu {
145	120	Picker("Compare Against", selection: $viewModel.comparisonMode) {
	@@ -158,32 +133,6 @@ struct SnapshotsView: View {
158	133	}
159	134	}
160	135
161		- private var devicePickerMenu: some View {
162		- let selected = appSettings.selectedDeviceIDs
163		- let isMulti = selected.count > 1
164		- return Menu {
165		- ForEach(knownDevices) { entry in
166		- Button {
167		- appSettings.toggleDevice(entry.id)
168		- } label: {
169		- Label {
170		- Text(entry.isCurrent
171		- ? "\(entry.displayName) (This Device)"
172		- : entry.displayName)
173		- } icon: {
174		- Image(systemName: selected.contains(entry.id)
175		- ? "checkmark.circle.fill" : "circle.fill")
176		- .foregroundStyle(entry.color)
177		- }
178		- }
179		- }
180		- } label: {
181		- Image(systemName: "iphone")
182		- }
183		- .tint(isMulti ? .orange : .accentColor)
184		- .accessibilityLabel("Select devices – \(selected.count) selected")
185		- }
186		-
187	136	private func repairDeltaListSummariesIfNeeded() {
188	137	do {
189	138	_ = try DeltaService.rebuildMissingListSummaries(context: modelContext, maxCount: 64)