|------|----------------|--------------------|

 | Product docs | Updated | Keep `HealthProbe/Doc/README.md` as canonical index |

 | HealthKit capture | Capture now opens one archive observation per user-visible snapshot, attaches HealthKit pages, deleted-object evidence, and type verification to that observation id before finishing it, no longer aborts initial full-history imports after a fixed 30-minute wall-clock cap while page-level HealthKit timeouts remain in place, defers grouped observation summary/daily aggregate rebuilds until per-type verification instead of rebuilding after every imported page, and persists large HealthKit pages in smaller archive chunks while using a smaller anchored-query page size to avoid long monolithic SQLite stalls | Continue moving UI/cache reads to archive-backed observation ids and revisit fully adaptive paging/background collection separately |

 | 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. Metric timeout calibration, local device profile settings, operation logging, ContentView preview, Settings data maintenance, legacy detail/PDF views, unused legacy repair/observer services, Dashboard view/view-model access, and legacy anomaly/count-drop review have moved outside SwiftData or been removed. Remaining SwiftData imports are inventoried in [`SwiftData-Retirement-Inventory.md`](SwiftData-Retirement-Inventory.md) | Treat as disposable prototype data; stop returning/storing `HealthSnapshot` bridge handles before removing `ModelContainer` |

 | UI | Prototype exists; Dashboard status reads archive/cache observation rows and shows cache health, and Dashboard view/view-model code no longer imports SwiftData or reads `ModelContext`; capture/review actions now route through DTOs and snapshot ids, with the remaining legacy bridge isolated in `HealthKitService`. Snapshots and Data Types tab roots no longer import SwiftData, load Core Data cached observation rows, and open archive/cache-backed detail rows; `SnapshotArchiveDetailView` and `DataTypeArchiveDetailView` read Core Data type/diff summaries and page record drill-down through SQLite; unused legacy SwiftData snapshot/type detail and PDF views have been deleted; record-change evolution and temporal distribution screens now receive DTO rows/cache input instead of querying SwiftData directly; export preview reads the archive export API before showing/exporting JSON; simplified detail mode replaces heavy charts with summary rows on small/accessibility layouts or when enabled in Settings; visible change labels now use neutral new/missing/change-review language | Stop writing prototype `HealthSnapshot` bridge rows during capture/review |

 - Snapshots timeline/detail rows, Data Types list/detail rows, and record drill-down are archive/cache-backed for new archive v2 observations when cache rows exist.

 - Legacy SwiftData-only snapshots are 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.

 - Old prototype database compatibility is no longer required.

 - Initial SQLite archive tests cover open/init/reset/idempotency, snapshot-level observation grouping, legacy mirror removal, small observation diffs, large synthetic diff pagination, formal timing/memory metrics, materialized aggregate comparison, source/provenance breakdowns, consolidation-evidence labels, export preview, paged JSON output, and manifest row persistence.

 - Initial Core Data cache tests cover full rebuild from SQLite and delete-cache-then-rebuild without losing archive data.

         db: OpaquePointer?,

         rebuildDerivedState: Bool

     ) throws -> HealthArchiveWriteSummary {

         let rows = samples.map { ArchiveSampleRow(sample: $0, observedAt: observedAt) }

         var inserted = 0

         var updated = 0

         var typeEventCounts: [Int64: (inserted: Int, deleted: Int)] = [:]

         for row in rows {

             var counts = typeEventCounts[result.sampleTypeID, default: (inserted: 0, deleted: 0)]

             switch result.kind {

             case .inserted:

                 insertedEventCount: eventCounts.inserted,

                 deletedEventCount: eventCounts.deleted,

                 verifiedVisibleCount: nil,

             )

             if rebuildDerivedState {

                 try rebuildTypeSummary(observationID: observationID, sampleTypeID: sampleTypeID, db: db)

         observationID: Int64,

         db: OpaquePointer?

     ) throws {

         let visibleCount = try visibleAggregate(sampleTypeID: sampleTypeID, db: db).visibleRecordCount

         try insertObservationTypeRun(

             observationID: observationID,

             insertedEventCount: 0,

             deletedEventCount: 0,

             verifiedVisibleCount: visibleCount,

         )

         try rebuildTypeSummary(observationID: observationID, sampleTypeID: sampleTypeID, db: db)

         try rebuildDailyAggregates(

         db: OpaquePointer?,

         rebuildDerivedState: Bool

     ) throws {

             return

         }

             eventKind: "disappeared",

             evidenceKind: "deleted_object",

             observedAt: observedMissingAt,

         )

         try closeOpenVisibilityRanges(

             sampleID: sampleID,

             excludingVersionID: nil,

             closedAtObservationID: observationID,

             observedAt: observedMissingAt,

         )

         try insertObservationTypeRun(

             observationID: observationID,

             insertedEventCount: 0,

             deletedEventCount: 1,

             verifiedVisibleCount: nil,

         )

         if rebuildDerivedState {

             try rebuildTypeSummary(observationID: observationID, sampleTypeID: sampleTypeID, db: db)

     private func upsertArchiveV2Sample(

         _ row: ArchiveSampleRow,

         observationID: Int64,

     ) throws -> ArchiveV2SampleWriteResult {

         let versionResult = try upsertSampleVersion(

             row,

             sampleID: sampleResult.id,

             deviceID: deviceID,

             metadataID: metadataID,

             observationID: observationID,

         )

         let writeKind: ArchiveV2SampleWriteKind

             eventKind: eventKind,

             evidenceKind: "healthkit_sample",

             observedAt: row.observedAt,

         )

         try closeOpenVisibilityRanges(

             sampleID: sampleResult.id,

             excludingVersionID: versionResult.id,

             closedAtObservationID: observationID,

             observedAt: row.observedAt,

         )

         try insertOpenVisibilityRangeIfNeeded(

             sampleID: sampleResult.id,

             versionID: versionResult.id,

             observationID: observationID,

             observedAt: row.observedAt,

         )

         return ArchiveV2SampleWriteResult(sampleTypeID: sampleTypeID, kind: writeKind)

         insertedEventCount: Int,

         deletedEventCount: Int,

         verifiedVisibleCount: Int?,

     ) throws {

         if let existing = try observationTypeRunCounts(

             observationID: observationID,

             sampleTypeID: sampleTypeID,

         ) {

             try withStatement(

                 """

                 WHERE observation_id = ? AND sample_type_id = ?

                 """,

                 db: db

                 bindText(status, to: 1, in: statement)

                 sqlite3_bind_double(statement, 2, observedAt.timeIntervalSince1970)

                 sqlite3_bind_double(statement, 3, observedAt.timeIntervalSince1970)

                 inserted_event_count, deleted_event_count, verified_visible_count

             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)

             """

                 bindInt64(observationID, to: 1, in: statement)

                 bindInt64(sampleTypeID, to: 2, in: statement)

                 bindText(status, to: 3, in: statement)

     private func observationTypeRunCounts(

         observationID: Int64,

         sampleTypeID: Int64,

     ) throws -> (inserted: Int, deleted: Int)? {

         try withStatement(

             """

             WHERE observation_id = ? AND sample_type_id = ?

             LIMIT 1

             """,

         ) { statement in

             bindInt64(observationID, to: 1, in: statement)

             bindInt64(sampleTypeID, to: 2, in: statement)

         }

     }

         try withStatement(

             "INSERT OR IGNORE INTO sample_types (type_identifier, display_name, category) VALUES (?, NULL, NULL)",

         ) { statement in

             bindText(typeIdentifier, to: 1, in: statement)

             guard sqlite3_step(statement) == SQLITE_DONE else {

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

             }

         }

             bindText(typeIdentifier, to: 1, in: statement)

         }

     }

             bindText(typeIdentifier, to: 1, in: statement)

         }

     }

         guard row.sourceName != nil || row.sourceBundleIdentifier != nil else { return nil }

         let sourceNameHash = row.sourceName.map { HashService.archiveContentHash(domain: "hp:v2:source_name", parts: [$0]) }

         if let existing = try sourceRevisionID(

             sourceID: sourceID,

             productType: row.sourceProductType,

             version: row.sourceVersion,

             operatingSystemVersion: row.sourceOperatingSystemVersion,

         ) {

             return existing

         }

         try withStatement(

             "INSERT INTO source_revisions (source_id, product_type, version, operating_system_version) VALUES (?, ?, ?, ?)",

         ) { statement in

             bindInt64(sourceID, to: 1, in: statement)

             bindText(row.sourceProductType, to: 2, in: statement)

         productType: String?,

         version: String?,

         operatingSystemVersion: String?,

     ) throws -> Int64? {

         try optionalInt64(

             """

               AND (operating_system_version = ? OR (operating_system_version IS NULL AND ? IS NULL))

             LIMIT 1

             """,

         ) { statement in

             bindInt64(sourceID, to: 1, in: statement)

             bindText(productType, to: 2, in: statement)

         }

     }

         if let existing = try optionalInt64(

             """

             SELECT id FROM sources

             LIMIT 1

             """,

             db: db,

             bind: { statement in

                 bindText(sourceNameHash, to: 1, in: statement)

                 bindText(sourceNameHash, to: 2, in: statement)

         ) {

             return existing

         }

             bindText(sourceNameHash, to: 1, in: statement)

             bindText(bundleIdentifier, to: 2, in: statement)

             guard sqlite3_step(statement) == SQLITE_DONE else {

         return sqlite3_last_insert_rowid(db)

     }

         guard row.hasDeviceProvenance else { return nil }

         let deviceHash = row.deviceName.map { HashService.archiveContentHash(domain: "hp:v2:device_name", parts: [$0]) }

         let manufacturerHash = row.deviceManufacturer.map { HashService.archiveContentHash(domain: "hp:v2:device_manufacturer", parts: [$0]) }

             LIMIT 1

             """,

             db: db,

             bind: { statement in

                 bindText(deviceHash, to: 1, in: statement)

                 bindText(deviceHash, to: 2, in: statement)

                 software_version, local_identifier_hash, udi_hash

             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)

             """,

         ) { statement in

             bindText(deviceHash, to: 1, in: statement)

             bindText(manufacturerHash, to: 2, in: statement)

         return sqlite3_last_insert_rowid(db)

     }

         guard let metadataHash = row.metadataHash, let metadataJSON = row.metadataJSON else { return nil }

         try withStatement(

             "INSERT OR IGNORE INTO metadata_blobs (metadata_hash, metadata_json) VALUES (?, ?)",

         ) { statement in

             bindText(metadataHash, to: 1, in: statement)

             bindText(metadataJSON, to: 2, in: statement)

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

             }

         }

             bindText(metadataHash, to: 1, in: statement)

         }

     }

         _ row: ArchiveSampleRow,

         sampleTypeID: Int64,

         observationID: Int64,

     ) throws -> (id: Int64, inserted: Bool) {

         try withStatement(

             """

                 fuzzy_key, first_seen_observation_id, first_seen_at

             ) VALUES (?, ?, ?, ?, NULL, ?, ?)

             """,

         ) { statement in

             bindInt64(sampleTypeID, to: 1, in: statement)

             bindText(row.sampleUUIDHash, to: 2, in: statement)

         let inserted = sqlite3_changes(db) > 0

         let id = try requiredInt64(

             "SELECT id FROM samples WHERE sample_type_id = ? AND strict_fingerprint = ? LIMIT 1",

         ) { statement in

             bindInt64(sampleTypeID, to: 1, in: statement)

             bindText(row.strictFingerprint, to: 2, in: statement)

         return (id, inserted)

     }

         try optionalInt64(

             "SELECT id FROM samples WHERE sample_type_id = ? AND sample_uuid_hash = ? LIMIT 1",

         ) { statement in

             bindInt64(sampleTypeID, to: 1, in: statement)

             bindText(sampleUUIDHash, to: 2, in: statement)

         deviceID: Int64?,

         metadataID: Int64?,

         observationID: Int64,

     ) throws -> (id: Int64, inserted: Bool) {

         try withStatement(

             """

                 source_revision_id, hk_device_id, metadata_id, created_observation_id

             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

             """,

         ) { statement in

             bindInt64(sampleID, to: 1, in: statement)

             bindText(row.payloadHash, to: 2, in: statement)

         let inserted = sqlite3_changes(db) > 0

         let id = try requiredInt64(

             "SELECT id FROM sample_versions WHERE sample_id = ? AND payload_hash = ? LIMIT 1",

         ) { statement in

             bindInt64(sampleID, to: 1, in: statement)

             bindText(row.payloadHash, to: 2, in: statement)

         eventKind: String,

         evidenceKind: String,

         observedAt: Date,

     ) throws {

         try withStatement(

             """

                 observation_id, sample_id, version_id, event_kind, observed_at, evidence_kind

             ) VALUES (?, ?, ?, ?, ?, ?)

             """,

         ) { statement in

             bindInt64(observationID, to: 1, in: statement)

             bindInt64(sampleID, to: 2, in: statement)

         excludingVersionID: Int64?,

         closedAtObservationID: Int64,

         observedAt: Date,

     ) throws {

         let versionPredicate = excludingVersionID == nil

             ? ""

         SET last_observation_id = ?, last_seen_at = ?

         WHERE sample_id = ? AND last_observation_id IS NULL \(versionPredicate)

         """

             bindInt64(closedAtObservationID, to: 1, in: statement)

             sqlite3_bind_double(statement, 2, observedAt.timeIntervalSince1970)

             bindInt64(sampleID, to: 3, in: statement)

         versionID: Int64,

         observationID: Int64,

         observedAt: Date,

     ) throws {

         let existing = try optionalInt64(

             """

             WHERE sample_id = ? AND version_id = ? AND last_observation_id IS NULL

             LIMIT 1

             """,

         ) { statement in

             bindInt64(sampleID, to: 1, in: statement)

             bindInt64(versionID, to: 2, in: statement)

                 sample_id, version_id, first_observation_id, last_observation_id, first_seen_at, last_seen_at

             ) VALUES (?, ?, ?, NULL, ?, NULL)

             """,

         ) { statement in

             bindInt64(sampleID, to: 1, in: statement)

             bindInt64(versionID, to: 2, in: statement)

     private func requiredInt64(

         _ sql: String,

         db: OpaquePointer?,

         bind: (OpaquePointer?) throws -> Void

     ) throws -> Int64 {

             throw SQLiteHealthArchiveStoreError.stepFailed("missing required row")

         }

         return value

     private func optionalInt64(

         _ sql: String,

         db: OpaquePointer?,

         bind: (OpaquePointer?) throws -> Void

     ) throws -> Int64? {

             try bind(statement)

             guard sqlite3_step(statement) == SQLITE_ROW else { return nil }

             return sqlite3_column_int64(statement, 0)

         }

     }

         var statement: OpaquePointer?

         guard sqlite3_prepare_v2(db, sql, -1, &statement, nil) == SQLITE_OK else {

             throw SQLiteHealthArchiveStoreError.prepareFailed(lastErrorMessage(db))

 }

 private struct ArchiveSampleRow {

     let sampleUUIDHash: String

     let typeIdentifier: String