+| 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 replacing remaining transition detail/PDF paths with archive/cache DTOs |

+| SwiftData cache | Exists; test builds now reset legacy prototype UI/archive/cache stores once for archive v2 so old SwiftData-only snapshots are not treated as backed-up observations. Metric timeout calibration, local device profile settings, operation logging, ContentView preview, Settings data maintenance, and legacy anomaly/count-drop review have moved outside SwiftData or been removed. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; replace capture/review actions and transition detail/PDF paths before removing `ModelContainer` |

+| UI | Prototype exists; Dashboard status reads archive/cache observation rows and shows cache health, with SwiftData retained only for capture/review actions; Snapshots and Data Types tab roots no longer import SwiftData, load Core Data cached observation rows, and open archive/cache-backed detail rows; `SnapshotArchiveDetailView` and `DataTypeArchiveDetailView` read Core Data type/diff summaries and page record drill-down through SQLite; legacy `SnapshotDetailView`/`DataTypeSnapshotDetailView` remain as transition views outside the active tab roots; record-change evolution and temporal distribution screens now receive DTO rows/cache input instead of querying SwiftData directly; 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 already-existing SwiftData detail cache as transition fallback | Remove or isolate remaining SwiftData transition detail/PDF paths |

+1. Remove or isolate remaining SwiftData transition detail/PDF paths.

+- Current UI/cache layers still depend on 17 SwiftData-backed files for launch container, capture review actions, legacy transition detail paths, model definitions, and PDF paths.

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

+- [x] Snapshot tab navigation/detail rows use Core Data cached summaries plus SQLite diff summaries when archive observation ids are available.

+- [ ] Wire Core Data cache into remaining UI-facing view models. Dashboard

+  status, Snapshots root/detail, Data Types root/detail, record-change

+  evolution, and temporal distribution now use cache/archive DTOs.

+  longer query `SnapshotDelta` list summaries.

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

+  SQLite diff summaries and no longer require SwiftData navigation handles.

+- [x] Snapshots root reads Core Data cached observation rows directly and no longer imports SwiftData.

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

+  longer import SwiftData; Dashboard capture/review actions and legacy

+  transition detail/PDF paths remain.

+After moving the Snapshots and Data Types tab roots to archive/cache

+observations, 17 app files still have SwiftData imports because capture,

+Dashboard review actions, legacy detail transition paths, model definitions, and

+PDF/export transition paths still use prototype snapshot handles.

+- `HealthProbe/Views/Snapshots/SnapshotsView.swift` no longer imports

+  SwiftData or queries `HealthSnapshot`; it loads Core Data cached observation

+  rows and opens `SnapshotArchiveDetailView`, an archive/cache-only detail view

+  that feeds Data Type drill-down through observation ids and cached summaries.

+2. Delete or isolate unused SwiftData snapshot/type detail transition views once

+   PDF/export and any remaining preview paths have archive/cache replacements.

+    var selectedBaselineObservationID: Int64?

