Add Core Data archive cache rebuild · 3d4c7fb

Add Core Data archive cache rebuild
Browse files

bogdan committed 2 weeks ago

main

1 parent 25d8783

commit 3d4c7fb

Showing 6 changed files with 723 additions and 23 deletions

+8 -1

HealthProbe/Doc/00-agent-guides/AGENTS.md

@@ -210,6 +210,13 @@ final class TypeDistributionBin {
 // and materialized aggregates. Expensive counts used by reports/UI should be
 // cached in Core Data and be rebuildable from SQLite.
 
+// Interface updated 2026-05-24 — see AGENTS.md
+// Services/CoreDataArchiveCacheStore.swift defines the rebuildable Core Data
+// UI/report cache boundary. It owns programmatic cache entities for observation
+// rows, type summaries, daily aggregates, diff summaries, export manifests, and
+// archive health. Cache rows carry source observation ids plus archive/cache
+// schema versions; deleting this cache must never delete the SQLite archive.
+
 // Objective updated 2026-05-23 — see AGENTS.md
 // HealthProbe is a local Health DB Time Machine. Snapshot/device identifiers are
 // retained only to preserve local provenance and keep comparisons within one
@@ -338,7 +345,7 @@ When one agent needs to communicate a decision or change to another:
 
 | Module | Status | Owner |
 |--------|--------|-------|
-| Core Data UI/Report Cache | ⏳ Planned replacement of SwiftData | Models agent |
+| Core Data UI/Report Cache | ⏳ Started: programmatic model + full rebuild service | Models agent |
 | HealthKit Integration | ✅ Done | Services agent |
 | Snapshot Diff Service | ✅ Done | Services agent |
 | Service Protocols | ⏳ Not started | Services agent |


+3 -2

HealthProbe/Doc/02-architecture/Core-Data-Cache-Design.md

View

@@ -1,7 +1,7 @@
 # HealthProbe - Core Data Cache Design
 
 **Last Updated:** 2026-05-23
-**Status:** Target design for UI/report cache
+**Status:** Initial programmatic model and full-cache rebuild implemented; UI wiring and targeted invalidation pending
 
 ## 1. Purpose
 
@@ -172,6 +172,8 @@ Rebuild order:
 
 Partial rebuild is allowed when SQLite can identify affected observations/types. Full rebuild must remain available for repair and tests.
 
+Implementation note, 2026-05-24: `CoreDataArchiveCacheStore` defines the cache model programmatically and can rebuild all cache entities from the SQLite archive. The first implementation rebuilds observation rows, type summaries, daily aggregates, adjacent-observation diff summaries, export manifest rows, and archive health rows. It is intentionally rebuildable: deleting the Core Data cache must not touch the SQLite archive.
+
 ## 5. Legacy Device Mode
 
 Legacy or low-memory UI should still use the same Core Data cache. It may reduce:
@@ -185,4 +187,3 @@ It must preserve:
 - cached summaries;
 - report generation;
 - paged SQLite detail/export access.
-


+9 -7

HealthProbe/Doc/04-project/IMPLEMENTATION_STATUS.md

View

@@ -26,7 +26,7 @@ There are no real deployments, only test installations. Existing prototype datab
 | Product docs | Updated | Keep `HealthProbe/Doc/README.md` as canonical index |
 | HealthKit capture | Prototype exists | Adapt capture to write differential SQLite observations first |
 | SQLite archive | Archive v2 schema, 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 | Start Core Data cache work |
-| Core Data cache | Not implemented | Add rebuildable cache for expensive counts, summaries, report metadata, UI state |
+| Core Data cache | Initial programmatic Core Data model and full-cache rebuild service are in place for observation rows, type summaries, daily aggregates, diff summaries, export manifest rows, and archive health | Wire cache reads into UI-facing view models and add targeted partial invalidation |
 | SwiftData cache | Exists | Treat as disposable prototype data; reset/ignore during v2 transition |
 | UI | Prototype exists | Reframe screens around observations, diffs, export, archive status |
 | Diff/change explanation | Prototype/legacy anomaly logic exists | Move heavy diffing into SQLite and use neutral change classifications |
@@ -38,11 +38,12 @@ There are no real deployments, only test installations. Existing prototype datab
 
 Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.md).
 
-1. Add Core Data UI/report cache and rebuild pipeline.
+1. Wire Core Data cache reads into UI-facing view models.
 2. Replace SwiftData UI dependencies with Core Data/cache DTOs.
-3. Update UI language from anomaly/status to observation/diff/export.
-4. Add streaming exports with manifests.
-5. Validate on low-memory/legacy-class devices.
+3. Add targeted cache invalidation for affected observation/type ranges.
+4. Update UI language from anomaly/status to observation/diff/export.
+5. Add streaming exports with manifests.
+6. Validate on low-memory/legacy-class devices.
 
 ## Known Prototype Mismatches
 
@@ -53,14 +54,15 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
 - Existing implementation may decode or cache too much data for low-end devices.
 - Old prototype database compatibility is no longer required.
 - Initial SQLite archive tests cover open/init/reset/idempotency, legacy mirror removal, small observation diffs, large synthetic diff pagination, formal timing/memory metrics, materialized aggregate comparison, source/provenance breakdowns, and consolidation-evidence labels, but not yet export behavior.
+- Initial Core Data cache tests cover full rebuild from SQLite and delete-cache-then-rebuild without losing archive data.
 
 ## Verification Checklist
 
 - [ ] SQLite archive v2 can reconstruct records visible at observation T.
 - [ ] No recurring complete snapshot copies are written for high-volume types.
 - [x] SQL diff between two observations runs without loading full datasets into Swift arrays.
-- [ ] Expensive counts used by reports/UI are cached and rebuildable.
-- [ ] Deleting Core Data cache and rebuilding from SQLite restores UI/report summaries.
+- [x] Expensive counts used by reports/UI are cached and rebuildable.
+- [x] Deleting Core Data cache and rebuilding from SQLite restores UI/report summaries.
 - [ ] Export can stream large selected record sets.
 - [ ] Export manifests include hashes and observation metadata.
 - [ ] iOS app remains read-only with respect to HealthKit.


+15 -13

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

View

