-| 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, and Settings data maintenance have moved outside SwiftData. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; replace capture review actions and navigation handles before removing `ModelContainer` |

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

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

-- Current UI/cache layers still depend on 23 SwiftData-backed files for launch container, capture review actions, navigation handles, some charts, and PDF paths.

-  data maintenance now uses the rebuildable Core Data cache; SwiftData

-  snapshot/navigation handles remain.

-After moving local settings/data-maintenance flows out of SwiftData, 23 app

-files still have SwiftData imports.

-- `HealthProbe/Models/AnomalyRecord.swift`

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

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

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

-import Foundation

-import SwiftData

-

-@Model final class AnomalyRecord {

-    var id: UUID = UUID()

-    var detectedAt: Date = Date.now

-    var snapshotID: UUID = UUID()

-    var deltaID: UUID?

-    var deviceID: String = ""

-    var anomalyTypeRaw: String = "deletion"

-    var severityRaw: String = "info"

-    var typeIdentifier: String?

-    var message: String = ""

-    var isResolved: Bool = false

-

-    init(snapshotID: UUID, deviceID: String, anomalyType: AnomalyType, severity: Severity) {

-        self.id = UUID()

-        self.snapshotID = snapshotID

-        self.deviceID = deviceID

-        self.anomalyTypeRaw = anomalyType.rawValue

-        self.severityRaw = severity.rawValue

-    }

-}

-

-extension AnomalyRecord {

-    var anomalyType: AnomalyType {

-        get { AnomalyType(rawValue: anomalyTypeRaw) ?? .deletion }

-        set { anomalyTypeRaw = newValue.rawValue }

-    }

-    var severity: Severity {

-        get { Severity(rawValue: severityRaw) ?? .info }

-        set { severityRaw = newValue.rawValue }

-    }

-}

-import Foundation

-

-enum AnomalyType: String, Codable {

-    case historicalInsertion = "historical_insertion"

-    case deletion            = "deletion"

-    case duplication         = "duplication"

-    case silentReplacement   = "silent_replacement"

-    case syncAnomaly         = "sync_anomaly"

-}

-

-enum Severity: String, Codable, Comparable {

-    case info, warning, critical

-

-    private static let order: [Severity] = [.info, .warning, .critical]

-    static func < (lhs: Severity, rhs: Severity) -> Bool {

-        order.firstIndex(of: lhs)! < order.firstIndex(of: rhs)!

-    }

-}

-

-enum TypeTransition: String, Codable {

-    case unchanged    // type present in both, count and hash identical

-    case changed      // type present in both, count or hash differs

-    case appeared     // type missing in previous, present in current

-    case disappeared  // type present in previous, missing in current

-}

-

-enum TypeDeltaReason: String, Codable {

-    case normal               // expected delta, no external cause

-    case registryChanged      // monitoredTypeSetHash changed between snapshots

-    case authorizationChanged // type quality == .unauthorized

-    case unsupported          // type unavailable on this OS/device

-    case unknown

-}

-    var anomalyFlagsJSON: String = "[]"

-    var isPostRestoreSuppressedDeltaID: UUID?

-    var anomalyFlags: [String] {

-        get { (try? JSONDecoder().decode([String].self, from: Data(anomalyFlagsJSON.utf8))) ?? [] }

-        set { anomalyFlagsJSON = (try? String(data: JSONEncoder().encode(newValue), encoding: .utf8)) ?? "[]" }

-    }

-

-import Foundation

-

