#Preview {

     ContentView()

         .environment(AppSettings())

 }

 | 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 | Move Snapshots/Data Types from SwiftData previews 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 |

 | UI | Prototype exists; Snapshots/Data Types now default to the local device timeline instead of a multi-device picker. Dashboard status prefers archive/cache observation rows and shows cache health; Snapshots timeline, snapshot detail summaries/type rows, and Data Types list prefer Core Data cache rows when archive observation ids exist; data type detail reads Core Data type/diff summaries and uses SQLite `diffRecords` for paged drill-down; export preview reads the archive export API before showing/exporting JSON; simplified detail mode replaces heavy charts with summary rows on small/accessibility layouts or when enabled in Settings; visible change labels now use neutral new/missing/change-review language, with SwiftData detail cache as transition fallback | Remove remaining SwiftData navigation handles |

 | Diff/change explanation | Prototype/legacy anomaly logic exists | Move heavy diffing into SQLite and use neutral change classifications |

 | 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 |

 - SwiftData currently blocks iOS 15-era device support.

 - Existing `Anomaly*` model/service names are legacy language.

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

 - Snapshots timeline, snapshot detail summary/type rows, Data Types list rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist, but navigation still uses SwiftData snapshot handles during the transition.

 - Legacy SwiftData-only snapshots can show diffs without archive-backed values; they are now 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:

 - [x] Identify all remaining SwiftData imports.

 - [ ] Replace SwiftData models used by active flows. Metric timeout calibration

 - [ ] 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

 - `HealthProbe/ContentView.swift`

 Retirement path:

 - replace prototype snapshot model dependencies in tab roots;

 - remove `.modelContainer(...)` once no active view needs `@Query` or

   `ModelContext`.

 block:

 - `HealthProbe/Models/AnomalyRecord.swift`

 - `HealthProbe/Models/HealthRecord.swift`

 - `HealthProbe/Models/HealthSnapshot.swift`

 - `HealthProbe/Models/OperationLog.swift`

   `YearlyCount`, `TypeDistributionBin`, and `HealthRecord` active reads with

   archive/cache DTOs;

 - replace `AnomalyRecord` flows with neutral change/diff DTOs;

 ## Capture And Maintenance Services

   queries plus archive ids;

 - replace detail navigation parameters from SwiftData models to observation/type

   DTOs;

 - keep paged record drill-down and export paths on archive APIs.

 ## Removed During This Pass

   store outside `ModelContainer`.

 - `SettingsView`, `DashboardView`, and `HealthKitService` read/write timeout

   calibration through the local store.

 ## Next Recommended Slices

 2. Replace `ContentView` preview/container dependency after tab roots stop using

    `@Query`.

 3. Move `DashboardView` capture review actions away from `ModelContext`.

         let fullSchema = Schema([

             HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,

             SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,

         ])

         let appSupportURL = URL.applicationSupportDirectory

             HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,

             SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,

         ])

         let uiCacheConfig = ModelConfiguration(

             "ui-cache",

     static func extractReportData(

         snapshot: HealthSnapshot,

         baseline: HealthSnapshot?,

     ) -> SnapshotReportData {

         let profileName: String? = {

             guard let n = profile?.name, !n.isEmpty else { return nil }

     @Environment(\.modelContext) private var modelContext

     @Environment(AppSettings.self) private var appSettings

     @Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var snapshots: [HealthSnapshot]

     @State private var viewModel = DashboardViewModel()

     @State private var didAutoRequestPermissions = false

     @State private var snapshotSheetTab: SnapshotSheetTab = .progress

     @State private var diagnosticReport: DiagnosticReport?

         guard viewModel.archiveObservationRows.count > 1 else { return nil }

         return viewModel.archiveObservationRows[1]

     }

     private var currentDeviceDisplayName: String {

         if let latest, !latest.deviceName.isEmpty { return latest.deviceName }

         return "Local device"

     }

             progressSheet

         }

         .task {

             viewModel.loadArchiveCacheStatus()

             if !didAutoRequestPermissions && !HealthKitService.shared.hasRequestedPermissionsBefore {

                 didAutoRequestPermissions = true

 #Preview {

     DataTypesView()

         .environment(AppSettings())

 }

     @Environment(\.modelContext) private var modelContext

     @Environment(AppSettings.self) private var appSettings

     @Query private var snapshots: [HealthSnapshot]

     @AppStorage("checkFrequencyHours") private var checkFrequencyHours: Int = 6

     @State private var showDeleteConfirm = false

     @State private var showRepairLegacyRecordsConfirm = false

     @State private var dataMaintenanceMessage: String?

     @State private var timeoutProfiles: [LocalMetricTimeoutProfile] = []

     private var currentDeviceID: String {

         AppSettings.currentDeviceID

     }

     var body: some View {

         NavigationStack {

             List {

             }

             .navigationTitle("Settings")

             .onAppear {

                 loadTimeoutProfiles()

             }

             .confirmationDialog(

                     Spacer()

                     TextField("Device name", text: Binding(

                         get: { profile.name },

                         }

                     ))

                     .multilineTextAlignment(.trailing)

                                 }

                             }

                             .onTapGesture {

                             }

                             .accessibilityLabel(dc.rawValue.capitalized)

                             .accessibilityAddTraits(profile.colorTag == dc.rawValue ? .isSelected : [])

     // MARK: - Actions

     }

     private func loadTimeoutProfiles() {

 #Preview {

     SettingsView()

         .environment(AppSettings())

 }

 struct SnapshotDetailView: View {

     let snapshot: HealthSnapshot

     let baseline: HealthSnapshot?

     @Query(sort: \HealthSnapshot.timestamp) private var allSnapshots: [HealthSnapshot]

     @Query private var allDeltas: [SnapshotDelta]

                 deviceID: "preview-device"

             ),

             baseline: nil,

         )

     }

 }

     @Environment(\.modelContext) private var modelContext

     @Query(sort: \HealthSnapshot.timestamp, order: .reverse) private var allSnapshots: [HealthSnapshot]

     @Query private var allDeltas: [SnapshotDelta]

     @State private var viewModel = SnapshotsViewModel()

     private var displayedSnapshots: [HealthSnapshot] {

         guard let deviceID = localDeviceID else { return [] }

                 repairDeltaListSummariesIfNeeded()

             }

             .task(id: timelineReloadID) {

                 await viewModel.loadArchiveRows()

             }

         }

             // Keep the list responsive even if summary repair fails.

         }

     }

 }

 private struct SnapshotListItem: Identifiable {

     let deltaSummary: SnapshotDeltaListSummary?

     let showsDeltaSummary: Bool

     let isSelectedBaseline: Bool

     private static let dateFormatter: DateFormatter = {

         let f = DateFormatter()

 #Preview {

     SnapshotsView()

         .environment(AppSettings())

 }