+                     **Purpose:** Cache expensive presentation/report values while keeping SQLite authoritative.
+                     Checklist:
+                    -- [ ] Define Core Data model for observation rows.
+                    -- [ ] Define type summary cache entity.
+                    -- [ ] Define daily/monthly aggregate cache entity.
+                    -- [ ] Define diff summary cache entity.
+                    -- [ ] Define export manifest/status cache entity.
+                    -- [ ] Define archive health/status cache entity.
+                    -- [ ] Implement cache rebuild from SQLite.
+                    -- [ ] Implement cache invalidation by archive schema/cache schema/version/hash.
+                    -- [ ] Implement delete-cache-and-rebuild flow.
+                    -- [ ] Add cache schema/version and rebuild tests.
+                    +- [x] Define Core Data model for observation rows.
+                    +- [x] Define type summary cache entity.
+                    +- [x] Define daily/monthly aggregate cache entity.
+                    +- [x] Define diff summary cache entity.
+                    +- [x] Define export manifest/status cache entity.
+                    +- [x] Define archive health/status cache entity.
+                    +- [x] Implement initial cache rebuild from SQLite for observation/type/daily/diff/export/health rows.
+                    +- [x] Include archive schema/cache schema/version/hash fields on rebuilt rows.
+                    +- [x] Implement delete-cache-and-rebuild flow.
+                    +- [x] Add cache schema/version and rebuild tests.
+                    +- [ ] Wire Core Data cache into UI-facing view models.
+                    +- [ ] Add targeted partial invalidation for affected observation/type ranges.
+                     Acceptance:
+                    -- [ ] Deleting Core Data cache does not lose forensic data.
+                    -- [ ] Cache rebuild restores dashboard/timeline/report summaries.
+                    -- [ ] Cache rows include source observation ids and archive/cache schema versions.
+                    +- [x] Deleting Core Data cache does not lose forensic data.
+                    +- [x] Cache rebuild restores dashboard/timeline/report summaries.
+                    +- [x] Cache rows include source observation ids and archive/cache schema versions.
+                     - [ ] SQLite wins on disagreement.
+                     ## Milestone 7 - Export Layer

+585 -0

HealthProbe/Services/CoreDataArchiveCacheStore.swift

View