-enum AnomalyDetector {

-    struct DetectionResult {

-        var records: [AnomalyRecord]

-        var consumedPostRestoreSuppressionDeltaID: UUID? = nil

-    }

-

-    // AnomalyDetector is pure — must not mutate SwiftData models, must not call context.save().

-    // currentTypeCounts and previousTypeCounts are pre-built maps provided by the caller.

-    // detect() sets record.deltaID = delta.id on EVERY created AnomalyRecord internally —

-    // the caller must not set deltaID externally. All returned records have deltaID == delta.id.

-    static func detect(

-        delta: SnapshotDelta,

-        current: HealthSnapshot,

-        previous: HealthSnapshot,

-        currentTypeCounts: [String: TypeCount],

-        previousTypeCounts: [String: TypeCount]

-    ) -> DetectionResult {

-                // Quality gate: current snapshot must be complete.

-                // Previous may be partial due known unavailable metrics; per-type quality guards

-                // below still prevent analysis on impaired comparisons.

-                guard current.snapshotQuality == SnapshotQuality.complete else {

-            return DetectionResult(records: [])

-        }

-

-        var records: [AnomalyRecord] = []

-        var syncAnomalyCount = 0

-        var consumedDeltaID: UUID? = nil

-

-        let typeDeltas = delta.typeDeltas ?? []

-

-        for typeDelta in typeDeltas {

-            // Registry gate — suppress appeared/disappeared anomalies from non-normal reasons

-            guard typeDelta.reason == TypeDeltaReason.normal else { continue }

-

-            // count = -1 guard: skip any TypeDelta where either quality is not complete

-            let prevQuality = typeDelta.qualityBefore

-            let currQuality = typeDelta.qualityAfter

-            if prevQuality != nil && prevQuality != SnapshotQuality.complete { continue }

-            if currQuality != nil && currQuality != SnapshotQuality.complete { continue }

-

-            guard typeDelta.transition == .changed else { continue }

-

-            let typeID = typeDelta.typeIdentifier

-            let prevTC = previousTypeCounts[typeID]

-            let currTC = currentTypeCounts[typeID]

-            let countDelta = typeDelta.countDelta

-

-            // historicalInsertion

-            if countDelta > 0 {

-                let currEarliest = currTC?.earliestDate

-                let prevEarliest = prevTC?.earliestDate

-                let currLatest   = currTC?.latestDate

-                let prevLatest   = prevTC?.latestDate

-

-                let isHistorical: Bool

-                if let ce = currEarliest, let pe = prevEarliest {

-                    isHistorical = ce < pe

-                } else if let cl = currLatest, let pl = prevLatest {

-                    let dayDiff = abs(cl.timeIntervalSince(pl))

-                    isHistorical = dayDiff < 86_400 // within 1 day

-                } else {

-                    isHistorical = false

-                }

-

-                if isHistorical {

-                    let record = makeRecord(

-                        delta: delta,

-                        snapshotID: current.id,

-                        deviceID: current.deviceID,

-                        type: .historicalInsertion,

-                        severity: .warning,

-                        typeID: typeID,

-                        message: "Historical insertion detected for \(typeDelta.displayName): +\(countDelta) records"

-                    )

-                    records.append(record)

-                }

-            }

-

-            // deletion

-            if countDelta < 0 {

-                let prevCount = prevTC?.count ?? 0

-                let severity: Severity

-                if prevCount > 0 {

-                    let ratio = Double(abs(countDelta)) / Double(prevCount)

-                    severity = ratio >= 0.05 ? .critical : .warning

-                } else {

-                    severity = .warning

-                }

-                let record = makeRecord(

-                    delta: delta,

-                    snapshotID: current.id,

-                    deviceID: current.deviceID,

-                    type: .deletion,

-                    severity: severity,

-                    typeID: typeID,

-                    message: "Records disappeared for \(typeDelta.displayName): \(countDelta) records. Verify Health read authorization first; if access was intentionally revoked, confirm that decision. Otherwise, treat this as possible data deletion."

-                )

-                records.append(record)

-            }

-

-            // duplication

-            if countDelta > 0, let prevCount = prevTC?.count, prevCount > 0 {

-                let ratio = Double(countDelta) / Double(prevCount)

-                if ratio > 0.5 {

-                    let currEarliest = currTC?.earliestDate

-                    let prevEarliest = prevTC?.earliestDate

-                    let currLatest   = currTC?.latestDate

-                    let prevLatest   = prevTC?.latestDate

-

-                    let earliestClose = zip(currEarliest, prevEarliest)

-                        .map { abs($0.timeIntervalSince($1)) < 86_400 } ?? true

-                    let latestClose = zip(currLatest, prevLatest)

-                        .map { abs($0.timeIntervalSince($1)) < 86_400 } ?? true

-

-                    if earliestClose && latestClose {

-                        let record = makeRecord(

-                            delta: delta,

-                            snapshotID: current.id,

-                            deviceID: current.deviceID,

-                            type: .duplication,

-                            severity: .warning,

-                            typeID: typeID,

-                            message: "Duplication detected for \(typeDelta.displayName): +\(countDelta) records (\(Int(ratio * 100))% increase)"

-                        )

-                        records.append(record)

-                    }

-                }

-            }

-

-            // silentReplacement

-            if countDelta == 0 && typeDelta.hashBefore != typeDelta.hashAfter {

-                let record = makeRecord(

-                    delta: delta,

-                    snapshotID: current.id,

-                    deviceID: current.deviceID,

-                    type: .silentReplacement,

-                    severity: .info,

-                    typeID: typeID,

-                    message: "Silent replacement detected for \(typeDelta.displayName): count unchanged but hash differs"

-                )

-                records.append(record)

-            }

-

-            // Count types contributing to syncAnomaly

-            if abs(countDelta) > 0, let prevCount = prevTC?.count, prevCount > 0 {

-                let ratio = Double(abs(countDelta)) / Double(prevCount)

-                if ratio > 0.10 { syncAnomalyCount += 1 }

-            }

-        }

-

-        // syncAnomaly — ≥ 4 types simultaneously changed by >10%

-        if syncAnomalyCount >= 4 {

-            // isPostRestore suppression: suppress syncAnomaly if previous snapshot has the flag

-            // and the suppression token hasn't been consumed yet.

-            // Suppression is only consumed when current.snapshotQuality == .complete (enforced

-            // by the quality gate at the top — if we get here, both are complete).

-            if previous.isPostRestore && previous.isPostRestoreSuppressedDeltaID == nil {

-                // Suppression consumed — return the delta ID for the caller to persist

-                consumedDeltaID = delta.id

-                // Do not emit syncAnomaly

-            } else {

-                let record = makeRecord(

-                    delta: delta,

-                    snapshotID: current.id,

-                    deviceID: current.deviceID,

-                    type: .syncAnomaly,

-                    severity: .critical,

-                    typeID: nil,

-                    message: "Sync anomaly detected: \(syncAnomalyCount) types changed by >10% simultaneously"

-                )

-                records.append(record)

-            }

-        }

-

-        // Set anomalyFlags on current snapshot (non-persisted here — caller does context.save())

-        let flagValues = Set(records.map { $0.anomalyType.rawValue })

-        current.anomalyFlags = Array(flagValues)

-

-        return DetectionResult(

-            records: records,

-            consumedPostRestoreSuppressionDeltaID: consumedDeltaID

-        )

-    }

-

-    private static func makeRecord(

-        delta: SnapshotDelta,

-        snapshotID: UUID,

-        deviceID: String,

-        type anomalyType: AnomalyType,

-        severity: Severity,

-        typeID: String?,

-        message: String

-    ) -> AnomalyRecord {

-        let record = AnomalyRecord(

-            snapshotID: snapshotID,

-            deviceID: deviceID,

-            anomalyType: anomalyType,

-            severity: severity

-        )

-        record.deltaID = delta.id  // set structurally inside detect(), never by caller

-        record.typeIdentifier = typeID

-        record.message = message

-        return record

-    }

-}

