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

 | 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 type-specific import strategies: conservative paging for the heaviest metrics, more aggressive pages/chunks for ordinary metrics, adaptive write chunk sizing, batched deleted-object persistence, explicit task yields, and lower-allocation streaming loops to avoid long monolithic SQLite stalls | Continue moving UI/cache reads to archive-backed observation ids and revisit full checkpoint/resume and 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; Settings can now schedule a full test-database reset for the next app launch | Stop writing prototype `HealthSnapshot` bridge rows during capture/review |

     ) throws -> HealthArchiveWriteSummary {

         let statementCache = SQLiteStatementCache(db: db)

         defer { statementCache.finalizeAll() }

         var inserted = 0

         var updated = 0

         var unchanged = 0

                     row,

                     observationID: observationID,

                     db: db,

                 )

             }

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

     ) throws {

         let statementCache = SQLiteStatementCache(db: db)

         defer { statementCache.finalizeAll() }

         let sampleTypeID = try upsertSampleType(

             typeIdentifier: sampleType.identifier,

             db: db,

         )

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

         try insertObservationTypeRun(

     ) throws -> Int {

         let statementCache = SQLiteStatementCache(db: db)

         defer { statementCache.finalizeAll() }

         guard let sampleTypeID = try sampleTypeID(

                 typeIdentifier: sampleTypeIdentifier,

                 db: db,

               ) else {

             return 0

         }

         _ row: ArchiveSampleRow,

         observationID: Int64,

         db: OpaquePointer?,

     ) throws -> ArchiveV2SampleWriteResult {

         let sampleResult = try upsertSample(

             row,

             sampleTypeID: sampleTypeID,

         }

     }

         try withStatement(

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

             db: db,

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

             }

         }

             "SELECT id FROM sample_types WHERE type_identifier = ? LIMIT 1",

             db: db,

             statementCache: statementCache

         ) { statement in

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

         }

     }

             "SELECT id FROM sample_types WHERE type_identifier = ? LIMIT 1",

             db: db,

             statementCache: statementCache

         ) { statement in

             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]) }

         let sourceID = try upsertSource(

             sourceNameHash: sourceNameHash,

             bundleIdentifier: row.sourceBundleIdentifier,

             db: db,

         )

         if let existing = try sourceRevisionID(

             sourceID: sourceID,

             db: db,

             statementCache: statementCache

         ) {

             return existing

         }

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

             }

         }

     }

     private func sourceRevisionID(

         }

     }

         if let existing = try optionalInt64(

             """

             SELECT id FROM sources

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

             }

         ) {

             return existing

         }

         try withStatement(

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(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]) }

         let localIdentifierHash = row.deviceLocalIdentifier.map { HashService.archiveContentHash(domain: "hp:v2:device_local_id", parts: [$0]) }

         let udiHash = row.deviceUDI.map { HashService.archiveContentHash(domain: "hp:v2:device_udi", parts: [$0]) }

         if let existing = try optionalInt64(

             """

                 bindText(row.deviceModel, to: 8, in: statement)

             }

         ) {

             return existing

         }

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(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 (?, ?)",

             db: db,

                 throw SQLiteHealthArchiveStoreError.stepFailed(lastErrorMessage(db))

             }

         }

             "SELECT id FROM metadata_blobs WHERE metadata_hash = ? LIMIT 1",

             db: db,

             statementCache: statementCache

         ) { statement in

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

         }

     }

     private func upsertSample(

     }

 }

 private struct ArchiveSampleRow {

     let sampleUUIDHash: String

     let typeIdentifier: String

         ))

         let report = try await store.checkIntegrity()

         let versionDebugRows = try sampleVersionDebugRows(at: url)

         XCTAssertEqual(firstWrite.insertedCount, 1)

         XCTAssertEqual(firstWrite.updatedCount, 0)

         XCTAssertEqual(firstWrite.unchangedCount, 0)

         XCTAssertEqual(try countRows(in: "samples", at: url), 1)

         XCTAssertEqual(try countRows(in: "sample_versions", at: url), 1, versionDebugRows)

         XCTAssertEqual(try countRows(in: "source_revisions", at: url), 1)

         XCTAssertFalse(try tableExists("archive_samples", at: url))

         XCTAssertEqual(secondWrite.insertedCount, 0)

         }

         return rows.joined(separator: "\n")

     }

 }