+                    +import CoreData
+                    +import Foundation
+                    +import SQLite3
+                    +enum CoreDataArchiveCacheStoreError: Error {
+                    +    case persistentStoreLoadFailed(Error)
+                    +    case openArchiveFailed(String)
+                    +    case prepareFailed(String)
+                    +    case stepFailed(String)
+                    +}
+                    +struct CoreDataArchiveCacheRebuildSummary: Equatable, Sendable {
+                    +    let observationRows: Int
+                    +    let typeSummaryRows: Int
+                    +    let dailyAggregateRows: Int
+                    +    let diffSummaryRows: Int
+                    +    let exportManifestRows: Int
+                    +    let archiveHealthRows: Int
+                    +}
+                    +// Interface updated 2026-05-24 — see AGENTS.md
+                    +final class CoreDataArchiveCacheStore {
+                    +    static let cacheSchemaVersion = 1
+                    +    let container: NSPersistentContainer
+                    +    init(storeURL: URL? = nil, inMemory: Bool = false) throws {
+                    +        let model = Self.makeModel()
+                    +        container = NSPersistentContainer(name: "HealthProbeCache", managedObjectModel: model)
+                    +        let description = NSPersistentStoreDescription()
+                    +        if inMemory {
+                    +            description.type = NSInMemoryStoreType
+                    +        } else {
+                    +            let resolvedURL = storeURL ?? URL.applicationSupportDirectory.appending(path: "HealthProbeCache.sqlite")
+                    +            description.url = resolvedURL
+                    +        }
+                    +        description.shouldMigrateStoreAutomatically = true
+                    +        description.shouldInferMappingModelAutomatically = true
+                    +        container.persistentStoreDescriptions = [description]
+                    +        var loadError: Error?
+                    +        container.loadPersistentStores { _, error in
+                    +            loadError = error
+                    +        }
+                    +        if let loadError {
+                    +            throw CoreDataArchiveCacheStoreError.persistentStoreLoadFailed(loadError)
+                    +        }
+                    +        container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
+                    +    }
+                    +    func rebuild(fromArchiveAt archiveURL: URL) throws -> CoreDataArchiveCacheRebuildSummary {
+                    +        let archive = try openArchive(at: archiveURL)
+                    +        defer { sqlite3_close(archive) }
+                    +        let archiveSchemaVersion = try archiveSchemaVersion(db: archive)
+                    +        let integrityStatus = try firstText("PRAGMA integrity_check", db: archive) ?? "missing"
+                    +        let computedAt = Date()
+                    +        let context = container.viewContext
+                    +        try resetCache(context: context)
+                    +        let observationCount = try insertObservationRows(db: archive, context: context, archiveSchemaVersion: archiveSchemaVersion, computedAt: computedAt)
+                    +        let typeSummaryCount = try insertTypeSummaryRows(db: archive, context: context, computedAt: computedAt)
+                    +        let dailyAggregateCount = try insertDailyAggregateRows(db: archive, context: context, computedAt: computedAt)
+                    +        let diffSummaryCount = try insertDiffSummaryRows(db: archive, context: context, computedAt: computedAt)
+                    +        let exportManifestCount = try insertExportManifestRows(db: archive, context: context, computedAt: computedAt)
+                    +        try insertArchiveHealthRow(
+                    +            context: context,
+                    +            archiveSchemaVersion: archiveSchemaVersion,
+                    +            integrityStatus: integrityStatus,
+                    +            computedAt: computedAt
+                    +        )
+                    +        if context.hasChanges {
+                    +            try context.save()
+                    +        }
+                    +        return CoreDataArchiveCacheRebuildSummary(
+                    +            observationRows: observationCount,
+                    +            typeSummaryRows: typeSummaryCount,
+                    +            dailyAggregateRows: dailyAggregateCount,
+                    +            diffSummaryRows: diffSummaryCount,
+                    +            exportManifestRows: exportManifestCount,
+                    +            archiveHealthRows: 1
+                    +        )
+                    +    }
+                    +    func deleteCache() throws {
+                    +        let context = container.viewContext
+                    +        try resetCache(context: context)
+                    +        if context.hasChanges {
+                    +            try context.save()
+                    +        }
+                    +    }
+                    +    private func resetCache(context: NSManagedObjectContext) throws {
+                    +        for entityName in Self.cacheEntityNames {
+                    +            let request = NSFetchRequest<NSManagedObject>(entityName: entityName)
+                    +            let objects = try context.fetch(request)
+                    +            for object in objects {
+                    +                context.delete(object)
+                    +            }
+                    +        }
+                    +    }
+                    +    private func insertObservationRows(
+                    +        db: OpaquePointer?,
+                    +        context: NSManagedObjectContext,
+                    +        archiveSchemaVersion: Int,
+                    +        computedAt: Date
+                    +    ) throws -> Int {
+                    +        let sql = """
+                    +        SELECT
+                    +            o.id,
+                    +            o.observed_at,
+                    +            o.status,
+                    +            o.trigger_reason,
+                    +            o.time_zone_identifier,
+                    +            COUNT(s.sample_type_id),
+                    +            COALESCE(SUM(s.visible_record_count), 0),
+                    +            COALESCE(SUM(s.appeared_count), 0),
+                    +            COALESCE(SUM(s.disappeared_count), 0),
+                    +            COALESCE(SUM(s.representation_changed_count), 0),
+                    +            COALESCE(GROUP_CONCAT(s.aggregate_hash, '|'), '')
+                    +        FROM observations o
+                    +        LEFT JOIN observation_type_summaries s ON s.observation_id = o.id
+                    +        GROUP BY o.id, o.observed_at, o.status, o.trigger_reason, o.time_zone_identifier
+                    +        ORDER BY o.id
+                    +        """
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            var count = 0
+                    +            while sqlite3_step(statement) == SQLITE_ROW {
+                    +                let observationID = sqlite3_column_int64(statement, 0)
+                    +                let sourceHash = HashService.archiveContentHash(
+                    +                    domain: "hp:cache:observation_row",
+                    +                    parts: [
+                    +                        String(observationID),
+                    +                        columnText(statement, 10)
+                    +                    ]
+                    +                )
+                    +                let object = NSEntityDescription.insertNewObject(forEntityName: "CachedObservationRow", into: context)
+                    +                object.setValue(observationID, forKey: "observationID")
+                    +                object.setValue(columnUnixDate(statement, 1), forKey: "observedAt")
+                    +                object.setValue(columnText(statement, 2) ?? "unknown", forKey: "status")
+                    +                object.setValue(columnText(statement, 3) ?? "unknown", forKey: "triggerReason")
+                    +                object.setValue(columnText(statement, 4), forKey: "timeZoneIdentifier")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 5)), forKey: "trackedTypeCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 6)), forKey: "visibleRecordCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 7)), forKey: "appearedCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 8)), forKey: "disappearedCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 9)), forKey: "representationChangedCount")
+                    +                object.setValue(Int64(archiveSchemaVersion), forKey: "archiveSchemaVersion")
+                    +                object.setValue(Int64(Self.cacheSchemaVersion), forKey: "cacheSchemaVersion")
+                    +                object.setValue(sourceHash, forKey: "sourceAggregateHash")
+                    +                object.setValue(computedAt, forKey: "computedAt")
+                    +                count += 1
+                    +            }
+                    +            return count
+                    +        }
+                    +    }
+                    +    private func insertTypeSummaryRows(
+                    +        db: OpaquePointer?,
+                    +        context: NSManagedObjectContext,
+                    +        computedAt: Date
+                    +    ) throws -> Int {
+                    +        let sql = """
+                    +        SELECT
+                    +            s.observation_id,
+                    +            t.type_identifier,
+                    +            t.display_name,
+                    +            s.visible_record_count,
+                    +            s.appeared_count,
+                    +            s.disappeared_count,
+                    +            s.representation_changed_count,
+                    +            s.earliest_start_date,
+                    +            s.latest_end_date,
+                    +            s.value_sum,
+                    +            s.value_max,
+                    +            s.aggregate_hash
+                    +        FROM observation_type_summaries s
+                    +        JOIN sample_types t ON t.id = s.sample_type_id
+                    +        ORDER BY s.observation_id, t.type_identifier
+                    +        """
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            var count = 0
+                    +            while sqlite3_step(statement) == SQLITE_ROW {
+                    +                let object = NSEntityDescription.insertNewObject(forEntityName: "CachedTypeSummary", into: context)
+                    +                object.setValue(sqlite3_column_int64(statement, 0), forKey: "observationID")
+                    +                object.setValue(columnText(statement, 1) ?? "", forKey: "sampleTypeIdentifier")
+                    +                object.setValue(columnText(statement, 2), forKey: "displayName")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 3)), forKey: "visibleRecordCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 4)), forKey: "appearedCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 5)), forKey: "disappearedCount")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 6)), forKey: "representationChangedCount")
+                    +                object.setValue(columnUnixDate(statement, 7), forKey: "earliestStartDate")
+                    +                object.setValue(columnUnixDate(statement, 8), forKey: "latestEndDate")
+                    +                object.setValue(columnDouble(statement, 9), forKey: "valueSum")
+                    +                object.setValue(columnDouble(statement, 10), forKey: "valueMax")
+                    +                object.setValue(columnText(statement, 11), forKey: "aggregateHash")
+                    +                object.setValue(computedAt, forKey: "computedAt")
+                    +                count += 1
+                    +            }
+                    +            return count
+                    +        }
+                    +    }
+                    +    private func insertDailyAggregateRows(
+                    +        db: OpaquePointer?,
+                    +        context: NSManagedObjectContext,
+                    +        computedAt: Date
+                    +    ) throws -> Int {
+                    +        let sql = """
+                    +        SELECT
+                    +            d.observation_id,
+                    +            t.type_identifier,
+                    +            d.bucket_start,
+                    +            d.bucket_end,
+                    +            o.time_zone_identifier,
+                    +            d.visible_record_count,
+                    +            d.value_sum,
+                    +            d.value_max,
+                    +            sr.id,
+                    +            d.aggregate_hash
+                    +        FROM daily_type_aggregates d
+                    +        JOIN sample_types t ON t.id = d.sample_type_id
+                    +        JOIN observations o ON o.id = d.observation_id
+                    +        LEFT JOIN source_revisions sr ON sr.id = d.source_revision_id
+                    +        ORDER BY d.observation_id, t.type_identifier, d.bucket_start, sr.id
+                    +        """
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            var count = 0
+                    +            while sqlite3_step(statement) == SQLITE_ROW {
+                    +                let sourceRevisionHash = columnInt64(statement, 8).map {
+                    +                    HashService.archiveContentHash(domain: "hp:cache:source_revision", parts: [String($0)])
+                    +                }
+                    +                let object = NSEntityDescription.insertNewObject(forEntityName: "CachedDailyAggregate", into: context)
+                    +                object.setValue(sqlite3_column_int64(statement, 0), forKey: "observationID")
+                    +                object.setValue(columnText(statement, 1) ?? "", forKey: "sampleTypeIdentifier")
+                    +                object.setValue(columnUnixDate(statement, 2), forKey: "bucketStart")
+                    +                object.setValue(columnUnixDate(statement, 3), forKey: "bucketEnd")
+                    +                object.setValue(columnText(statement, 4), forKey: "timeZoneIdentifier")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 5)), forKey: "visibleRecordCount")
+                    +                object.setValue(columnDouble(statement, 6), forKey: "valueSum")
+                    +                object.setValue(columnDouble(statement, 7), forKey: "valueMax")
+                    +                object.setValue(sourceRevisionHash, forKey: "sourceRevisionDisplayHash")
+                    +                object.setValue(columnText(statement, 9), forKey: "aggregateHash")
+                    +                object.setValue(computedAt, forKey: "computedAt")
+                    +                count += 1
+                    +            }
+                    +            return count
+                    +        }
+                    +    }
+                    +    private func insertDiffSummaryRows(
+                    +        db: OpaquePointer?,
+                    +        context: NSManagedObjectContext,
+                    +        computedAt: Date
+                    +    ) throws -> Int {
+                    +        let sql = """
+                    +        WITH pairs AS (
+                    +            SELECT
+                    +                o.id AS to_id,
+                    +                (SELECT MAX(p.id) FROM observations p WHERE p.id < o.id) AS from_id
+                    +            FROM observations o
+                    +        )
+                    +        SELECT
+                    +            pairs.from_id,
+                    +            pairs.to_id,
+                    +            t.type_identifier,
+                    +            SUM(CASE WHEN e.event_kind = 'appeared' THEN 1 ELSE 0 END),
+                    +            SUM(CASE WHEN e.event_kind = 'disappeared' THEN 1 ELSE 0 END),
+                    +            SUM(CASE WHEN e.event_kind = 'representationChanged' THEN 1 ELSE 0 END)
+                    +        FROM pairs
+                    +        JOIN sample_observation_events e ON e.observation_id = pairs.to_id
+                    +        JOIN samples s ON s.id = e.sample_id
+                    +        JOIN sample_types t ON t.id = s.sample_type_id
+                    +        WHERE pairs.from_id IS NOT NULL
+                    +        GROUP BY pairs.from_id, pairs.to_id, t.type_identifier
+                    +        ORDER BY pairs.from_id, pairs.to_id, t.type_identifier
+                    +        """
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            var count = 0
+                    +            while sqlite3_step(statement) == SQLITE_ROW {
+                    +                let fromObservationID = sqlite3_column_int64(statement, 0)
+                    +                let toObservationID = sqlite3_column_int64(statement, 1)
+                    +                let sampleTypeIdentifier = columnText(statement, 2) ?? ""
+                    +                let appearedCount = Int64(sqlite3_column_int64(statement, 3))
+                    +                let disappearedCount = Int64(sqlite3_column_int64(statement, 4))
+                    +                let representationChangedCount = Int64(sqlite3_column_int64(statement, 5))
+                    +                let sourceHash = HashService.archiveContentHash(
+                    +                    domain: "hp:cache:diff_summary",
+                    +                    parts: [
+                    +                        String(fromObservationID),
+                    +                        String(toObservationID),
+                    +                        sampleTypeIdentifier,
+                    +                        String(appearedCount),
+                    +                        String(disappearedCount),
+                    +                        String(representationChangedCount)
+                    +                    ]
+                    +                )
+                    +                let object = NSEntityDescription.insertNewObject(forEntityName: "CachedDiffSummary", into: context)
+                    +                object.setValue(fromObservationID, forKey: "fromObservationID")
+                    +                object.setValue(toObservationID, forKey: "toObservationID")
+                    +                object.setValue(sampleTypeIdentifier, forKey: "sampleTypeIdentifier")
+                    +                object.setValue(appearedCount, forKey: "appearedCount")
+                    +                object.setValue(disappearedCount, forKey: "disappearedCount")
+                    +                object.setValue(representationChangedCount, forKey: "representationChangedCount")
+                    +                object.setValue(false, forKey: "consolidationLikely")
+                    +                object.setValue(nil, forKey: "uncertaintyReason")
+                    +                object.setValue(sourceHash, forKey: "sourceAggregateHash")
+                    +                object.setValue(computedAt, forKey: "computedAt")
+                    +                count += 1
+                    +            }
+                    +            return count
+                    +        }
+                    +    }
+                    +    private func insertExportManifestRows(
+                    +        db: OpaquePointer?,
+                    +        context: NSManagedObjectContext,
+                    +        computedAt: Date
+                    +    ) throws -> Int {
+                    +        let sql = """
+                    +        SELECT
+                    +            export_id,
+                    +            export_kind,
+                    +            created_at,
+                    +            from_observation_id,
+                    +            to_observation_id,
+                    +            filter_json,
+                    +            record_count,
+                    +            manifest_hash
+                    +        FROM export_manifests
+                    +        ORDER BY created_at, id
+                    +        """
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            var count = 0
+                    +            while sqlite3_step(statement) == SQLITE_ROW {
+                    +                let object = NSEntityDescription.insertNewObject(forEntityName: "CachedExportManifest", into: context)
+                    +                object.setValue(columnText(statement, 0) ?? "", forKey: "exportID")
+                    +                object.setValue(columnText(statement, 1) ?? "unknown", forKey: "exportKind")
+                    +                object.setValue(columnUnixDate(statement, 2), forKey: "createdAt")
+                    +                object.setValue(columnInt64(statement, 3), forKey: "fromObservationID")
+                    +                object.setValue(columnInt64(statement, 4), forKey: "toObservationID")
+                    +                object.setValue(columnText(statement, 5), forKey: "filterSummary")
+                    +                object.setValue(Int64(sqlite3_column_int64(statement, 6)), forKey: "recordCount")
+                    +                object.setValue(columnText(statement, 7) ?? "", forKey: "manifestHash")
+                    +                object.setValue(nil, forKey: "fileURLBookmarkData")
+                    +                object.setValue("available", forKey: "status")
+                    +                object.setValue(computedAt, forKey: "computedAt")
+                    +                count += 1
+                    +            }
+                    +            return count
+                    +        }
+                    +    }
+                    +    private func insertArchiveHealthRow(
+                    +        context: NSManagedObjectContext,
+                    +        archiveSchemaVersion: Int,
+                    +        integrityStatus: String,
+                    +        computedAt: Date
+                    +    ) throws {
+                    +        let object = NSEntityDescription.insertNewObject(forEntityName: "CachedArchiveHealth", into: context)
+                    +        object.setValue(Int64(archiveSchemaVersion), forKey: "archiveSchemaVersion")
+                    +        object.setValue(Int64(Self.cacheSchemaVersion), forKey: "cacheSchemaVersion")
+                    +        object.setValue(computedAt, forKey: "lastIntegrityCheckAt")
+                    +        object.setValue(integrityStatus, forKey: "lastIntegrityStatus")
+                    +        object.setValue(nil, forKey: "lastErrorKind")
+                    +        object.setValue(nil, forKey: "lastErrorMessageHash")
+                    +        object.setValue(UUID().uuidString, forKey: "cacheBuildID")
+                    +        object.setValue(computedAt, forKey: "computedAt")
+                    +    }
+                    +}
+                    +private extension CoreDataArchiveCacheStore {
+                    +    static let cacheEntityNames = [
+                    +        "CachedObservationRow",
+                    +        "CachedTypeSummary",
+                    +        "CachedDailyAggregate",
+                    +        "CachedDiffSummary",
+                    +        "CachedExportManifest",
+                    +        "CachedArchiveHealth"
+                    +    ]
+                    +    static func makeModel() -> NSManagedObjectModel {
+                    +        let model = NSManagedObjectModel()
+                    +        model.entities = [
+                    +            cachedObservationRowEntity(),
+                    +            cachedTypeSummaryEntity(),
+                    +            cachedDailyAggregateEntity(),
+                    +            cachedDiffSummaryEntity(),
+                    +            cachedExportManifestEntity(),
+                    +            cachedArchiveHealthEntity()
+                    +        ]
+                    +        return model
+                    +    }
+                    +    static func cachedObservationRowEntity() -> NSEntityDescription {
+                    +        entity("CachedObservationRow", attributes: [
+                    +            attribute("observationID", .integer64AttributeType),
+                    +            attribute("observedAt", .dateAttributeType),
+                    +            attribute("status", .stringAttributeType),
+                    +            attribute("triggerReason", .stringAttributeType),
+                    +            attribute("timeZoneIdentifier", .stringAttributeType, optional: true),
+                    +            attribute("trackedTypeCount", .integer64AttributeType),
+                    +            attribute("visibleRecordCount", .integer64AttributeType),
+                    +            attribute("appearedCount", .integer64AttributeType),
+                    +            attribute("disappearedCount", .integer64AttributeType),
+                    +            attribute("representationChangedCount", .integer64AttributeType),
+                    +            attribute("archiveSchemaVersion", .integer64AttributeType),
+                    +            attribute("cacheSchemaVersion", .integer64AttributeType),
+                    +            attribute("sourceAggregateHash", .stringAttributeType),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func cachedTypeSummaryEntity() -> NSEntityDescription {
+                    +        entity("CachedTypeSummary", attributes: [
+                    +            attribute("observationID", .integer64AttributeType),
+                    +            attribute("sampleTypeIdentifier", .stringAttributeType),
+                    +            attribute("displayName", .stringAttributeType, optional: true),
+                    +            attribute("visibleRecordCount", .integer64AttributeType),
+                    +            attribute("appearedCount", .integer64AttributeType),
+                    +            attribute("disappearedCount", .integer64AttributeType),
+                    +            attribute("representationChangedCount", .integer64AttributeType),
+                    +            attribute("earliestStartDate", .dateAttributeType, optional: true),
+                    +            attribute("latestEndDate", .dateAttributeType, optional: true),
+                    +            attribute("valueSum", .doubleAttributeType, optional: true),
+                    +            attribute("valueMax", .doubleAttributeType, optional: true),
+                    +            attribute("aggregateHash", .stringAttributeType, optional: true),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func cachedDailyAggregateEntity() -> NSEntityDescription {
+                    +        entity("CachedDailyAggregate", attributes: [
+                    +            attribute("observationID", .integer64AttributeType),
+                    +            attribute("sampleTypeIdentifier", .stringAttributeType),
+                    +            attribute("bucketStart", .dateAttributeType),
+                    +            attribute("bucketEnd", .dateAttributeType),
+                    +            attribute("timeZoneIdentifier", .stringAttributeType, optional: true),
+                    +            attribute("visibleRecordCount", .integer64AttributeType),
+                    +            attribute("valueSum", .doubleAttributeType, optional: true),
+                    +            attribute("valueMax", .doubleAttributeType, optional: true),
+                    +            attribute("sourceRevisionDisplayHash", .stringAttributeType, optional: true),
+                    +            attribute("aggregateHash", .stringAttributeType, optional: true),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func cachedDiffSummaryEntity() -> NSEntityDescription {
+                    +        entity("CachedDiffSummary", attributes: [
+                    +            attribute("fromObservationID", .integer64AttributeType),
+                    +            attribute("toObservationID", .integer64AttributeType),
+                    +            attribute("sampleTypeIdentifier", .stringAttributeType, optional: true),
+                    +            attribute("appearedCount", .integer64AttributeType),
+                    +            attribute("disappearedCount", .integer64AttributeType),
+                    +            attribute("representationChangedCount", .integer64AttributeType),
+                    +            attribute("consolidationLikely", .booleanAttributeType),
+                    +            attribute("uncertaintyReason", .stringAttributeType, optional: true),
+                    +            attribute("sourceAggregateHash", .stringAttributeType),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func cachedExportManifestEntity() -> NSEntityDescription {
+                    +        entity("CachedExportManifest", attributes: [
+                    +            attribute("exportID", .stringAttributeType),
+                    +            attribute("exportKind", .stringAttributeType),
+                    +            attribute("createdAt", .dateAttributeType),
+                    +            attribute("fromObservationID", .integer64AttributeType, optional: true),
+                    +            attribute("toObservationID", .integer64AttributeType, optional: true),
+                    +            attribute("filterSummary", .stringAttributeType, optional: true),
+                    +            attribute("recordCount", .integer64AttributeType),
+                    +            attribute("manifestHash", .stringAttributeType),
+                    +            attribute("fileURLBookmarkData", .binaryDataAttributeType, optional: true),
+                    +            attribute("status", .stringAttributeType),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func cachedArchiveHealthEntity() -> NSEntityDescription {
+                    +        entity("CachedArchiveHealth", attributes: [
+                    +            attribute("archiveSchemaVersion", .integer64AttributeType),
+                    +            attribute("cacheSchemaVersion", .integer64AttributeType),
+                    +            attribute("lastIntegrityCheckAt", .dateAttributeType),
+                    +            attribute("lastIntegrityStatus", .stringAttributeType),
+                    +            attribute("lastErrorKind", .stringAttributeType, optional: true),
+                    +            attribute("lastErrorMessageHash", .stringAttributeType, optional: true),
+                    +            attribute("cacheBuildID", .stringAttributeType),
+                    +            attribute("computedAt", .dateAttributeType)
+                    +        ])
+                    +    }
+                    +    static func entity(_ name: String, attributes: [NSAttributeDescription]) -> NSEntityDescription {
+                    +        let entity = NSEntityDescription()
+                    +        entity.name = name
+                    +        entity.managedObjectClassName = "NSManagedObject"
+                    +        entity.properties = attributes
+                    +        return entity
+                    +    }
+                    +    static func attribute(
+                    +        _ name: String,
+                    +        _ type: NSAttributeType,
+                    +        optional: Bool = false
+                    +    ) -> NSAttributeDescription {
+                    +        let attribute = NSAttributeDescription()
+                    +        attribute.name = name
+                    +        attribute.attributeType = type
+                    +        attribute.isOptional = optional
+                    +        return attribute
+                    +    }
+                    +}
+                    +private extension CoreDataArchiveCacheStore {
+                    +    func openArchive(at archiveURL: URL) throws -> OpaquePointer? {
+                    +        var db: OpaquePointer?
+                    +        guard sqlite3_open_v2(archiveURL.path, &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nil) == SQLITE_OK else {
+                    +            let message = db.map(lastErrorMessage) ?? "unable to open archive database"
+                    +            sqlite3_close(db)
+                    +            throw CoreDataArchiveCacheStoreError.openArchiveFailed(message)
+                    +        }
+                    +        return db
+                    +    }
+                    +    func archiveSchemaVersion(db: OpaquePointer?) throws -> Int {
+                    +        let sql = "SELECT value FROM archive_metadata WHERE key = 'schema_version' LIMIT 1"
+                    +        return try withStatement(sql, db: db) { statement in
+                    +            guard sqlite3_step(statement) == SQLITE_ROW,
+                    +                  let value = columnText(statement, 0),
+                    +                  let version = Int(value) else {
+                    +                return 0
+                    +            }
+                    +            return version
+                    +        }
+                    +    }
+                    +    func firstText(_ sql: String, db: OpaquePointer?) throws -> String? {
+                    +        try withStatement(sql, db: db) { statement in
+                    +            guard sqlite3_step(statement) == SQLITE_ROW else {
+                    +                return nil
+                    +            }
+                    +            return columnText(statement, 0)
+                    +        }
+                    +    }
+                    +    func withStatement<T>(_ sql: String, db: OpaquePointer?, body: (OpaquePointer?) throws -> T) throws -> T {
+                    +        var statement: OpaquePointer?
+                    +        guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {
+                    +            throw CoreDataArchiveCacheStoreError.prepareFailed(lastErrorMessage(db))
+                    +        }
+                    +        defer { sqlite3_finalize(statement) }
+                    +        return try body(statement)
+                    +    }
+                    +}
+                    +private func lastErrorMessage(_ db: OpaquePointer?) -> String {
+                    +    guard let message = sqlite3_errmsg(db) else { return "unknown SQLite error" }
+                    +    return String(cString: message)
+                    +}
+                    +private func columnText(_ statement: OpaquePointer?, _ index: Int32) -> String? {
+                    +    guard sqlite3_column_type(statement, index) != SQLITE_NULL,
+                    +          let pointer = sqlite3_column_text(statement, index) else {
+                    +        return nil
+                    +    }
+                    +    return String(cString: pointer)
+                    +}
+                    +private func columnDouble(_ statement: OpaquePointer?, _ index: Int32) -> Double? {
+                    +    guard sqlite3_column_type(statement, index) != SQLITE_NULL else { return nil }
+                    +    return sqlite3_column_double(statement, index)
+                    +}
+                    +private func columnInt64(_ statement: OpaquePointer?, _ index: Int32) -> Int64? {
+                    +    guard sqlite3_column_type(statement, index) != SQLITE_NULL else { return nil }
+                    +    return sqlite3_column_int64(statement, index)
+                    +}
+                    +private func columnUnixDate(_ statement: OpaquePointer?, _ index: Int32) -> Date? {
+                    +    columnDouble(statement, index).map { Date(timeIntervalSince1970: $0) }
+                    +}

+103 -0

HealthProbeTests/CoreDataArchiveCacheStoreTests.swift

View

+                    +import CoreData
+                    +import HealthKit
+                    +import XCTest
+                    +@testable import HealthProbe
+                    +final class CoreDataArchiveCacheStoreTests: XCTestCase {
+                    +    private var temporaryDirectory: URL!
+                    +    override func setUpWithError() throws {
+                    +        temporaryDirectory = FileManager.default.temporaryDirectory
+                    +            .appending(path: "HealthProbeCacheTests-\(UUID().uuidString)", directoryHint: .isDirectory)
+                    +        try FileManager.default.createDirectory(at: temporaryDirectory, withIntermediateDirectories: true)
+                    +    }
+                    +    override func tearDownWithError() throws {
+                    +        if let temporaryDirectory {
+                    +            try? FileManager.default.removeItem(at: temporaryDirectory)
+                    +        }
+                    +        temporaryDirectory = nil
+                    +    }
+                    +    func testRebuildCreatesCoreDataRowsFromSQLiteArchive() async throws {
+                    +        let archiveURL = temporaryDirectory.appending(path: "Archive.sqlite")
+                    +        let archive = SQLiteHealthArchiveStore(databaseURL: archiveURL)
+                    +        let firstSample = makeStepCountSample(value: 42, start: 1_000)
+                    +        let secondSample = makeStepCountSample(value: 7, start: 2_000)
+                    +        _ = try await archive.upsertSamples([firstSample], observedAt: Date(timeIntervalSince1970: 3_000))
+                    +        _ = try await archive.upsertSamples([firstSample, secondSample], observedAt: Date(timeIntervalSince1970: 3_060))
+                    +        try await archive.recordDisappearance(
+                    +            sampleUUIDHash: HashService.sampleUUIDHash(firstSample.uuid.uuidString),
+                    +            sampleTypeIdentifier: HKQuantityTypeIdentifier.stepCount.rawValue,
+                    +            observedMissingAt: Date(timeIntervalSince1970: 3_120)
+                    +        )
+                    +        try await archive.markVerification(
+                    +            sampleType: firstSample.sampleType,
+                    +            verifiedAt: Date(timeIntervalSince1970: 3_180)
+                    +        )
+                    +        let cache = try CoreDataArchiveCacheStore(inMemory: true)
+                    +        let summary = try cache.rebuild(fromArchiveAt: archiveURL)
+                    +        let context = cache.container.viewContext
+                    +        XCTAssertEqual(summary.observationRows, 4)
+                    +        XCTAssertEqual(summary.typeSummaryRows, 4)
+                    +        XCTAssertGreaterThanOrEqual(summary.dailyAggregateRows, 1)
+                    +        XCTAssertEqual(summary.archiveHealthRows, 1)
+                    +        XCTAssertEqual(try count("CachedObservationRow", in: context), 4)
+                    +        XCTAssertEqual(try count("CachedTypeSummary", in: context), 4)
+                    +        XCTAssertEqual(try count("CachedArchiveHealth", in: context), 1)
+                    +        let latestObservation = try fetchFirst(
+                    +            "CachedObservationRow",
+                    +            predicate: NSPredicate(format: "observationID == %d", 4),
+                    +            in: context
+                    +        )
+                    +        XCTAssertEqual(latestObservation?.value(forKey: "visibleRecordCount") as? Int64, 1)
+                    +        XCTAssertEqual(latestObservation?.value(forKey: "cacheSchemaVersion") as? Int64, Int64(CoreDataArchiveCacheStore.cacheSchemaVersion))
+                    +    }
+                    +    func testDeletingCacheDoesNotDeleteSQLiteArchiveAndRebuildRestoresRows() async throws {
+                    +        let archiveURL = temporaryDirectory.appending(path: "Archive.sqlite")
+                    +        let archive = SQLiteHealthArchiveStore(databaseURL: archiveURL)
+                    +        let sample = makeStepCountSample(value: 10, start: 1_000)
+                    +        _ = try await archive.upsertSamples([sample], observedAt: Date(timeIntervalSince1970: 2_000))
+                    +        let cache = try CoreDataArchiveCacheStore(inMemory: true)
+                    +        _ = try cache.rebuild(fromArchiveAt: archiveURL)
+                    +        try cache.deleteCache()
+                    +        XCTAssertEqual(try count("CachedObservationRow", in: cache.container.viewContext), 0)
+                    +        let integrityReport = try await archive.checkIntegrity()
+                    +        XCTAssertTrue(integrityReport.passed)
+                    +        let rebuilt = try cache.rebuild(fromArchiveAt: archiveURL)
+                    +        XCTAssertEqual(rebuilt.observationRows, 1)
+                    +        XCTAssertEqual(try count("CachedObservationRow", in: cache.container.viewContext), 1)
+                    +    }
+                    +    private func makeStepCountSample(value: Double, start: TimeInterval, end: TimeInterval? = nil) -> HKQuantitySample {
+                    +        let quantityType = HKQuantityType.quantityType(forIdentifier: .stepCount)!
+                    +        let quantity = HKQuantity(unit: .count(), doubleValue: value)
+                    +        let startDate = Date(timeIntervalSince1970: start)
+                    +        let endDate = Date(timeIntervalSince1970: end ?? (start + 300))
+                    +        return HKQuantitySample(type: quantityType, quantity: quantity, start: startDate, end: endDate)
+                    +    }
+                    +    private func count(_ entityName: String, in context: NSManagedObjectContext) throws -> Int {
+                    +        let request = NSFetchRequest<NSManagedObject>(entityName: entityName)
+                    +        return try context.count(for: request)
+                    +    }
+                    +    private func fetchFirst(
+                    +        _ entityName: String,
+                    +        predicate: NSPredicate,
+                    +        in context: NSManagedObjectContext
+                    +    ) throws -> NSManagedObject? {
+                    +        let request = NSFetchRequest<NSManagedObject>(entityName: entityName)
+                    +        request.predicate = predicate
+                    +        request.fetchLimit = 1
+                    +        return try context.fetch(request).first
+                    +    }
+                    +}

	@@ -210,6 +210,13 @@ final class TypeDistributionBin {
210	210	// and materialized aggregates. Expensive counts used by reports/UI should be
211	211	// cached in Core Data and be rebuildable from SQLite.
212	212
	213	+// Interface updated 2026-05-24 — see AGENTS.md
	214	+// Services/CoreDataArchiveCacheStore.swift defines the rebuildable Core Data
	215	+// UI/report cache boundary. It owns programmatic cache entities for observation
	216	+// rows, type summaries, daily aggregates, diff summaries, export manifests, and
	217	+// archive health. Cache rows carry source observation ids plus archive/cache
	218	+// schema versions; deleting this cache must never delete the SQLite archive.
	219	+
213	220	// Objective updated 2026-05-23 — see AGENTS.md
214	221	// HealthProbe is a local Health DB Time Machine. Snapshot/device identifiers are
215	222	// retained only to preserve local provenance and keep comparisons within one
	@@ -338,7 +345,7 @@ When one agent needs to communicate a decision or change to another:
338	345
339	346	\| Module \| Status \| Owner \|
340	347	\|--------\|--------\|-------\|
341		-\| Core Data UI/Report Cache \| ⏳ Planned replacement of SwiftData \| Models agent \|
	348	+\| Core Data UI/Report Cache \| ⏳ Started: programmatic model + full rebuild service \| Models agent \|
342	349	\| HealthKit Integration \| ✅ Done \| Services agent \|
343	350	\| Snapshot Diff Service \| ✅ Done \| Services agent \|
344	351	\| Service Protocols \| ⏳ Not started \| Services agent \|

	@@ -1,7 +1,7 @@
1	1	# HealthProbe - Core Data Cache Design
2	2
3	3	Last Updated: 2026-05-23
4		-Status: Target design for UI/report cache
	4	+Status: Initial programmatic model and full-cache rebuild implemented; UI wiring and targeted invalidation pending
5	5
6	6	## 1. Purpose
7	7
	@@ -172,6 +172,8 @@ Rebuild order:
172	172
173	173	Partial rebuild is allowed when SQLite can identify affected observations/types. Full rebuild must remain available for repair and tests.
174	174
	175	+Implementation note, 2026-05-24: `CoreDataArchiveCacheStore` defines the cache model programmatically and can rebuild all cache entities from the SQLite archive. The first implementation rebuilds observation rows, type summaries, daily aggregates, adjacent-observation diff summaries, export manifest rows, and archive health rows. It is intentionally rebuildable: deleting the Core Data cache must not touch the SQLite archive.
	176	+
175	177	## 5. Legacy Device Mode
176	178
177	179	Legacy or low-memory UI should still use the same Core Data cache. It may reduce:
	@@ -185,4 +187,3 @@ It must preserve:
185	187	- cached summaries;
186	188	- report generation;
187	189	- paged SQLite detail/export access.
188		-

	@@ -26,7 +26,7 @@ There are no real deployments, only test installations. Existing prototype datab
26	26	\| Product docs \| Updated \| Keep `HealthProbe/Doc/README.md` as canonical index \|
27	27	\| HealthKit capture \| Prototype exists \| Adapt capture to write differential SQLite observations first \|
28	28	\| SQLite archive \| Archive v2 schema, 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 \| Start Core Data cache work \|
29		-\| Core Data cache \| Not implemented \| Add rebuildable cache for expensive counts, summaries, report metadata, UI state \|
	29	+\| Core Data cache \| Initial programmatic Core Data model and full-cache rebuild service are in place for observation rows, type summaries, daily aggregates, diff summaries, export manifest rows, and archive health \| Wire cache reads into UI-facing view models and add targeted partial invalidation \|
30	30	\| SwiftData cache \| Exists \| Treat as disposable prototype data; reset/ignore during v2 transition \|
31	31	\| UI \| Prototype exists \| Reframe screens around observations, diffs, export, archive status \|
32	32	\| Diff/change explanation \| Prototype/legacy anomaly logic exists \| Move heavy diffing into SQLite and use neutral change classifications \|
	@@ -38,11 +38,12 @@ There are no real deployments, only test installations. Existing prototype datab
38	38
39	39	Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.md).
40	40
41		-1. Add Core Data UI/report cache and rebuild pipeline.
	41	+1. Wire Core Data cache reads into UI-facing view models.
42	42	2. Replace SwiftData UI dependencies with Core Data/cache DTOs.
43		-3. Update UI language from anomaly/status to observation/diff/export.
44		-4. Add streaming exports with manifests.
45		-5. Validate on low-memory/legacy-class devices.
	43	+3. Add targeted cache invalidation for affected observation/type ranges.
	44	+4. Update UI language from anomaly/status to observation/diff/export.
	45	+5. Add streaming exports with manifests.
	46	+6. Validate on low-memory/legacy-class devices.
46	47
47	48	## Known Prototype Mismatches
48	49
	@@ -53,14 +54,15 @@ Detailed checkable milestones live in [`Refactoring-Plan.md`](Refactoring-Plan.m
53	54	- Existing implementation may decode or cache too much data for low-end devices.
54	55	- Old prototype database compatibility is no longer required.
55	56	- Initial SQLite archive tests cover open/init/reset/idempotency, legacy mirror removal, small observation diffs, large synthetic diff pagination, formal timing/memory metrics, materialized aggregate comparison, source/provenance breakdowns, and consolidation-evidence labels, but not yet export behavior.
	57	+- Initial Core Data cache tests cover full rebuild from SQLite and delete-cache-then-rebuild without losing archive data.
56	58
57	59	## Verification Checklist
58	60
59	61	- [ ] SQLite archive v2 can reconstruct records visible at observation T.
60	62	- [ ] No recurring complete snapshot copies are written for high-volume types.
61	63	- [x] SQL diff between two observations runs without loading full datasets into Swift arrays.
62		-- [ ] Expensive counts used by reports/UI are cached and rebuildable.
63		-- [ ] Deleting Core Data cache and rebuilding from SQLite restores UI/report summaries.
	64	+- [x] Expensive counts used by reports/UI are cached and rebuildable.
	65	+- [x] Deleting Core Data cache and rebuilding from SQLite restores UI/report summaries.
64	66	- [ ] Export can stream large selected record sets.
65	67	- [ ] Export manifests include hashes and observation metadata.
66	68	- [ ] iOS app remains read-only with respect to HealthKit.