+    func baselines(for rows: [CachedArchiveObservationRow]) -> [Int64: CachedArchiveObservationRow] {

+        let orderedDescending = rows.sorted { $0.observedAt > $1.observedAt }

+        return rows.reduce(into: [Int64: CachedArchiveObservationRow]()) { partial, row in

+            partial[row.observationID] = baseline(

+                for: row,

+                in: rows,

+    func baseline(

+        for row: CachedArchiveObservationRow,

+        in rows: [CachedArchiveObservationRow]

+    ) -> CachedArchiveObservationRow? {

+            for: row,

+            in: rows,

+            orderedDescending: rows.sorted { $0.observedAt > $1.observedAt }

+        for row: CachedArchiveObservationRow,

+        in rows: [CachedArchiveObservationRow],

+        orderedDescending: [CachedArchiveObservationRow]

+    ) -> CachedArchiveObservationRow? {

+            return orderedDescending.first { $0.observedAt < row.observedAt }

+            guard let selectedBaselineObservationID else { return nil }

+            return rows.first { $0.observationID == selectedBaselineObservationID }

+            let target = row.observedAt.addingTimeInterval(-interval)

+            return rows

+                .filter { $0.observedAt <= target }

+                .max { $0.observedAt < $1.observedAt }

+    func toggleBaseline(_ row: CachedArchiveObservationRow) {

+        if selectedBaselineObservationID == row.observationID {

+            selectedBaselineObservationID = nil

+            selectedBaselineObservationID = row.observationID

+import SwiftUI

+

+struct SnapshotArchiveDetailView: View {

+    let row: CachedArchiveObservationRow

+    let baseline: CachedArchiveObservationRow?

+    let timelineRows: [CachedArchiveObservationRow]

+

+    @State private var typeRows: [SnapshotArchiveTypeSummaryRow] = []

+    @State private var loadError: String?

+

+    private var timelineContexts: [DataTypeSnapshotContext] {

+        timelineRows

+            .sorted { $0.observedAt > $1.observedAt }

+            .map {

+                DataTypeSnapshotContext(

+                    observationID: $0.observationID,

+                    observedAt: $0.observedAt

+                )

+            }

+    }

+

+    private var currentContext: DataTypeSnapshotContext {

+        DataTypeSnapshotContext(

+            observationID: row.observationID,

+            observedAt: row.observedAt

+        )

+    }

+

+    private var baselineContext: DataTypeSnapshotContext? {

+        baseline.map {

+            DataTypeSnapshotContext(

+                observationID: $0.observationID,

+                observedAt: $0.observedAt

+            )

+        }

+    }

+

+    private var dataRange: (earliest: Date?, latest: Date?) {

+        (

+            typeRows.compactMap(\.earliestStartDate).min(),

+            typeRows.compactMap(\.latestEndDate).max()

+        )

+    }

+

+    private var taskID: String {

+        "\(baseline?.observationID ?? -1)|\(row.observationID)"

+    }

+

+    var body: some View {

+        List {

+            summarySection

+            typeSection

+        }

+        .navigationTitle("Snapshot")

+        .navigationBarTitleDisplayMode(.inline)

+        .task(id: taskID) {

+            await loadTypeRows()

+        }

+    }

+

+    private var summarySection: some View {

+        Section {

+            DataTypeRangeIndicator(

+                earliestDate: dataRange.earliest,

+                latestDate: dataRange.latest,

+                quality: .complete

+            )

+            .listRowInsets(EdgeInsets())

+            .listRowBackground(Color.clear)

+

+            SnapshotArchiveSummaryRow(label: "Metrics", value: "\(row.trackedTypeCount)")

+            SnapshotArchiveSummaryRow(label: "Records", value: "\(row.visibleRecordCount)")

+

+            if let baseline {

+                SnapshotArchiveSummaryRow(

+                    label: "Baseline",

+                    value: baseline.observedAt.formatted(.dateTime.month().day().hour().minute())

+                )

+                SnapshotArchiveSummaryRow(

+                    label: "Record Changes",

+                    value: "\(row.appearedCount + row.disappearedCount + row.representationChangedCount)"

+                )

+            }

+

+            if let loadError {

+                Label(loadError, systemImage: "exclamationmark.triangle.fill")

+                    .font(.caption)

+                    .foregroundStyle(Color.warningAmber)

+            }

+        }

+    }

+

+    private var typeSection: some View {

+        Section("Data Types") {

+            if typeRows.isEmpty {

+                Text("No data types are available for this observation.")

+                    .foregroundStyle(.secondary)

+            } else {

+                ForEach(typeRows) { typeRow in

+                    if let baselineContext {

+                        NavigationLink {

+                            DataTypeArchiveDetailView(

+                                current: currentContext,

+                                baseline: baselineContext,

+                                timeline: timelineContexts,

+                                typeIdentifier: typeRow.typeIdentifier,

+                                displayName: typeRow.displayName,

+                                initialDiff: typeRow.typeDiff

+                            )

+                        } label: {

+                            SnapshotArchiveTypeSummaryRowView(row: typeRow, hasBaseline: true)

+                        }

+                    } else {

+                        SnapshotArchiveTypeSummaryRowView(row: typeRow, hasBaseline: false)

+                    }

+                }

+            }

+        }

+    }

+

+    @MainActor

+    private func loadTypeRows() async {

+        do {

+            let cache = try CoreDataArchiveCacheStore()

+            let currentSummaries = try cache.typeSummaries(observationID: row.observationID)

+            let previousSummaries: [CachedArchiveTypeSummary]

+            if let baseline {

+                previousSummaries = try cache.typeSummaries(observationID: baseline.observationID)

+            } else {

+                previousSummaries = []

+            }

+            let currentByType = Dictionary(uniqueKeysWithValues: currentSummaries.map { ($0.sampleTypeIdentifier, $0) })

+            let previousByType = Dictionary(uniqueKeysWithValues: previousSummaries.map { ($0.sampleTypeIdentifier, $0) })

+            let typeIdentifiers = Set(currentByType.keys).union(previousByType.keys)

+

+            var rows: [SnapshotArchiveTypeSummaryRow] = []

+            rows.reserveCapacity(typeIdentifiers.count)

+

+            for typeIdentifier in typeIdentifiers {

+                let summary = currentByType[typeIdentifier]

+                let previousSummary = previousByType[typeIdentifier]

+                let diffSummary: CachedArchiveDiffSummary?

+                if let baseline {

+                    diffSummary = try cache.diffSummary(

+                        fromObservationID: baseline.observationID,

+                        toObservationID: row.observationID,

+                        sampleTypeIdentifier: typeIdentifier

+                    )

+                } else {

+                    diffSummary = nil

+                }

+

+                rows.append(SnapshotArchiveTypeSummaryRow(

+                    typeIdentifier: typeIdentifier,

+                    displayName: summary?.displayName ?? previousSummary?.displayName ?? typeIdentifier,

+                    currentCount: summary?.visibleRecordCount ?? 0,

+                    previousCount: previousSummary?.visibleRecordCount,

+                    appearedCount: diffSummary?.appearedCount ?? summary?.appearedCount ?? 0,

+                    disappearedCount: diffSummary?.disappearedCount ?? summary?.disappearedCount ?? 0,

+                    representationChangedCount: diffSummary?.representationChangedCount ?? summary?.representationChangedCount ?? 0,

+                    earliestStartDate: summary?.earliestStartDate ?? previousSummary?.earliestStartDate,

+                    latestEndDate: summary?.latestEndDate ?? previousSummary?.latestEndDate

+                ))

+            }

+

+            typeRows = rows.sorted {

+                $0.displayName.localizedCompare($1.displayName) == .orderedAscending

+            }

+            loadError = nil

+        } catch {

+            typeRows = []

+            loadError = error.localizedDescription

+        }

+    }

+}

+

+private struct SnapshotArchiveSummaryRow: View {

+    let label: String

+    let value: String

+

+    var body: some View {

+        HStack {

+            Text(label)

+            Spacer()

+            Text(value)

+                .foregroundStyle(.secondary)

+                .monospacedDigit()

+        }

+    }

+}

+

+private struct SnapshotArchiveTypeSummaryRow: Identifiable {

+    let typeIdentifier: String

+    let displayName: String

+    let currentCount: Int

+    let previousCount: Int?

+    let appearedCount: Int

+    let disappearedCount: Int

+    let representationChangedCount: Int

+    let earliestStartDate: Date?

+    let latestEndDate: Date?

+

+    var id: String { typeIdentifier }

+

+    var currentDelta: Int {

+        guard let previousCount else { return currentCount }

+        return currentCount - previousCount

+    }

+

+    var recordChangeCount: Int {

+        appearedCount + disappearedCount + representationChangedCount

+    }

+

+    var hasChanges: Bool {

+        currentDelta != 0 || recordChangeCount > 0

+    }

+

+    var typeDiff: TypeDiff {

+        TypeDiff(

+            id: typeIdentifier,

+            typeIdentifier: typeIdentifier,

+            displayName: displayName,

+            currentCount: currentCount,

+            previousCount: previousCount ?? 0,

+            previousTracked: previousCount != nil,

+            appearedCount: appearedCount,

+            disappearedCount: disappearedCount,

+            representationChangedCount: representationChangedCount

+        )

+    }

+}

+

+private struct SnapshotArchiveTypeSummaryRowView: View {

+    let row: SnapshotArchiveTypeSummaryRow

+    let hasBaseline: Bool

+

+    private var changeLabel: String {

+        guard hasBaseline else { return "Stored" }

+        if row.disappearedCount > 0 { return "\(row.disappearedCount) missing" }

+        if row.appearedCount > 0 { return "\(row.appearedCount) new" }

+        if row.representationChangedCount > 0 { return "\(row.representationChangedCount) changed" }

+        if row.currentDelta != 0 {

+            let prefix = row.currentDelta > 0 ? "+" : ""

+            return "\(prefix)\(row.currentDelta) records"

+        }

+        return "No changes"

+    }

+

+    private var changeColor: Color {

+        guard hasBaseline else { return .secondary }

+        if row.disappearedCount > 0 { return .criticalRed }

+        if row.hasChanges { return .warningAmber }

+        return .secondary

+    }

+

+    var body: some View {

+        HStack(spacing: 12) {

+            VStack(alignment: .leading, spacing: 3) {

+                Text(row.displayName)

+                    .font(.subheadline)

+                Text(row.typeIdentifier)

+                    .font(.caption2)

+                    .foregroundStyle(.secondary)

+                    .lineLimit(1)

+                    .truncationMode(.middle)

+            }

+

+            Spacer()

+

+            VStack(alignment: .trailing, spacing: 4) {

+                Text("\(row.currentCount)")

+                    .font(.subheadline.monospacedDigit())

+                    .foregroundStyle(.primary)

+                Text(changeLabel)

+                    .font(.caption.weight(.semibold))

+                    .foregroundStyle(changeColor)

+            }

+        }

+        .accessibilityElement(children: .combine)

+    }

+}

+

+#Preview {

+    NavigationStack {

+        SnapshotArchiveDetailView(

+            row: CachedArchiveObservationRow(

+                observationID: 2,

+                observedAt: .now,

+                status: "completed",

+                triggerReason: "manual",

+                timeZoneIdentifier: nil,

+                trackedTypeCount: 12,

+                visibleRecordCount: 2000,

+                appearedCount: 40,

+                disappearedCount: 10,

+                representationChangedCount: 3,

+                archiveSchemaVersion: 2,

+                cacheSchemaVersion: 1,

+                computedAt: .now

+            ),

+            baseline: nil,

+            timelineRows: []

+        )

+    }

+}

+    private var archiveRows: [CachedArchiveObservationRow] {

+        viewModel.archiveRows ?? []

+        !archiveRows.isEmpty

+        let baselines = viewModel.baselines(for: archiveRows)

+        return archiveRows.map { row in

+                archiveRow: row,

+                baseline: baselines[row.observationID],

+            .task {

+            NavigationLink {

+                SnapshotArchiveDetailView(

+                    row: item.archiveRow,

+                    timelineRows: archiveRows

+                )

+            } label: {

+                SnapshotRow(

+                    isSelectedBaseline: viewModel.selectedBaselineObservationID == item.archiveRow.observationID

+            .swipeActions(edge: .leading) {

+                Button {

+                    viewModel.toggleBaseline(item.archiveRow)

+                    viewModel.comparisonMode = .selected

+                } label: {

+                    Label(

+                        viewModel.selectedBaselineObservationID == item.archiveRow.observationID ? "Unset Baseline" : "Set as Baseline",

+                        systemImage: viewModel.selectedBaselineObservationID == item.archiveRow.observationID ? "pin.slash" : "pin"

+                    )

+                }

+                .tint(.indigo)

+            }

+        }

+        .refreshable {

+            await viewModel.loadArchiveRows()

+                    if viewModel.selectedBaselineObservationID != nil {

+    let archiveRow: CachedArchiveObservationRow

+    let baseline: CachedArchiveObservationRow?

+    var id: Int64 {

+        archiveRow.observationID

+    let archiveRow: CachedArchiveObservationRow

+        let formatter = DateFormatter()

+        formatter.dateStyle = .medium

+        formatter.timeStyle = .short

+        return formatter

+    private var metricCountLabel: String {

+        archiveRow.trackedTypeCount == 1

+            ? "1 metric"

+            : "\(archiveRow.trackedTypeCount) metrics"

+    private var recordCountLabel: String {

+        archiveRow.visibleRecordCount == 1

+    private var deltaSummaryText: String {

+        let appeared = archiveRow.appearedCount

+        let disappeared = archiveRow.disappearedCount

+        let changed = archiveRow.representationChangedCount

+        let total = appeared + disappeared + changed

+        guard total > 0 else { return "No record changes" }

+        var parts: [String] = []

+        if appeared > 0 { parts.append("\(appeared) new") }

+        if disappeared > 0 { parts.append("\(disappeared) missing") }

+        if changed > 0 { parts.append("\(changed) changed") }

+        return parts.joined(separator: " • ")

+        if archiveRow.disappearedCount > 0 { return Color.criticalRed }

+        if archiveRow.appearedCount + archiveRow.representationChangedCount > 0 { return Color.warningAmber }

+        return Color.healthyGreen

+        let hasChanges = archiveRow.appearedCount

+            + archiveRow.disappearedCount

+            + archiveRow.representationChangedCount > 0

+        return hasChanges ? "arrow.triangle.2.circlepath" : "checkmark.circle"

+                Text(Self.dateFormatter.string(from: archiveRow.observedAt))

+                    .fill(Color.neutralGray)

+                Text("Local archive")

+                Label(metricCountLabel, systemImage: "list.bullet.rectangle")

+                    .foregroundStyle(.secondary)

+                Label(recordCountLabel, systemImage: "doc.text.magnifyingglass")

+                    .font(.caption)

+                    .foregroundStyle(.secondary)

+            Label("Archive observation \(archiveRow.observationID)", systemImage: "externaldrive")

+                .font(.caption)

+                .foregroundStyle(.secondary)

+

+            if showsDeltaSummary {