-

-// Optional zip for two optionals (avoids force-unwrapping in comparisons)

-private func zip<A, B>(_ a: A?, _ b: B?) -> (A, B)? {

-    guard let a, let b else { return nil }

-    return (a, b)

-}

-        // Post-save pipeline: delta computation + anomaly detection

-        try await runPostSavePipeline(snapshot: snapshot, typeCounts: typeCounts, context: context)

-        typeCounts: [TypeCount],

-        guard let prevID = snapshot.previousSnapshotID else { return }

-

-        let prevDescriptor = FetchDescriptor<HealthSnapshot>(

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

-        )

-        guard let previous = try context.fetch(prevDescriptor).first else { return }

-

-        guard let delta = try DeltaService.computeAndSave(current: snapshot, context: context) else { return }

-

-        // Build type count maps for AnomalyDetector (never access relationship properties directly)

-        let currentTypeCounts = Dictionary(uniqueKeysWithValues: typeCounts.map { ($0.typeIdentifier, $0) })

-                var previousTypeCounts = Dictionary(

-            uniqueKeysWithValues: (previous.typeCounts ?? []).map { ($0.typeIdentifier, $0) }

-        )

-

-                for (typeID, currentType) in currentTypeCounts {

-                        guard currentType.quality == .complete,

-                                    currentType.count > 0,

-                                    let immediatePreviousType = previousTypeCounts[typeID],

-                                    immediatePreviousType.quality == .unauthorized,

-                                    let historicalBaseline = findLastCompleteValuedTypeCount(

-                                        typeID: typeID,

-                                        before: previous,

-                                        context: context

-                                    ) else {

-                                continue

-                        }

-

-                        previousTypeCounts[typeID] = historicalBaseline

-                }

-

-        let detection = AnomalyDetector.detect(

-            delta: delta,

-            current: snapshot,

-            previous: previous,

-            currentTypeCounts: currentTypeCounts,

-            previousTypeCounts: previousTypeCounts

-        )

-

-        for record in detection.records {

-            context.insert(record)

-        }

-        if let consumedDeltaID = detection.consumedPostRestoreSuppressionDeltaID {

-            previous.isPostRestoreSuppressedDeltaID = consumedDeltaID

-        }

-

-        if !detection.records.isEmpty || detection.consumedPostRestoreSuppressionDeltaID != nil {

-            try context.save()

-        }

