| HealthKit capture | Capture now opens one archive observation per user-visible snapshot and attaches HealthKit pages, deleted-object evidence, and type verification to that observation id before finishing it | Continue moving UI/cache reads to archive-backed observation ids |

 | SQLite archive | Archive v2 schema, snapshot-level observation grouping, 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 | Continue moving capture/Dashboard actions to archive/cache DTOs |

 | Core Data cache | Initial programmatic Core Data model, full-cache rebuild service, read DTOs for observation/type/diff/health rows, and Dashboard archive-cache status wiring are in place | Move remaining export/report paths to cache DTOs and add targeted partial invalidation |

 | Diff/change explanation | SQL diff summaries, paged diff records, aggregate comparisons, and consolidation-evidence labels exist; legacy anomaly/count-drop review has been removed from active flows; the old direct `HealthSnapshot.typeCounts` diff helper has been retired | Keep active diff/count views on archive/cache DTOs |

 | Export | SQLite export preview, paged JSON writing, SHA256 manifest hashing, and `export_manifests` rows are in place for selected records and observation diffs | Fill remaining recovery-compatible envelope metadata, CSV export, relationship preservation, and reproducibility checks |

 | Legacy device support | Simplified detail UI mode is implemented for small/accessibility layouts and as a Settings toggle | Remove SwiftData dependency and validate lower deployment targets |

 - SwiftData currently blocks iOS 15-era device support.

 - Some screens still imply snapshot-count monitoring rather than Time Machine inspection.

 - Snapshots timeline/detail rows, Data Types list/detail rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist.

 - Legacy SwiftData-only snapshots are reset for archive v2 test installs rather than migrated.

 - Capture strategy and some legacy SwiftData transition paths may still decode or cache too much data for low-end devices.

 Checklist:

 - [ ] Replace direct SwiftData `@Query` dependencies for target screens.

 - [x] Dashboard status reads Core Data cached observation rows and cache health,

 - [x] Observation timeline rows read Core Data cache when available and no

   longer query `SnapshotDelta` list summaries.

 - [x] Observation root and archive detail use cached summary/type rows plus

   moved to local Codable stores and removed from `ModelContainer`; Settings

   data maintenance now uses the rebuildable Core Data cache; legacy

   anomaly/count-drop review has been deleted; Snapshots/Data Types tab roots no

   `YearlyCount`, and `TypeDistributionBin` are no longer SwiftData models;

 - [ ] Remove/disable `ModelContainer` as required for target builds.

 - [x] Add prototype-store ignore/delete/reset path for test installs.

 - [ ] Verify no old-store compatibility layer remains in active flows.

 ## Current Count

 ## Launch Container

 types:

 - `HealthProbe/ViewModels/DashboardViewModel.swift`

 Retirement path:

 - move capture/review actions away from `ModelContext`;

 - `HealthProbe/Views/Dashboard/DashboardView.swift` no longer queries

   `HealthSnapshot` for status rows; Dashboard status now uses archive/cache rows

   only. SwiftData remains there for capture/review actions.

 - `HealthProbe/Views/DataTypes/RecordChangeEvolutionChart.swift` now accepts a

   small `RecordChangeEvolutionSnapshot` DTO and loads archive/cache counts

   without importing SwiftData or querying `SnapshotDelta`.

 ## Next Recommended Slices

    Dashboard actions no longer need them.

     var sharedModelContainer: ModelContainer = {

         do {

         } catch {

             fatalError("Could not create ModelContainer: \(error)")

         }

 import Foundation

 import SwiftData

 @Observable

 final class DashboardViewModel {

     var isRequestingAuth = false

     }

     func createSnapshot(

         selectedTypeIDs: Set<String>,

         adaptiveTimeoutsEnabled: Bool,

         triggerReason: String = "manual",

             return

         }

         isCreatingSnapshot = true

         snapshotError = nil

         snapshotProgress = .fetching

                 if shouldAutoSaveKnownUnauthorizedPartial(snapshot: snapshot, failedCount: failedCount, context: context) {

                     snapshotProgressMessage = "Known unavailable metrics"

                     snapshotProgressDetail = "Snapshot was auto-saved as partial because unavailable metrics were already confirmed in the previous snapshot."

                     return

                 }

         }

     }

         guard let snapshot = pendingAmbiguousSnapshot else { return }

         let ambiguousIDs = Set(ambiguousDisappearedMetrics.map(\.id))

         let typeCounts = snapshot.typeCounts ?? []

         snapshot.snapshotQuality = healthKit.deriveSnapshotQuality(from: typeCounts)

         do {

             let saved = try await healthKit.savePartialSnapshot(snapshot, in: context)

             finishSavedReviewedSnapshot(saved)

         } catch {

         }

     }

         guard let snapshot = pendingAmbiguousSnapshot else { return }

         do {

             let saved = try await healthKit.saveReviewedCompleteSnapshot(snapshot, in: context)

             finishSavedReviewedSnapshot(saved)

         } catch {

         }

     }

         isRequestingAuth = true

         defer { isRequestingAuth = false }

         do {

             try await healthKit.requestAuthorization()

         } catch {

             snapshotError = "Failed to request permissions: \(error.localizedDescription)"

             snapshotProgress = .idle

     }

     func retryFailedMetricsWithExtendedTimeout(

         selectedTypeIDs: Set<String>,

         adaptiveTimeoutsEnabled: Bool

     ) async {

         guard hasTimeout else { return }

         await createSnapshot(

             selectedTypeIDs: selectedTypeIDs,

             adaptiveTimeoutsEnabled: adaptiveTimeoutsEnabled,

             triggerReason: "retryFailedMetrics",

         )

     }

         guard let snapshot = pendingPartialSnapshot else {

             if !keepSheetOpenForReview {

                 fetchProgress = nil

         }

         do {

             let saved = try await healthKit.savePartialSnapshot(snapshot, in: context)

             completedSnapshotID = saved.id

             completedSnapshotTimestamp = saved.timestamp

         snapshotProgress = .idle

     }

         pendingPartialSnapshot = nil

         pendingAmbiguousSnapshot = nil

         ambiguousDisappearedMetrics = []

         if let snapshotID = completedSnapshotID {

             do {

                 var descriptor = FetchDescriptor<HealthSnapshot>(

                     predicate: #Predicate<HealthSnapshot> { $0.id == snapshotID }

                 )

 import SwiftUI

 import HealthKit

 import UIKit

 struct DashboardView: View {

     @Environment(AppSettings.self) private var appSettings

     @State private var viewModel = DashboardViewModel()

     @State private var currentDeviceProfile = LocalDeviceProfileStore.profile(for: AppSettings.currentDeviceID)

                     Task {

                         if viewModel.canRetryWithPermissions {

                             await viewModel.retryWithPermissions(

                                 selectedTypeIDs: appSettings.selectedTypeIDs,

                                 adaptiveTimeoutsEnabled: appSettings.adaptiveTimeoutsEnabled

                             )

                         } else {

                             await viewModel.retryFailedMetricsWithExtendedTimeout(

                                 selectedTypeIDs: appSettings.selectedTypeIDs,

                                 adaptiveTimeoutsEnabled: appSettings.adaptiveTimeoutsEnabled

                             )

             }

             Button {

             } label: {

                 Text("Save Partial").frame(maxWidth: .infinity)

             }

             .accessibilityLabel("Save partial snapshot")

             Button {

             } label: {

                 Text("Discard").foregroundStyle(Color.criticalRed).frame(maxWidth: .infinity)

             }

     private var ambiguousResolutionActionsSection: some View {

         VStack(spacing: 10) {

             Button {

             } label: {

                 Label("Treat as Unauthorized", systemImage: "lock.slash")

                     .frame(maxWidth: .infinity)

             .accessibilityLabel("Treat missing metrics as unauthorized")

             Button {

             } label: {

                 Label("Treat as Missing", systemImage: "minus.circle")

                     .frame(maxWidth: .infinity)

             .accessibilityLabel("Treat missing metrics as absent from the current Health store")

             Button {

             } label: {

                 Label("Cancel Save", systemImage: "xmark")

                     .foregroundStyle(Color.criticalRed)

             Button {

                 Task {

                     await viewModel.createSnapshot(

                         selectedTypeIDs: appSettings.selectedTypeIDs,

                         adaptiveTimeoutsEnabled: appSettings.adaptiveTimeoutsEnabled

                     )

 #Preview {

     DashboardView()

         .environment(AppSettings())

 }