Move timeout profiles out of SwiftData · 3c1cfcb

Move timeout profiles out of SwiftData
Browse files

bogdan committed a week ago

main

1 parent a42b295

commit 3c1cfcb

Showing 10 changed files with 304 additions and 207 deletions

+2 -2

HealthProbe/Doc/04-project/IMPLEMENTATION_STATUS.md

@@ -27,7 +27,7 @@ There are no real deployments, only test installations. Existing prototype datab
 | 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 |
-| 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. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; replace Settings/local rows, capture review actions, and navigation handles before removing `ModelContainer` |
+| 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 has moved to a local Codable store outside `ModelContainer`. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; replace remaining Settings/local rows, capture review actions, and navigation handles before removing `ModelContainer` |
 | 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 |
@@ -49,7 +49,7 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
 - 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.
-- Current UI/cache layers still depend on 28 SwiftData-backed files for launch container, local Settings rows, capture review actions, navigation handles, some charts, and PDF paths.
+- Current UI/cache layers still depend on 27 SwiftData-backed files for launch container, remaining local Settings rows, capture review actions, navigation handles, some charts, and PDF paths.
 - 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.


+4 -1

HealthProbe/Doc/04-project/Refactoring-Plan.md

View

@@ -246,7 +246,10 @@ Acceptance:
 
 Checklist:
 - [x] Identify all remaining SwiftData imports.
-- [ ] Replace SwiftData models used by active flows.
+- [ ] Replace SwiftData models used by active flows. Metric timeout calibration
+  has been moved to a local Codable store and removed from `ModelContainer`;
+  `DeviceProfile`, `OperationLog`, and SwiftData snapshot/navigation handles
+  remain.
 - [ ] 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.


+16 -13

HealthProbe/Doc/04-project/SwiftData-Retirement-Inventory.md

View

@@ -9,7 +9,7 @@ local settings stored outside SwiftData where needed.
 
 ## Current Count
 
-After removing unused imports from pure legacy services, 28 app files still have
+After moving timeout calibration out of SwiftData, 27 app files still have
 SwiftData imports.
 
 ## Launch Container
@@ -20,8 +20,8 @@ These files keep SwiftData required at app launch:
 - `HealthProbe/ContentView.swift`
 
 Retirement path:
-- move local settings models (`DeviceProfile`, `MetricTimeoutProfile`,
-  `OperationLog`) to non-SwiftData storage or Core Data cache/local store;
+- move remaining local settings models (`DeviceProfile`, `OperationLog`) to
+  non-SwiftData storage or Core Data cache/local store;
 - replace prototype snapshot model dependencies in tab roots;
 - remove `.modelContainer(...)` once no active view needs `@Query` or
   `ModelContext`.
@@ -35,7 +35,6 @@ block:
 - `HealthProbe/Models/DeviceProfile.swift`
 - `HealthProbe/Models/HealthRecord.swift`
 - `HealthProbe/Models/HealthSnapshot.swift`
-- `HealthProbe/Models/MetricTimeoutProfile.swift`
 - `HealthProbe/Models/OperationLog.swift`
 - `HealthProbe/Models/SnapshotDelta.swift`
 - `HealthProbe/Models/TypeCount.swift`
@@ -48,8 +47,8 @@ Retirement path:
   `YearlyCount`, `TypeDistributionBin`, and `HealthRecord` active reads with
   archive/cache DTOs;
 - replace `AnomalyRecord` flows with neutral change/diff DTOs;
-- move `DeviceProfile`, `MetricTimeoutProfile`, and `OperationLog` to a local
-  non-SwiftData store before removing the launch container.
+- move `DeviceProfile` and `OperationLog` to a local non-SwiftData store before
+  removing the launch container.
 
 ## Capture And Maintenance Services
 
@@ -64,7 +63,7 @@ These services still write/read legacy SwiftData transition models:
 Retirement path:
 - make capture persist archive observations first and expose only bridge ids
   while transition UI still exists;
-- move timeout learning and operation logging out of SwiftData;
+- move operation logging out of SwiftData;
 - delete legacy record repair once old SwiftData stores are no longer opened;
 - remove snapshot deletion/repair logic after archive/cache navigation replaces
   prototype snapshots.
@@ -90,22 +89,26 @@ Retirement path:
   queries plus archive ids;
 - replace detail navigation parameters from SwiftData models to observation/type
   DTOs;
-- move Settings device profile and timeout profile rows to local non-SwiftData
-  storage;
+- move Settings device profile rows to local non-SwiftData storage;
 - keep paged record drill-down and export paths on archive APIs.
 
 ## Removed During This Pass
 
-The following files no longer import SwiftData because they only use already
-declared app model types and do not need SwiftData APIs directly:
+The following SwiftData dependencies were removed from active flows:
 
 - `HealthProbe/Services/AnomalyDetector.swift`
 - `HealthProbe/Services/IntegrityService.swift`
+- `HealthProbe/Models/MetricTimeoutProfile.swift` was deleted.
+- Metric timeout learning/calibration now uses
+  `HealthProbe/Utilities/LocalMetricTimeoutProfile.swift`, a Codable local
+  store outside `ModelContainer`.
+- `SettingsView`, `DashboardView`, and `HealthKitService` read/write timeout
+  calibration through the local store.
 
 ## Next Recommended Slices
 
-1. Replace Settings local rows (`DeviceProfile`, `MetricTimeoutProfile`) with a
-   small non-SwiftData local store so Settings no longer requires `@Query`.
+1. Replace Settings local rows (`DeviceProfile`) with a small non-SwiftData
+   local store so Settings no longer requires `@Query` for local configuration.
 2. Replace `ContentView` preview/container dependency after tab roots stop using
    `@Query`.
 3. Move `DashboardView` capture review actions away from `ModelContext`.


+2 -2

HealthProbe/HealthProbeApp.swift

View

@@ -33,7 +33,7 @@ struct HealthProbeApp: App {
         let fullSchema = Schema([
             HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,
             SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,
-            OperationLog.self, DeviceProfile.self, MetricTimeoutProfile.self,
+            OperationLog.self, DeviceProfile.self,
         ])
 
         let appSupportURL = URL.applicationSupportDirectory
@@ -44,7 +44,7 @@ struct HealthProbeApp: App {
             HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,
             SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,
         ])