-    private func findLastCompleteValuedTypeCount(

-        typeID: String,

-        before snapshot: HealthSnapshot,

-        context: ModelContext

-    ) -> TypeCount? {

-        var visited: Set<UUID> = []

-        var cursorID = snapshot.previousSnapshotID

-

-        while let snapshotID = cursorID, !visited.contains(snapshotID) {

-            visited.insert(snapshotID)

-

-            guard let historicalSnapshot = fetchSnapshot(id: snapshotID, context: context) else {

-                break

-            }

-

-            if let candidate = historicalSnapshot.typeCounts?.first(where: { $0.typeIdentifier == typeID }),

-               candidate.quality == .complete,

-               candidate.count > 0 {

-                return candidate

-            }

-

-            cursorID = historicalSnapshot.previousSnapshotID

-        }

-

-        return nil

-    }

-

-                anomalySummarySection

-    @ViewBuilder

-    private var anomalySummarySection: some View {

-        AnomalySummarySection()

-    }

-

-private struct AnomalySummarySection: View {

-    @Environment(\.modelContext) private var modelContext

-    @Query(filter: #Predicate<AnomalyRecord> { !$0.isResolved })

-    private var unresolved: [AnomalyRecord]

-

-    private var criticalCount: Int { unresolved.filter { $0.severityRaw == Severity.critical.rawValue }.count }

-    private var warningCount:  Int { unresolved.filter { $0.severityRaw == Severity.warning.rawValue }.count }

-    private var disappearedRecords: [AnomalyRecord] {

-        unresolved

-            .filter { $0.anomalyType == .deletion }

-            .sorted { $0.detectedAt > $1.detectedAt }

-    }

-

-    private func confirmAuthorizationChange(for anomaly: AnomalyRecord) {

-        defer {

-            anomaly.isResolved = true

-            try? modelContext.save()

-        }

-

-        guard let typeIdentifier = anomaly.typeIdentifier else { return }

-        let snapshotID = anomaly.snapshotID

-

-        let descriptor = FetchDescriptor<HealthSnapshot>(

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

-        )

-        guard let snapshot = try? modelContext.fetch(descriptor).first,

-              let typeCount = snapshot.typeCounts?.first(where: { $0.typeIdentifier == typeIdentifier }) else {

-            return

-        }

-

-        typeCount.count = -1

-        typeCount.contentHash = ""

-        typeCount.earliestDate = nil

-        typeCount.latestDate = nil

-        typeCount.quality = .unauthorized

-        typeCount.yearlyCounts?.removeAll()

-        snapshot.snapshotQuality = HealthKitService.shared.deriveSnapshotQuality(from: snapshot.typeCounts ?? [])

-    }

-

-    var body: some View {

-        if !unresolved.isEmpty {

-            Section("Change Review") {

-                if criticalCount > 0 {

-                    Label("\(criticalCount) critical \(criticalCount == 1 ? "change" : "changes")",

-                          systemImage: "exclamationmark.circle.fill")

-                        .foregroundStyle(Color.criticalRed)

-                }

-                if warningCount > 0 {

-                    Label("\(warningCount) \(warningCount == 1 ? "warning" : "warnings")",

-                          systemImage: "exclamationmark.triangle.fill")

-                        .foregroundStyle(Color.warningAmber)

-                }

-                if !disappearedRecords.isEmpty {

-                    VStack(alignment: .leading, spacing: 8) {

-                        Label("Records missing from current view", systemImage: "eye.slash")

-                            .font(.subheadline.weight(.semibold))

-                            .foregroundStyle(Color.criticalRed)

-                        Text("Check Health read access for the affected metrics first. If you intentionally revoked access, confirm that here; otherwise treat this as a change that needs external review.")

-                            .font(.caption)

-                            .foregroundStyle(.secondary)

-                        ForEach(disappearedRecords.prefix(3)) { anomaly in

-                            VStack(alignment: .leading, spacing: 6) {

-                                Text(anomaly.message)

-                                    .font(.caption)

-                                    .foregroundStyle(.secondary)

-                                Button("Confirm Authorization Change") {

-                                    confirmAuthorizationChange(for: anomaly)

-                                }

-                                .buttonStyle(.bordered)

-                                .controlSize(.small)

-                            }

-                        }

-                    }

-                    .padding(.vertical, 4)

-                }

-            }

-        }

-    }

-}

-

-                if let snapshot, !snapshot.anomalyFlags.isEmpty {

-                    Image(systemName: "exclamationmark.triangle.fill")

-                        .foregroundStyle(Color.warningAmber)

-                        .font(.caption)

-                        .accessibilityLabel("Has changes to review")

-                }