-        let localModels = Schema([OperationLog.self, DeviceProfile.self, MetricTimeoutProfile.self])
+        let localModels = Schema([OperationLog.self, DeviceProfile.self])
 
         let uiCacheConfig = ModelConfiguration(
             "ui-cache",


+0 -140

HealthProbe/Models/MetricTimeoutProfile.swift

View

+                    -import Foundation
+                    -import SwiftData
+                    -@Model final class MetricTimeoutProfile {
+                    -    static let defaultInitialTimeout: TimeInterval = 15
+                    -    static let maximumTimeout: TimeInterval = 120
+                    -    private static let sampleLimit = 30
+                    -    private static let p95MinimumSampleCount = 5
+                    -    var id: UUID = UUID()
+                    -    var metricIdentifier: String = ""
+                    -    var displayName: String = ""
+                    -    var lastSuccessfulElapsed: TimeInterval = 0
+                    -    var averageSuccessfulElapsed: TimeInterval = 0
+                    -    var p95SuccessfulElapsed: TimeInterval = 0
+                    -    var lastTimeoutElapsed: TimeInterval = 0
+                    -    var timeoutCount: Int = 0
+                    -    var successCount: Int = 0
+                    -    var lastUpdatedAt: Date = Date.distantPast
+                    -    var currentTimeout: TimeInterval = MetricTimeoutProfile.defaultInitialTimeout
+                    -    var isManuallyOverridden: Bool = false
+                    -    var manualTimeoutValue: TimeInterval = MetricTimeoutProfile.defaultInitialTimeout
+                    -    var successfulElapsedSamplesJSON: String = "[]"
+                    -    init(metricIdentifier: String, displayName: String) {
+                    -        self.id = UUID()
+                    -        self.metricIdentifier = metricIdentifier
+                    -        self.displayName = displayName
+                    -        self.currentTimeout = Self.defaultInitialTimeout
+                    -        self.manualTimeoutValue = Self.defaultInitialTimeout
+                    -    }
+                    -}
+                    -extension MetricTimeoutProfile {
+                    -    var effectiveTimeout: TimeInterval {
+                    -        clamp(isManuallyOverridden ? manualTimeoutValue : currentTimeout)
+                    -    }
+                    -    var timeoutMode: String {
+                    -        if isManuallyOverridden { return "manual" }
+                    -        return successCount == 0 && timeoutCount == 0 ? "default" : "adaptive"
+                    -    }
+                    -    var hasP95: Bool {
+                    -        successSamples.count >= Self.p95MinimumSampleCount
+                    -    }
+                    -    var p95SuccessfulElapsedIfAvailable: TimeInterval? {
+                    -        hasP95 ? p95SuccessfulElapsed : nil
+                    -    }
+                    -    var suggestedRetryTimeout: TimeInterval {
+                    -        clamp(max(effectiveTimeout * 2, lastSuccessfulElapsed * 2, Self.defaultInitialTimeout))
+                    -    }
+                    -    func recordSuccess(elapsed: TimeInterval, displayName: String) {
+                    -        self.displayName = displayName
+                    -        lastSuccessfulElapsed = elapsed
+                    -        successCount += 1
+                    -        lastUpdatedAt = Date()
+                    -        var samples = successSamples
+                    -        samples.append(elapsed)
+                    -        if samples.count > Self.sampleLimit {
+                    -            samples.removeFirst(samples.count - Self.sampleLimit)
+                    -        }
+                    -        successSamples = samples
+                    -        averageSuccessfulElapsed = samples.reduce(0, +) / Double(samples.count)
+                    -        p95SuccessfulElapsed = Self.percentile95(samples)
+                    -        currentTimeout = automaticTimeout(from: samples)
+                    -    }
+                    -    func recordTimeout(elapsed: TimeInterval, displayName: String) {
+                    -        self.displayName = displayName
+                    -        lastTimeoutElapsed = elapsed
+                    -        timeoutCount += 1
+                    -        lastUpdatedAt = Date()
+                    -        guard !isManuallyOverridden else { return }
+                    -        let progressive = max(currentTimeout * 1.5, elapsed * 2, Self.defaultInitialTimeout)
+                    -        currentTimeout = clamp(progressive)
+                    -    }
+                    -    func resetLearning(displayName: String? = nil) {
+                    -        if let displayName { self.displayName = displayName }
+                    -        lastSuccessfulElapsed = 0
+                    -        averageSuccessfulElapsed = 0
+                    -        p95SuccessfulElapsed = 0
+                    -        lastTimeoutElapsed = 0
+                    -        timeoutCount = 0
+                    -        successCount = 0
+                    -        lastUpdatedAt = Date()
+                    -        currentTimeout = Self.defaultInitialTimeout
+                    -        isManuallyOverridden = false
+                    -        manualTimeoutValue = Self.defaultInitialTimeout
+                    -        successfulElapsedSamplesJSON = "[]"
+                    -    }
+                    -    func setManualTimeout(_ value: TimeInterval) {
+                    -        manualTimeoutValue = clamp(value)
+                    -        isManuallyOverridden = true
+                    -        lastUpdatedAt = Date()
+                    -    }
+                    -    func returnToAutomatic() {
+                    -        isManuallyOverridden = false
+                    -        lastUpdatedAt = Date()
+                    -    }
+                    -    private var successSamples: [TimeInterval] {
+                    -        get {
+                    -            guard let data = successfulElapsedSamplesJSON.data(using: .utf8),
+                    -                  let values = try? JSONDecoder().decode([TimeInterval].self, from: data) else {
+                    -                return []
+                    -            }
+                    -            return values
+                    -        }
+                    -        set {
+                    -            successfulElapsedSamplesJSON = (try? String(data: JSONEncoder().encode(newValue), encoding: .utf8)) ?? "[]"
+                    -        }
+                    -    }
+                    -    private func automaticTimeout(from samples: [TimeInterval]) -> TimeInterval {
+                    -        let basis = samples.count >= Self.p95MinimumSampleCount ? Self.percentile95(samples) : samples.max() ?? 0
+                    -        return clamp(max(Self.defaultInitialTimeout, basis * 2, currentTimeout * 0.9))
+                    -    }
+                    -    private func clamp(_ value: TimeInterval) -> TimeInterval {
+                    -        min(max(value, Self.defaultInitialTimeout), Self.maximumTimeout)
+                    -    }
+                    -    private static func percentile95(_ samples: [TimeInterval]) -> TimeInterval {
+                    -        guard !samples.isEmpty else { return 0 }
+                    -        let sorted = samples.sorted()
+                    -        let rawIndex = Int(ceil(Double(sorted.count) * 0.95)) - 1
+                    -        let index = min(max(rawIndex, 0), sorted.count - 1)
+                    -        return sorted[index]
+                    -    }
+                    -}

+12 -23

HealthProbe/Services/HealthKitService.swift

View

@@ -46,8 +46,8 @@ final class HealthKitService {
 
     static let allTypes: [MonitoredType] = buildAllTypes()
 
-    static let defaultInitialTimeoutSeconds: TimeInterval = MetricTimeoutProfile.defaultInitialTimeout
-    static let maximumTimeoutSeconds: TimeInterval = MetricTimeoutProfile.maximumTimeout
+    static let defaultInitialTimeoutSeconds: TimeInterval = LocalMetricTimeoutProfile.defaultInitialTimeout
+    static let maximumTimeoutSeconds: TimeInterval = LocalMetricTimeoutProfile.maximumTimeout
     static let fullHistoryImportTimeoutSeconds: TimeInterval = 30 * 60
     // Prevents 3N simultaneous HK queries from exhausting resources at N=20 types.
     static let maxConcurrentTypeFetches = 6
@@ -611,7 +611,7 @@ final class HealthKitService {
         typeCounts.reserveCapacity(active.count)
 
         for monitoredType in active {
-            let profile = timeoutProfile(for: monitoredType, context: context)
+            var profile = timeoutProfile(for: monitoredType)
             let timeout = timeoutForFetch(
                 profile: profile,
                 adaptiveTimeoutsEnabled: adaptiveTimeoutsEnabled,
@@ -625,7 +625,8 @@ final class HealthKitService {
                 archiveObservationID: archiveObservationID,
                 progress: progress
             )
-            updateTimeoutProfile(profile, with: result, monitoredType: monitoredType)
+            updateTimeoutProfile(&profile, with: result, monitoredType: monitoredType)
+            LocalMetricTimeoutProfileStore.save(profile)
             result.applyTimeoutProfile(profile)
             progress?.updateTimeoutProfile(from: profile, for: monitoredType.id)
             let typeCount = result.makeTypeCount()
@@ -637,7 +638,7 @@ final class HealthKitService {
 
     private func fetchTypeCountData(
         for monitoredType: MonitoredType,
-        timeoutProfile: MetricTimeoutProfile,
+        timeoutProfile: LocalMetricTimeoutProfile,
         timeoutSeconds: TimeInterval,
         previousTypeCount: TypeCount?,
         archiveObservationID: Int64,
@@ -1475,24 +1476,12 @@ final class HealthKitService {
 
     // MARK: - Timeout profiles
 
-    private func timeoutProfile(for monitoredType: MonitoredType, context: ModelContext) -> MetricTimeoutProfile {
-        let identifier = monitoredType.id
-        var descriptor = FetchDescriptor<MetricTimeoutProfile>(
-            predicate: #Predicate<MetricTimeoutProfile> { $0.metricIdentifier == identifier }
-        )
-        descriptor.fetchLimit = 1
-        if let existing = try? context.fetch(descriptor).first {
-            existing.displayName = monitoredType.displayName
-            return existing
-        }
-
-        let profile = MetricTimeoutProfile(metricIdentifier: monitoredType.id, displayName: monitoredType.displayName)
-        context.insert(profile)
-        return profile
+    private func timeoutProfile(for monitoredType: MonitoredType) -> LocalMetricTimeoutProfile {
+        LocalMetricTimeoutProfileStore.profile(for: monitoredType)
     }
 
     private func timeoutForFetch(
-        profile: MetricTimeoutProfile,
+        profile: LocalMetricTimeoutProfile,
         adaptiveTimeoutsEnabled: Bool,
         timeoutMultiplier: Double
     ) -> TimeInterval {
@@ -1501,7 +1490,7 @@ final class HealthKitService {
     }
 
     private func updateTimeoutProfile(
-        _ profile: MetricTimeoutProfile,
+        _ profile: inout LocalMetricTimeoutProfile,
         with result: TypeCountFetchResult,
         monitoredType: MonitoredType
     ) {
@@ -2083,7 +2072,7 @@ private struct TypeCountFetchResult: Sendable {
     var timeoutCount: Int = 0
     var successCount: Int = 0
 
-    mutating func applyTimeoutProfile(_ profile: MetricTimeoutProfile) {
+    mutating func applyTimeoutProfile(_ profile: LocalMetricTimeoutProfile) {
         timeoutMode = profile.timeoutMode
         lastSuccessfulElapsed = profile.lastSuccessfulElapsed
         learnedTimeout = profile.effectiveTimeout
@@ -2175,7 +2164,7 @@ private extension SnapshotFetchProgress {
         )
     }
 
-    func updateTimeoutProfile(from profile: MetricTimeoutProfile, for typeID: String) {
+    func updateTimeoutProfile(from profile: LocalMetricTimeoutProfile, for typeID: String) {
         updateTimeoutProfile(
             typeID,
             timeoutMode: profile.timeoutMode,


+169 -0

HealthProbe/Utilities/LocalMetricTimeoutProfile.swift

View

+                    +import Foundation
+                    +struct LocalMetricTimeoutProfile: Codable, Equatable, Identifiable, Sendable {
+                    +    static let defaultInitialTimeout: TimeInterval = 15
+                    +    static let maximumTimeout: TimeInterval = 120
+                    +    private static let sampleLimit = 30
+                    +    private static let p95MinimumSampleCount = 5
+                    +    var id: String { metricIdentifier }
+                    +    var metricIdentifier: String
+                    +    var displayName: String
+                    +    var lastSuccessfulElapsed: TimeInterval = 0
+                    +    var averageSuccessfulElapsed: TimeInterval = 0
+                    +    var p95SuccessfulElapsed: TimeInterval = 0
+                    +    var lastTimeoutElapsed: TimeInterval = 0
+                    +    var timeoutCount: Int = 0
+                    +    var successCount: Int = 0
+                    +    var lastUpdatedAt: Date = Date.distantPast
+                    +    var currentTimeout: TimeInterval = LocalMetricTimeoutProfile.defaultInitialTimeout
+                    +    var isManuallyOverridden: Bool = false
+                    +    var manualTimeoutValue: TimeInterval = LocalMetricTimeoutProfile.defaultInitialTimeout
+                    +    var successfulElapsedSamples: [TimeInterval] = []
+                    +    init(metricIdentifier: String, displayName: String) {
+                    +        self.metricIdentifier = metricIdentifier
+                    +        self.displayName = displayName
+                    +    }
+                    +    var effectiveTimeout: TimeInterval {
+                    +        clamp(isManuallyOverridden ? manualTimeoutValue : currentTimeout)
+                    +    }
+                    +    var timeoutMode: String {
+                    +        if isManuallyOverridden { return "manual" }
+                    +        return successCount == 0 && timeoutCount == 0 ? "default" : "adaptive"
+                    +    }
+                    +    var p95SuccessfulElapsedIfAvailable: TimeInterval? {
+                    +        successfulElapsedSamples.count >= Self.p95MinimumSampleCount ? p95SuccessfulElapsed : nil
+                    +    }
+                    +    var suggestedRetryTimeout: TimeInterval {
+                    +        clamp(max(effectiveTimeout * 2, lastSuccessfulElapsed * 2, Self.defaultInitialTimeout))
+                    +    }
+                    +    mutating func recordSuccess(elapsed: TimeInterval, displayName: String) {
+                    +        self.displayName = displayName
+                    +        lastSuccessfulElapsed = elapsed
+                    +        successCount += 1
+                    +        lastUpdatedAt = Date()
+                    +        successfulElapsedSamples.append(elapsed)
+                    +        if successfulElapsedSamples.count > Self.sampleLimit {
+                    +            successfulElapsedSamples.removeFirst(successfulElapsedSamples.count - Self.sampleLimit)
+                    +        }
+                    +        averageSuccessfulElapsed = successfulElapsedSamples.reduce(0, +) / Double(successfulElapsedSamples.count)
+                    +        p95SuccessfulElapsed = Self.percentile95(successfulElapsedSamples)
+                    +        currentTimeout = automaticTimeout(from: successfulElapsedSamples)
+                    +    }
+                    +    mutating func recordTimeout(elapsed: TimeInterval, displayName: String) {
+                    +        self.displayName = displayName
+                    +        lastTimeoutElapsed = elapsed
+                    +        timeoutCount += 1
+                    +        lastUpdatedAt = Date()
+                    +        guard !isManuallyOverridden else { return }
+                    +        let progressive = max(currentTimeout * 1.5, elapsed * 2, Self.defaultInitialTimeout)
+                    +        currentTimeout = clamp(progressive)
+                    +    }
+                    +    mutating func resetLearning(displayName: String? = nil) {
+                    +        if let displayName { self.displayName = displayName }
+                    +        lastSuccessfulElapsed = 0
+                    +        averageSuccessfulElapsed = 0
+                    +        p95SuccessfulElapsed = 0
+                    +        lastTimeoutElapsed = 0
+                    +        timeoutCount = 0
+                    +        successCount = 0
+                    +        lastUpdatedAt = Date()
+                    +        currentTimeout = Self.defaultInitialTimeout
+                    +        isManuallyOverridden = false
+                    +        manualTimeoutValue = Self.defaultInitialTimeout
+                    +        successfulElapsedSamples = []
+                    +    }
+                    +    mutating func setManualTimeout(_ value: TimeInterval) {
+                    +        manualTimeoutValue = clamp(value)
+                    +        isManuallyOverridden = true
+                    +        lastUpdatedAt = Date()
+                    +    }
+                    +    mutating func returnToAutomatic() {
+                    +        isManuallyOverridden = false
+                    +        lastUpdatedAt = Date()
+                    +    }
+                    +    private func automaticTimeout(from samples: [TimeInterval]) -> TimeInterval {
+                    +        let basis = samples.count >= Self.p95MinimumSampleCount ? Self.percentile95(samples) : samples.max() ?? 0
+                    +        return clamp(max(Self.defaultInitialTimeout, basis * 2, currentTimeout * 0.9))
+                    +    }
+                    +    private func clamp(_ value: TimeInterval) -> TimeInterval {
+                    +        min(max(value, Self.defaultInitialTimeout), Self.maximumTimeout)
+                    +    }
+                    +    private static func percentile95(_ samples: [TimeInterval]) -> TimeInterval {
+                    +        guard !samples.isEmpty else { return 0 }
+                    +        let sorted = samples.sorted()
+                    +        let rawIndex = Int(ceil(Double(sorted.count) * 0.95)) - 1
+                    +        let index = min(max(rawIndex, 0), sorted.count - 1)
+                    +        return sorted[index]
+                    +    }
+                    +}
+                    +enum LocalMetricTimeoutProfileStore {
+                    +    private static let key = "hp_localMetricTimeoutProfiles"
+                    +    static func allProfiles(for monitoredTypes: [MonitoredType] = HealthKitService.allTypes) -> [LocalMetricTimeoutProfile] {
+                    +        let existing = Dictionary(uniqueKeysWithValues: load().map { ($0.metricIdentifier, $0) })
+                    +        return monitoredTypes.map { type in
+                    +            var profile = existing[type.id] ?? LocalMetricTimeoutProfile(metricIdentifier: type.id, displayName: type.displayName)
+                    +            profile.displayName = type.displayName
+                    +            return profile
+                    +        }
+                    +        .sorted { $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending }
+                    +    }
+                    +    static func profile(for monitoredType: MonitoredType) -> LocalMetricTimeoutProfile {
+                    +        allProfiles(for: [monitoredType]).first ?? LocalMetricTimeoutProfile(
+                    +            metricIdentifier: monitoredType.id,
+                    +            displayName: monitoredType.displayName
+                    +        )
+                    +    }
+                    +    static func save(_ profile: LocalMetricTimeoutProfile) {
+                    +        var profiles = load()
+                    +        if let index = profiles.firstIndex(where: { $0.metricIdentifier == profile.metricIdentifier }) {
+                    +            profiles[index] = profile
+                    +        } else {
+                    +            profiles.append(profile)
+                    +        }
+                    +        save(profiles)
+                    +    }
+                    +    static func resetAll(monitoredTypes: [MonitoredType] = HealthKitService.allTypes) {
+                    +        let profiles = monitoredTypes.map { type in
+                    +            LocalMetricTimeoutProfile(metricIdentifier: type.id, displayName: type.displayName)
+                    +        }
+                    +        save(profiles)
+                    +    }
+                    +    static func removeAll() {
+                    +        UserDefaults.standard.removeObject(forKey: key)
+                    +    }
+                    +    private static func load() -> [LocalMetricTimeoutProfile] {
+                    +        guard let data = UserDefaults.standard.data(forKey: key) else { return [] }
+                    +        return (try? JSONDecoder().decode([LocalMetricTimeoutProfile].self, from: data)) ?? []
+                    +    }
+                    +    private static func save(_ profiles: [LocalMetricTimeoutProfile]) {
+                    +        let sorted = profiles.sorted {
+                    +            $0.displayName.localizedCaseInsensitiveCompare($1.displayName) == .orderedAscending
+                    +        }
+                    +        UserDefaults.standard.set(try? JSONEncoder().encode(sorted), forKey: key)
+                    +    }
+                    +}

+3 -3

HealthProbe/Views/Dashboard/DashboardView.swift

View

@@ -373,8 +373,8 @@ struct DashboardView: View {
         lines.append("")
         lines.append("CONFIGURATION")
         lines.append("adaptiveTimeoutsEnabled: \(progress.adaptiveTimeoutsEnabled ? "true" : "false")")
-        lines.append("defaultInitialTimeout:   \(formatDuration(MetricTimeoutProfile.defaultInitialTimeout))")
-        lines.append("maximumTimeout:          \(formatDuration(MetricTimeoutProfile.maximumTimeout))")
+        lines.append("defaultInitialTimeout:   \(formatDuration(LocalMetricTimeoutProfile.defaultInitialTimeout))")
+        lines.append("maximumTimeout:          \(formatDuration(LocalMetricTimeoutProfile.maximumTimeout))")
         lines.append("maxConcurrentTypeFetches: \(progress.maxConcurrentTypeFetches)")
         lines.append("")
         lines.append("CHAIN/INTEGRITY CONTEXT")
@@ -732,7 +732,7 @@ struct DashboardView: View {
                                         Text("Observed needed: ~\(formatDuration(type.learnedTimeout))")
                                             .font(.caption).foregroundStyle(.secondary)
                                     }
-                                    Text("Suggested retry: \(type.suggestedRetryTimeout > 0 ? formatDuration(type.suggestedRetryTimeout) : formatDuration(MetricTimeoutProfile.maximumTimeout))")
+                                    Text("Suggested retry: \(type.suggestedRetryTimeout > 0 ? formatDuration(type.suggestedRetryTimeout) : formatDuration(LocalMetricTimeoutProfile.maximumTimeout))")
                                         .font(.caption).foregroundStyle(.secondary)
                                 }
                             }


+57 -23

HealthProbe/Views/Settings/SettingsView.swift

View

@@ -8,11 +8,11 @@ struct SettingsView: View {
     @Environment(AppSettings.self) private var appSettings
     @Query private var snapshots: [HealthSnapshot]
     @Query private var deviceProfiles: [DeviceProfile]
-    @Query(sort: \MetricTimeoutProfile.displayName) private var timeoutProfiles: [MetricTimeoutProfile]
     @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
@@ -36,7 +36,7 @@ struct SettingsView: View {
             .navigationTitle("Settings")
             .onAppear {
                 ensureCurrentDeviceProfile()
-                ensureTimeoutProfiles()
+                loadTimeoutProfiles()
             }
             .confirmationDialog(
                 "Delete All Audit Data",
@@ -139,17 +139,23 @@ struct SettingsView: View {
             ))
 
             InfoRow(label: "Default Initial Timeout") {
-                Text(formatDuration(MetricTimeoutProfile.defaultInitialTimeout))
+                Text(formatDuration(LocalMetricTimeoutProfile.defaultInitialTimeout))
                     .foregroundStyle(.secondary)
             }
 
             InfoRow(label: "Maximum Timeout") {
-                Text(formatDuration(MetricTimeoutProfile.maximumTimeout))
+                Text(formatDuration(LocalMetricTimeoutProfile.maximumTimeout))
                     .foregroundStyle(.secondary)
             }
 
             ForEach(timeoutProfiles) { profile in
-                TimeoutProfileRow(profile: profile)
+                TimeoutProfileRow(
+                    profile: profile,
+                    onManualTimeoutChanged: { setManualTimeout(profile.metricIdentifier, value: $0) },
+                    onSetManual: { setManualTimeout(profile.metricIdentifier, value: profile.effectiveTimeout) },
+                    onAutomatic: { returnTimeoutProfileToAutomatic(profile.metricIdentifier) },
+                    onReset: { resetTimeoutProfile(profile.metricIdentifier) }
+                )
             }
 
             Button(role: .destructive) {
@@ -220,19 +226,43 @@ struct SettingsView: View {
         try? modelContext.save()
     }
 
-    private func ensureTimeoutProfiles() {
-        let existingIDs = Set(timeoutProfiles.map(\.metricIdentifier))
-        for type in HealthKitService.allTypes where !existingIDs.contains(type.id) {
-            modelContext.insert(MetricTimeoutProfile(metricIdentifier: type.id, displayName: type.displayName))
-        }
-        try? modelContext.save()
+    private func loadTimeoutProfiles() {
+        timeoutProfiles = LocalMetricTimeoutProfileStore.allProfiles()
     }
 
     private func resetAllTimeoutProfiles() {
-        for profile in timeoutProfiles {
+        LocalMetricTimeoutProfileStore.resetAll()
+        loadTimeoutProfiles()
+    }
+
+    private func setManualTimeout(_ metricIdentifier: String, value: TimeInterval) {
+        updateTimeoutProfile(metricIdentifier) { profile in
+            profile.setManualTimeout(value)
+        }
+    }
+
+    private func returnTimeoutProfileToAutomatic(_ metricIdentifier: String) {
+        updateTimeoutProfile(metricIdentifier) { profile in
+            profile.returnToAutomatic()
+        }
+    }
+
+    private func resetTimeoutProfile(_ metricIdentifier: String) {
+        updateTimeoutProfile(metricIdentifier) { profile in
             profile.resetLearning()
         }
-        try? modelContext.save()
+    }
+
+    private func updateTimeoutProfile(
+        _ metricIdentifier: String,
+        mutate: (inout LocalMetricTimeoutProfile) -> Void
+    ) {
+        guard let index = timeoutProfiles.firstIndex(where: { $0.metricIdentifier == metricIdentifier }) else {
+            return
+        }
+        mutate(&timeoutProfiles[index])
+        LocalMetricTimeoutProfileStore.save(timeoutProfiles[index])
+        loadTimeoutProfiles()
     }
 
     private func deleteAllData() {
@@ -278,7 +308,11 @@ private struct TypeToggleRow: View {
 }
 
 private struct TimeoutProfileRow: View {
-    @Bindable var profile: MetricTimeoutProfile
+    let profile: LocalMetricTimeoutProfile
+    let onManualTimeoutChanged: (TimeInterval) -> Void
+    let onSetManual: () -> Void
+    let onAutomatic: () -> Void
+    let onReset: () -> Void
 
     var body: some View {
         VStack(alignment: .leading, spacing: 8) {
@@ -327,24 +361,24 @@ private struct TimeoutProfileRow: View {
             if profile.isManuallyOverridden {
                 Stepper(
                     "Manual \(formatDuration(profile.manualTimeoutValue))",
-                    value: $profile.manualTimeoutValue,
-                    in: MetricTimeoutProfile.defaultInitialTimeout...MetricTimeoutProfile.maximumTimeout,
+                    value: Binding(
+                        get: { profile.manualTimeoutValue },
+                        set: onManualTimeoutChanged
+                    ),
+                    in: LocalMetricTimeoutProfile.defaultInitialTimeout...LocalMetricTimeoutProfile.maximumTimeout,
                     step: 5
                 )
                 .font(.caption)
-                .onChange(of: profile.manualTimeoutValue) { _, newValue in
-                    profile.setManualTimeout(newValue)
-                }
             }
 
             HStack {
                 Button("Set Manual") {
-                    profile.setManualTimeout(profile.effectiveTimeout)
+                    onSetManual()
                 }
                 .buttonStyle(.borderless)
 
                 Button("Automatic") {
-                    profile.returnToAutomatic()
+                    onAutomatic()
                 }
                 .buttonStyle(.borderless)
                 .disabled(!profile.isManuallyOverridden)
@@ -352,7 +386,7 @@ private struct TimeoutProfileRow: View {
                 Spacer()
 
                 Button("Reset", role: .destructive) {
-                    profile.resetLearning()
+                    onReset()
                 }
                 .buttonStyle(.borderless)
             }
@@ -386,6 +420,6 @@ private func formatDuration(_ seconds: TimeInterval) -> String {
 
 #Preview {
     SettingsView()
-        .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self, MetricTimeoutProfile.self], inMemory: true)
+        .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
         .environment(AppSettings())
 }


+39 -0

HealthProbeTests/LocalMetricTimeoutProfileTests.swift

View

+                    +import XCTest
+                    +@testable import HealthProbe
+                    +final class LocalMetricTimeoutProfileTests: XCTestCase {
+                    +    override func tearDown() {
+                    +        LocalMetricTimeoutProfileStore.removeAll()
+                    +        super.tearDown()
+                    +    }
+                    +    func testRecordsSuccessAndPersistsProfile() {
+                    +        var profile = LocalMetricTimeoutProfile(metricIdentifier: "step_count", displayName: "Step Count")
+                    +        profile.recordSuccess(elapsed: 12, displayName: "Step Count")
+                    +        LocalMetricTimeoutProfileStore.save(profile)
+                    +        let loaded = LocalMetricTimeoutProfileStore.profile(for: MonitoredType(
+                    +            id: "step_count",
+                    +            displayName: "Step Count",
+                    +            category: .activity,
+                    +            isEnabledByDefault: true,
+                    +            objectType: nil
+                    +        ))
+                    +        XCTAssertEqual(loaded.successCount, 1)
+                    +        XCTAssertEqual(loaded.lastSuccessfulElapsed, 12)
+                    +        XCTAssertEqual(loaded.timeoutMode, "adaptive")
+                    +    }
+                    +    func testManualTimeoutIsClampedAndResettable() {
+                    +        var profile = LocalMetricTimeoutProfile(metricIdentifier: "heart_rate", displayName: "Heart Rate")
+                    +        profile.setManualTimeout(1_000)
+                    +        XCTAssertEqual(profile.effectiveTimeout, LocalMetricTimeoutProfile.maximumTimeout)
+                    +        XCTAssertEqual(profile.timeoutMode, "manual")
+                    +        profile.resetLearning()
+                    +        XCTAssertEqual(profile.effectiveTimeout, LocalMetricTimeoutProfile.defaultInitialTimeout)
+                    +        XCTAssertEqual(profile.timeoutMode, "default")
+                    +    }
+                    +}

	@@ -246,7 +246,10 @@ Acceptance:
246	246
247	247	Checklist:
248	248	- [x] Identify all remaining SwiftData imports.
249		-- [ ] Replace SwiftData models used by active flows.
	249	+- [ ] Replace SwiftData models used by active flows. Metric timeout calibration
	250	+ has been moved to a local Codable store and removed from `ModelContainer`;
	251	+ `DeviceProfile`, `OperationLog`, and SwiftData snapshot/navigation handles
	252	+ remain.
250	253	- [ ] Remove/disable `ModelContainer` as required for target builds.
251	254	- [x] Add prototype-store ignore/delete/reset path for test installs.
252	255	- [ ] Verify no old-store compatibility layer remains in active flows.

	@@ -46,8 +46,8 @@ final class HealthKitService {
46	46
47	47	static let allTypes: [MonitoredType] = buildAllTypes()
48	48
49		- static let defaultInitialTimeoutSeconds: TimeInterval = MetricTimeoutProfile.defaultInitialTimeout
50		- static let maximumTimeoutSeconds: TimeInterval = MetricTimeoutProfile.maximumTimeout
	49	+ static let defaultInitialTimeoutSeconds: TimeInterval = LocalMetricTimeoutProfile.defaultInitialTimeout
	50	+ static let maximumTimeoutSeconds: TimeInterval = LocalMetricTimeoutProfile.maximumTimeout
51	51	static let fullHistoryImportTimeoutSeconds: TimeInterval = 30 * 60
52	52	// Prevents 3N simultaneous HK queries from exhausting resources at N=20 types.
53	53	static let maxConcurrentTypeFetches = 6
	@@ -611,7 +611,7 @@ final class HealthKitService {
611	611	typeCounts.reserveCapacity(active.count)
612	612
613	613	for monitoredType in active {
614		- let profile = timeoutProfile(for: monitoredType, context: context)
	614	+ var profile = timeoutProfile(for: monitoredType)
615	615	let timeout = timeoutForFetch(
616	616	profile: profile,
617	617	adaptiveTimeoutsEnabled: adaptiveTimeoutsEnabled,
	@@ -625,7 +625,8 @@ final class HealthKitService {
625	625	archiveObservationID: archiveObservationID,
626	626	progress: progress
627	627	)
628		- updateTimeoutProfile(profile, with: result, monitoredType: monitoredType)
	628	+ updateTimeoutProfile(&profile, with: result, monitoredType: monitoredType)
	629	+ LocalMetricTimeoutProfileStore.save(profile)
629	630	result.applyTimeoutProfile(profile)
630	631	progress?.updateTimeoutProfile(from: profile, for: monitoredType.id)
631	632	let typeCount = result.makeTypeCount()
	@@ -637,7 +638,7 @@ final class HealthKitService {
637	638
638	639	private func fetchTypeCountData(
639	640	for monitoredType: MonitoredType,
640		- timeoutProfile: MetricTimeoutProfile,
	641	+ timeoutProfile: LocalMetricTimeoutProfile,
641	642	timeoutSeconds: TimeInterval,
642	643	previousTypeCount: TypeCount?,
643	644	archiveObservationID: Int64,
	@@ -1475,24 +1476,12 @@ final class HealthKitService {
1475	1476
1476	1477	// MARK: - Timeout profiles
1477	1478
1478		- private func timeoutProfile(for monitoredType: MonitoredType, context: ModelContext) -> MetricTimeoutProfile {
1479		- let identifier = monitoredType.id
1480		- var descriptor = FetchDescriptor<MetricTimeoutProfile>(
1481		- predicate: #Predicate<MetricTimeoutProfile> { $0.metricIdentifier == identifier }
1482		- )
1483		- descriptor.fetchLimit = 1
1484		- if let existing = try? context.fetch(descriptor).first {
1485		- existing.displayName = monitoredType.displayName
1486		- return existing
1487		- }
1488		-
1489		- let profile = MetricTimeoutProfile(metricIdentifier: monitoredType.id, displayName: monitoredType.displayName)
1490		- context.insert(profile)
1491		- return profile
	1479	+ private func timeoutProfile(for monitoredType: MonitoredType) -> LocalMetricTimeoutProfile {
	1480	+ LocalMetricTimeoutProfileStore.profile(for: monitoredType)
1492	1481	}
1493	1482
1494	1483	private func timeoutForFetch(
1495		- profile: MetricTimeoutProfile,
	1484	+ profile: LocalMetricTimeoutProfile,
1496	1485	adaptiveTimeoutsEnabled: Bool,
1497	1486	timeoutMultiplier: Double
1498	1487	) -> TimeInterval {
	@@ -1501,7 +1490,7 @@ final class HealthKitService {
1501	1490	}
1502	1491
1503	1492	private func updateTimeoutProfile(
1504		- _ profile: MetricTimeoutProfile,
	1493	+ _ profile: inout LocalMetricTimeoutProfile,
1505	1494	with result: TypeCountFetchResult,
1506	1495	monitoredType: MonitoredType
1507	1496	) {
	@@ -2083,7 +2072,7 @@ private struct TypeCountFetchResult: Sendable {
2083	2072	var timeoutCount: Int = 0
2084	2073	var successCount: Int = 0
2085	2074
2086		- mutating func applyTimeoutProfile(_ profile: MetricTimeoutProfile) {
	2075	+ mutating func applyTimeoutProfile(_ profile: LocalMetricTimeoutProfile) {
2087	2076	timeoutMode = profile.timeoutMode
2088	2077	lastSuccessfulElapsed = profile.lastSuccessfulElapsed
2089	2078	learnedTimeout = profile.effectiveTimeout
	@@ -2175,7 +2164,7 @@ private extension SnapshotFetchProgress {
2175	2164	)
2176	2165	}
2177	2166
2178		- func updateTimeoutProfile(from profile: MetricTimeoutProfile, for typeID: String) {
	2167	+ func updateTimeoutProfile(from profile: LocalMetricTimeoutProfile, for typeID: String) {
2179	2168	updateTimeoutProfile(
2180	2169	typeID,
2181	2170	timeoutMode: profile.timeoutMode,

	@@ -373,8 +373,8 @@ struct DashboardView: View {
373	373	lines.append("")
374	374	lines.append("CONFIGURATION")
375	375	lines.append("adaptiveTimeoutsEnabled: \(progress.adaptiveTimeoutsEnabled ? "true" : "false")")
376		- lines.append("defaultInitialTimeout: \(formatDuration(MetricTimeoutProfile.defaultInitialTimeout))")
377		- lines.append("maximumTimeout: \(formatDuration(MetricTimeoutProfile.maximumTimeout))")
	376	+ lines.append("defaultInitialTimeout: \(formatDuration(LocalMetricTimeoutProfile.defaultInitialTimeout))")
	377	+ lines.append("maximumTimeout: \(formatDuration(LocalMetricTimeoutProfile.maximumTimeout))")
378	378	lines.append("maxConcurrentTypeFetches: \(progress.maxConcurrentTypeFetches)")
379	379	lines.append("")
380	380	lines.append("CHAIN/INTEGRITY CONTEXT")
	@@ -732,7 +732,7 @@ struct DashboardView: View {
732	732	Text("Observed needed: ~\(formatDuration(type.learnedTimeout))")
733	733	.font(.caption).foregroundStyle(.secondary)
734	734	}
735		- Text("Suggested retry: \(type.suggestedRetryTimeout > 0 ? formatDuration(type.suggestedRetryTimeout) : formatDuration(MetricTimeoutProfile.maximumTimeout))")
	735	+ Text("Suggested retry: \(type.suggestedRetryTimeout > 0 ? formatDuration(type.suggestedRetryTimeout) : formatDuration(LocalMetricTimeoutProfile.maximumTimeout))")
736	736	.font(.caption).foregroundStyle(.secondary)
737	737	}
738	738	}

	@@ -27,7 +27,7 @@ There are no real deployments, only test installations. Existing prototype datab
27	27	\| 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 \|
28	28	\| 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 \|
29	29	\| 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 \|
30		-\| 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. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) \| Treat as disposable prototype data; replace Settings/local rows, capture review actions, and navigation handles before removing `ModelContainer` \|
	30	+\| 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 has moved to a local Codable store outside `ModelContainer`. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) \| Treat as disposable prototype data; replace remaining Settings/local rows, capture review actions, and navigation handles before removing `ModelContainer` \|
31	31	\| 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 \|
32	32	\| Diff/change explanation \| Prototype/legacy anomaly logic exists \| Move heavy diffing into SQLite and use neutral change classifications \|
33	33	\| 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 \|
	@@ -49,7 +49,7 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
49	49	- SwiftData currently blocks iOS 15-era device support.
50	50	- Existing `Anomaly*` model/service names are legacy language.
51	51	- Some screens still imply snapshot-count monitoring rather than Time Machine inspection.
52		-- Current UI/cache layers still depend on 28 SwiftData-backed files for launch container, local Settings rows, capture review actions, navigation handles, some charts, and PDF paths.
	52	+- Current UI/cache layers still depend on 27 SwiftData-backed files for launch container, remaining local Settings rows, capture review actions, navigation handles, some charts, and PDF paths.
53	53	- 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.
54	54	- Legacy SwiftData-only snapshots can show diffs without archive-backed values; they are now reset for archive v2 test installs rather than migrated.
55	55	- Capture strategy and some legacy SwiftData transition paths may still decode or cache too much data for low-end devices.

	@@ -9,7 +9,7 @@ local settings stored outside SwiftData where needed.
9	9
10	10	## Current Count
11	11
12		-After removing unused imports from pure legacy services, 28 app files still have
	12	+After moving timeout calibration out of SwiftData, 27 app files still have
13	13	SwiftData imports.
14	14
15	15	## Launch Container
	@@ -20,8 +20,8 @@ These files keep SwiftData required at app launch:
20	20	- `HealthProbe/ContentView.swift`
21	21
22	22	Retirement path:
23		-- move local settings models (`DeviceProfile`, `MetricTimeoutProfile`,
24		- `OperationLog`) to non-SwiftData storage or Core Data cache/local store;
	23	+- move remaining local settings models (`DeviceProfile`, `OperationLog`) to
	24	+ non-SwiftData storage or Core Data cache/local store;
25	25	- replace prototype snapshot model dependencies in tab roots;
26	26	- remove `.modelContainer(...)` once no active view needs `@Query` or
27	27	`ModelContext`.
	@@ -35,7 +35,6 @@ block:
35	35	- `HealthProbe/Models/DeviceProfile.swift`
36	36	- `HealthProbe/Models/HealthRecord.swift`
37	37	- `HealthProbe/Models/HealthSnapshot.swift`
38		-- `HealthProbe/Models/MetricTimeoutProfile.swift`
39	38	- `HealthProbe/Models/OperationLog.swift`
40	39	- `HealthProbe/Models/SnapshotDelta.swift`
41	40	- `HealthProbe/Models/TypeCount.swift`
	@@ -48,8 +47,8 @@ Retirement path:
48	47	`YearlyCount`, `TypeDistributionBin`, and `HealthRecord` active reads with
49	48	archive/cache DTOs;
50	49	- replace `AnomalyRecord` flows with neutral change/diff DTOs;
51		-- move `DeviceProfile`, `MetricTimeoutProfile`, and `OperationLog` to a local
52		- non-SwiftData store before removing the launch container.
	50	+- move `DeviceProfile` and `OperationLog` to a local non-SwiftData store before
	51	+ removing the launch container.
53	52
54	53	## Capture And Maintenance Services
55	54
	@@ -64,7 +63,7 @@ These services still write/read legacy SwiftData transition models:
64	63	Retirement path:
65	64	- make capture persist archive observations first and expose only bridge ids
66	65	while transition UI still exists;
67		-- move timeout learning and operation logging out of SwiftData;
	66	+- move operation logging out of SwiftData;
68	67	- delete legacy record repair once old SwiftData stores are no longer opened;
69	68	- remove snapshot deletion/repair logic after archive/cache navigation replaces
70	69	prototype snapshots.
	@@ -90,22 +89,26 @@ Retirement path:
90	89	queries plus archive ids;
91	90	- replace detail navigation parameters from SwiftData models to observation/type
92	91	DTOs;
93		-- move Settings device profile and timeout profile rows to local non-SwiftData
94		- storage;
	92	+- move Settings device profile rows to local non-SwiftData storage;
95	93	- keep paged record drill-down and export paths on archive APIs.
96	94
97	95	## Removed During This Pass
98	96
99		-The following files no longer import SwiftData because they only use already
100		-declared app model types and do not need SwiftData APIs directly:
	97	+The following SwiftData dependencies were removed from active flows:
101	98
102	99	- `HealthProbe/Services/AnomalyDetector.swift`
103	100	- `HealthProbe/Services/IntegrityService.swift`
	101	+- `HealthProbe/Models/MetricTimeoutProfile.swift` was deleted.
	102	+- Metric timeout learning/calibration now uses
	103	+ `HealthProbe/Utilities/LocalMetricTimeoutProfile.swift`, a Codable local
	104	+ store outside `ModelContainer`.
	105	+- `SettingsView`, `DashboardView`, and `HealthKitService` read/write timeout
	106	+ calibration through the local store.
104	107
105	108	## Next Recommended Slices
106	109
107		-1. Replace Settings local rows (`DeviceProfile`, `MetricTimeoutProfile`) with a
108		- small non-SwiftData local store so Settings no longer requires `@Query`.
	110	+1. Replace Settings local rows (`DeviceProfile`) with a small non-SwiftData
	111	+ local store so Settings no longer requires `@Query` for local configuration.
109	112	2. Replace `ContentView` preview/container dependency after tab roots stop using
110	113	`@Query`.
111	114	3. Move `DashboardView` capture review actions away from `ModelContext`.

	@@ -33,7 +33,7 @@ struct HealthProbeApp: App {
33	33	let fullSchema = Schema([
34	34	HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,
35	35	SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,
36		- OperationLog.self, DeviceProfile.self, MetricTimeoutProfile.self,
	36	+ OperationLog.self, DeviceProfile.self,
37	37	])
38	38
39	39	let appSupportURL = URL.applicationSupportDirectory
	@@ -44,7 +44,7 @@ struct HealthProbeApp: App {
44	44	HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self,
45	45	SnapshotDelta.self, TypeDelta.self, AnomalyRecord.self,
46	46	])
47		- let localModels = Schema([OperationLog.self, DeviceProfile.self, MetricTimeoutProfile.self])
	47	+ let localModels = Schema([OperationLog.self, DeviceProfile.self])
48	48
49	49	let uiCacheConfig = ModelConfiguration(
50	50	"ui-cache",

	@@ -8,11 +8,11 @@ struct SettingsView: View {
8	8	@Environment(AppSettings.self) private var appSettings
9	9	@Query private var snapshots: [HealthSnapshot]
10	10	@Query private var deviceProfiles: [DeviceProfile]
11		- @Query(sort: \MetricTimeoutProfile.displayName) private var timeoutProfiles: [MetricTimeoutProfile]
12	11	@AppStorage("checkFrequencyHours") private var checkFrequencyHours: Int = 6
13	12	@State private var showDeleteConfirm = false
14	13	@State private var showRepairLegacyRecordsConfirm = false
15	14	@State private var dataMaintenanceMessage: String?
	15	+ @State private var timeoutProfiles: [LocalMetricTimeoutProfile] = []
16	16
17	17	private var currentDeviceID: String {
18	18	AppSettings.currentDeviceID
	@@ -36,7 +36,7 @@ struct SettingsView: View {
36	36	.navigationTitle("Settings")
37	37	.onAppear {
38	38	ensureCurrentDeviceProfile()
39		- ensureTimeoutProfiles()
	39	+ loadTimeoutProfiles()
40	40	}
41	41	.confirmationDialog(
42	42	"Delete All Audit Data",
	@@ -139,17 +139,23 @@ struct SettingsView: View {
139	139	))
140	140
141	141	InfoRow(label: "Default Initial Timeout") {
142		- Text(formatDuration(MetricTimeoutProfile.defaultInitialTimeout))
	142	+ Text(formatDuration(LocalMetricTimeoutProfile.defaultInitialTimeout))
143	143	.foregroundStyle(.secondary)
144	144	}
145	145
146	146	InfoRow(label: "Maximum Timeout") {
147		- Text(formatDuration(MetricTimeoutProfile.maximumTimeout))
	147	+ Text(formatDuration(LocalMetricTimeoutProfile.maximumTimeout))
148	148	.foregroundStyle(.secondary)
149	149	}
150	150
151	151	ForEach(timeoutProfiles) { profile in
152		- TimeoutProfileRow(profile: profile)
	152	+ TimeoutProfileRow(
	153	+ profile: profile,
	154	+ onManualTimeoutChanged: { setManualTimeout(profile.metricIdentifier, value: $0) },
	155	+ onSetManual: { setManualTimeout(profile.metricIdentifier, value: profile.effectiveTimeout) },
	156	+ onAutomatic: { returnTimeoutProfileToAutomatic(profile.metricIdentifier) },
	157	+ onReset: { resetTimeoutProfile(profile.metricIdentifier) }
	158	+ )
153	159	}
154	160
155	161	Button(role: .destructive) {
	@@ -220,19 +226,43 @@ struct SettingsView: View {
220	226	try? modelContext.save()
221	227	}
222	228
223		- private func ensureTimeoutProfiles() {
224		- let existingIDs = Set(timeoutProfiles.map(\.metricIdentifier))
225		- for type in HealthKitService.allTypes where !existingIDs.contains(type.id) {
226		- modelContext.insert(MetricTimeoutProfile(metricIdentifier: type.id, displayName: type.displayName))
227		- }
228		- try? modelContext.save()
	229	+ private func loadTimeoutProfiles() {
	230	+ timeoutProfiles = LocalMetricTimeoutProfileStore.allProfiles()
229	231	}
230	232
231	233	private func resetAllTimeoutProfiles() {
232		- for profile in timeoutProfiles {
	234	+ LocalMetricTimeoutProfileStore.resetAll()
	235	+ loadTimeoutProfiles()
	236	+ }
	237	+
	238	+ private func setManualTimeout(_ metricIdentifier: String, value: TimeInterval) {
	239	+ updateTimeoutProfile(metricIdentifier) { profile in
	240	+ profile.setManualTimeout(value)
	241	+ }
	242	+ }
	243	+
	244	+ private func returnTimeoutProfileToAutomatic(_ metricIdentifier: String) {
	245	+ updateTimeoutProfile(metricIdentifier) { profile in
	246	+ profile.returnToAutomatic()
	247	+ }
	248	+ }
	249	+
	250	+ private func resetTimeoutProfile(_ metricIdentifier: String) {
	251	+ updateTimeoutProfile(metricIdentifier) { profile in
233	252	profile.resetLearning()
234	253	}
235		- try? modelContext.save()
	254	+ }
	255	+
	256	+ private func updateTimeoutProfile(
	257	+ _ metricIdentifier: String,
	258	+ mutate: (inout LocalMetricTimeoutProfile) -> Void
	259	+ ) {
	260	+ guard let index = timeoutProfiles.firstIndex(where: { $0.metricIdentifier == metricIdentifier }) else {
	261	+ return
	262	+ }
	263	+ mutate(&timeoutProfiles[index])
	264	+ LocalMetricTimeoutProfileStore.save(timeoutProfiles[index])
	265	+ loadTimeoutProfiles()
236	266	}
237	267
238	268	private func deleteAllData() {
	@@ -278,7 +308,11 @@ private struct TypeToggleRow: View {
278	308	}
279	309
280	310	private struct TimeoutProfileRow: View {
281		- @Bindable var profile: MetricTimeoutProfile
	311	+ let profile: LocalMetricTimeoutProfile
	312	+ let onManualTimeoutChanged: (TimeInterval) -> Void
	313	+ let onSetManual: () -> Void
	314	+ let onAutomatic: () -> Void
	315	+ let onReset: () -> Void
282	316
283	317	var body: some View {
284	318	VStack(alignment: .leading, spacing: 8) {
	@@ -327,24 +361,24 @@ private struct TimeoutProfileRow: View {
327	361	if profile.isManuallyOverridden {
328	362	Stepper(
329	363	"Manual \(formatDuration(profile.manualTimeoutValue))",
330		- value: $profile.manualTimeoutValue,
331		- in: MetricTimeoutProfile.defaultInitialTimeout...MetricTimeoutProfile.maximumTimeout,
	364	+ value: Binding(
	365	+ get: { profile.manualTimeoutValue },
	366	+ set: onManualTimeoutChanged
	367	+ ),
	368	+ in: LocalMetricTimeoutProfile.defaultInitialTimeout...LocalMetricTimeoutProfile.maximumTimeout,
332	369	step: 5
333	370	)
334	371	.font(.caption)
335		- .onChange(of: profile.manualTimeoutValue) { _, newValue in
336		- profile.setManualTimeout(newValue)
337		- }
338	372	}
339	373
340	374	HStack {
341	375	Button("Set Manual") {
342		- profile.setManualTimeout(profile.effectiveTimeout)
	376	+ onSetManual()
343	377	}
344	378	.buttonStyle(.borderless)
345	379
346	380	Button("Automatic") {
347		- profile.returnToAutomatic()
	381	+ onAutomatic()
348	382	}
349	383	.buttonStyle(.borderless)
350	384	.disabled(!profile.isManuallyOverridden)
	@@ -352,7 +386,7 @@ private struct TimeoutProfileRow: View {
352	386	Spacer()
353	387
354	388	Button("Reset", role: .destructive) {
355		- profile.resetLearning()
	389	+ onReset()
356	390	}
357	391	.buttonStyle(.borderless)
358	392	}
	@@ -386,6 +420,6 @@ private func formatDuration(_ seconds: TimeInterval) -> String {
386	420
387	421	#Preview {
388	422	SettingsView()
389		- .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self, MetricTimeoutProfile.self], inMemory: true)
	423	+ .modelContainer(for: [HealthSnapshot.self, TypeCount.self, YearlyCount.self, HealthRecord.self, TypeDistributionBin.self, DeviceProfile.self], inMemory: true)
390	424	.environment(AppSettings())
391	425	}