Add large import benchmark harness · 01414eb

Add large import benchmark harness
Browse files

bogdan committed a day ago

main

1 parent 36d0904

commit 01414eb

Showing 4 changed files with 243 additions and 1 deletions

+11 -0

HealthProbe/Doc/02-architecture/Implementation-Guide.md

@@ -392,9 +392,20 @@ Integration tests:
 - export generation with manifest hashes
 - high-frequency capture memory/performance
 - deletion evidence via `HKDeletedObject`
+- opt-in large synthetic full-import benchmark for SQLite archive write/finalize cost
 
 Synthetic fixtures only. No real health values or identifiable metadata.
 
+Large-import benchmark policy:
+- keep one opt-in XCTest benchmark for a synthetic full import into SQLite;
+- measure at least `XCTClockMetric` and `XCTMemoryMetric`;
+- enable it only with explicit environment variables or launch arguments so
+  normal test runs stay fast;
+- use it to compare archive write/finalize regressions between commits, not to
+  prove end-to-end HealthKit device performance by itself;
+- combine it with real-device diagnostic reports before declaring background
+  import safe on large live datasets.
+
 ## 11. Performance Considerations
 
 | Operation | Target | Notes |


+2 -1

HealthProbe/Doc/04-project/IMPLEMENTATION_STATUS.md

View

@@ -27,7 +27,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 | 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, persists large HealthKit pages in smaller archive chunks while using type-specific import strategies, and has an expanded HealthKit type registry for full-dataset discovery while keeping the original 15-type profile as the tested default | Run full dataset discovery/coverage on real devices before declaring import/storage complete; then revisit full checkpoint/resume and background collection |
-| 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, the hot write path now reuses prepared SQLite statements within grouped page writes instead of reparsing the same SQL for every sample, caches repeated sample-type/source/source-revision/device/metadata id lookups within grouped writes, skips redundant visibility close/existence checks when grouped imports create a brand-new sample or payload version, skips follow-up id lookup queries when SQLite confirms new sample/sample-version inserts, reuses verification aggregates instead of rescanning them twice, drives per-type finalize queries from sample-type-filtered sample ids, processes sample rows in a lower-allocation streaming loop, batches same-page deleted-object evidence in one transaction, adds composite indexes for visibility-range and sample-uuid hot lookups, and opens SQLite connections with import-friendly busy timeout / synchronous / temp-store pragmas | Continue moving capture/Dashboard actions to archive/cache DTOs |
+| 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, XCTest coverage, and an opt-in large synthetic full-import benchmark are in place; the legacy `archive_samples` mirror has been removed, the hot write path now reuses prepared SQLite statements within grouped page writes instead of reparsing the same SQL for every sample, caches repeated sample-type/source/source-revision/device/metadata id lookups within grouped writes, skips redundant visibility close/existence checks when grouped imports create a brand-new sample or payload version, skips follow-up id lookup queries when SQLite confirms new sample/sample-version inserts, reuses verification aggregates instead of rescanning them twice, drives per-type finalize queries from sample-type-filtered sample ids, processes sample rows in a lower-allocation streaming loop, batches same-page deleted-object evidence in one transaction, adds composite indexes for visibility-range and sample-uuid hot lookups, and opens SQLite connections with import-friendly busy timeout / synchronous / temp-store pragmas | Continue moving capture/Dashboard actions 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. 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 |
@@ -63,6 +63,7 @@ Import performance iterations and measured reports live in [`Import-Optimization
   the full HealthKit-accessible dataset.
 - 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 SQLite archive tests now also include a small always-on synthetic large-import smoke test plus an opt-in full-import benchmark to track archive write/finalize regressions without real HealthKit data.
 - Initial Core Data cache tests cover full rebuild from SQLite and delete-cache-then-rebuild without losing archive data.
 
 ## Verification Checklist


+28 -0

HealthProbe/Doc/04-project/Import-Optimization-Log.md

View

+                     - progress rates shown during import may overestimate throughput if overhead is not included;
+                     - compare first snapshots only against first snapshots after a database reset.
+                    +## Benchmark Harness
+                    +The repo now keeps one opt-in XCTest benchmark for synthetic large full imports:
+                    +- test: `SQLiteLargeImportPerformanceTests.testLargeSyntheticFullImportBenchmark`
+                    +- enable with:
+                    +  `HP_ENABLE_LARGE_IMPORT_BENCHMARK=1` or
+                    +  `-HP_ENABLE_LARGE_IMPORT_BENCHMARK YES`
+                    +- optional tuning:
+                    +  `HP_LARGE_IMPORT_SAMPLE_COUNT=<count>`,
+                    +  `HP_LARGE_IMPORT_ITERATIONS=<count>`, or matching launch arguments
+                    +  (`-HP_LARGE_IMPORT_SAMPLE_COUNT <count>`,
+                    +  `-HP_LARGE_IMPORT_ITERATIONS <count>`)
+                    +- metrics: `XCTClockMetric` and `XCTMemoryMetric`
+                    +To keep the path from drifting, the same test file also contains a small
+                    +always-on smoke case:
+                    +- test: `SQLiteLargeImportPerformanceTests.testLargeSyntheticFullImportSmoke`
+                    +- purpose: prove the archive can still complete a synthetic first-import flow in
+                    +  normal CI/test runs even when the heavier benchmark stays disabled
+                    +Interpretation rules:
+                    +- this benchmark measures SQLite archive write/finalize cost, not real HealthKit
+                    +  fetch latency or device authorization behavior;
+                    +- it is the repeatable regression gate for "can the archive still ingest a very
+                    +  large first import with bounded time/memory?";
+                    +- a background-import decision still needs one clean real-device full-import
+                    +  report from the large database device in addition to this synthetic benchmark.
+                     ## Real-Device Results
+                     ### 2026-06-02 Baseline Before Latest Batch/Chunk Work

+202 -0

HealthProbeTests/SQLiteLargeImportPerformanceTests.swift

View

+                    +import HealthKit
+                    +import SQLite3
+                    +import XCTest
+                    +@testable import HealthProbe
+                    +final class SQLiteLargeImportPerformanceTests: XCTestCase {
+                    +    private final class AsyncResultBox<T>: @unchecked Sendable {
+                    +        var result: Result<T, Error>?
+                    +    }
+                    +    private var temporaryDirectory: URL!
+                    +    override func setUpWithError() throws {
+                    +        temporaryDirectory = FileManager.default.temporaryDirectory
+                    +            .appending(path: "HealthProbeLargeImportTests-\(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 testLargeSyntheticFullImportSmoke() throws {
+                    +        let definitions = syntheticImportDefinitions()
+                    +        let samples = makeSyntheticImportSamples(totalCount: 5_000, definitions: definitions)
+                    +        let url = databaseURL(named: "LargeImportSmoke-\(UUID().uuidString).sqlite")
+                    +        try runSyntheticImport(
+                    +            samples: samples,
+                    +            definitions: definitions,
+                    +            databaseURL: url
+                    +        )
+                    +    }
+                    +    func testLargeSyntheticFullImportBenchmark() throws {
+                    +        let environment = ProcessInfo.processInfo.environment
+                    +        let defaults = UserDefaults.standard
+                    +        let isEnabled = environment["HP_ENABLE_LARGE_IMPORT_BENCHMARK"] == "1"
+                    +            || defaults.bool(forKey: "HP_ENABLE_LARGE_IMPORT_BENCHMARK")
+                    +        guard isEnabled else {
+                    +            throw XCTSkip("""
+                    +            Large import benchmark is opt-in. Run with environment variable \
+                    +            HP_ENABLE_LARGE_IMPORT_BENCHMARK=1 or launch argument \
+                    +            -HP_ENABLE_LARGE_IMPORT_BENCHMARK YES, plus optional \
+                    +            HP_LARGE_IMPORT_SAMPLE_COUNT / HP_LARGE_IMPORT_ITERATIONS overrides.
+                    +            """)
+                    +        }
+                    +        let sampleCount = max(
+                    +            1_000,
+                    +            Int(environment["HP_LARGE_IMPORT_SAMPLE_COUNT"] ?? "")
+                    +                ?? defaults.integer(forKey: "HP_LARGE_IMPORT_SAMPLE_COUNT").nonZero
+                    +                ?? 250_000
+                    +        )
+                    +        let iterationCount = max(
+                    +            1,
+                    +            Int(environment["HP_LARGE_IMPORT_ITERATIONS"] ?? "")
+                    +                ?? defaults.integer(forKey: "HP_LARGE_IMPORT_ITERATIONS").nonZero
+                    +                ?? 1
+                    +        )
+                    +        let definitions = syntheticImportDefinitions()
+                    +        let samples = makeSyntheticImportSamples(totalCount: sampleCount, definitions: definitions)
+                    +        let options = XCTMeasureOptions()
+                    +        options.iterationCount = iterationCount
+                    +        measure(metrics: [XCTClockMetric(), XCTMemoryMetric()], options: options) {
+                    +            let url = databaseURL(named: "LargeImport-\(UUID().uuidString).sqlite")
+                    +            do {
+                    +                try runSyntheticImport(
+                    +                    samples: samples,
+                    +                    definitions: definitions,
+                    +                    databaseURL: url
+                    +                )
+                    +            } catch {
+                    +                XCTFail("Large synthetic import benchmark failed: \(error)")
+                    +            }
+                    +        }
+                    +    }
+                    +    private func databaseURL(named name: String) -> URL {
+                    +        temporaryDirectory.appending(path: name)
+                    +    }
+                    +    private func syntheticImportDefinitions() -> [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)] {
+                    +        [
+                    +            (HKQuantityType.quantityType(forIdentifier: .heartRate)!, HKUnit.count().unitDivided(by: .minute()), 55),
+                    +            (HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned)!, .kilocalorie(), 1.5),
+                    +            (HKQuantityType.quantityType(forIdentifier: .basalEnergyBurned)!, .kilocalorie(), 1.1),
+                    +            (HKQuantityType.quantityType(forIdentifier: .stepCount)!, .count(), 12),
+                    +            (HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning)!, .meter(), 8)
+                    +        ]
+                    +    }
+                    +    private func makeSyntheticImportSamples(
+                    +        totalCount: Int,
+                    +        definitions: [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)]
+                    +    ) -> [HKQuantitySample] {
+                    +        return (0..<totalCount).map { index in
+                    +            let definition = definitions[index % definitions.count]
+                    +            let value = definition.baseline + Double(index % 17)
+                    +            let start = Date(timeIntervalSince1970: 10_000 + Double(index * 60))
+                    +            let end = start.addingTimeInterval(definition.sampleType.identifier == HKQuantityTypeIdentifier.heartRate.rawValue ? 5 : 60)
+                    +            let quantity = HKQuantity(unit: definition.unit, doubleValue: value)
+                    +            return HKQuantitySample(type: definition.sampleType, quantity: quantity, start: start, end: end)
+                    +        }
+                    +    }
+                    +    private func runSyntheticImport(
+                    +        samples: [HKQuantitySample],
+                    +        definitions: [(sampleType: HKQuantityType, unit: HKUnit, baseline: Double)],
+                    +        databaseURL url: URL
+                    +    ) throws {
+                    +        let store = SQLiteHealthArchiveStore(databaseURL: url)
+                    +        let observedAt = Date(timeIntervalSince1970: 5_000_000)
+                    +        defer {
+                    +            try? FileManager.default.removeItem(at: url)
+                    +            try? FileManager.default.removeItem(at: URL(fileURLWithPath: url.path + "-shm"))
+                    +            try? FileManager.default.removeItem(at: URL(fileURLWithPath: url.path + "-wal"))
+                    +        }
+                    +        try waitForArchiveOperation {
+                    +            let observationID = try await store.beginObservation(
+                    +                observedAt: observedAt,
+                    +                triggerReason: "benchmarkLargeSyntheticImport",
+                    +                selectedTypeSetHash: "synthetic-large-import"
+                    +            )
+                    +            _ = try await store.upsertSamples(
+                    +                samples,
+                    +                observedAt: observedAt,
+                    +                observationID: observationID
+                    +            )
+                    +            for definition in definitions {
+                    +                _ = try await store.markVerification(
+                    +                    sampleType: definition.sampleType,
+                    +                    verifiedAt: observedAt,
+                    +                    observationID: observationID
+                    +                )
+                    +            }
+                    +            try await store.finishObservation(
+                    +                observationID: observationID,
+                    +                status: "completed",
+                    +                endedAt: observedAt.addingTimeInterval(1)
+                    +            )
+                    +            return ()
+                    +        }
+                    +        XCTAssertEqual(try countRows(in: "samples", at: url), samples.count)
+                    +        XCTAssertEqual(try countRows(in: "sample_versions", at: url), samples.count)
+                    +        XCTAssertEqual(try countRows(in: "observation_type_runs", at: url), definitions.count)
+                    +    }
+                    +    private func waitForArchiveOperation<T>(_ operation: @escaping () async throws -> T) throws -> T {
+                    +        let expectation = expectation(description: "archive operation")
+                    +        let box = AsyncResultBox<T>()
+                    +        Task {
+                    +            do {
+                    +                box.result = .success(try await operation())
+                    +            } catch {
+                    +                box.result = .failure(error)
+                    +            }
+                    +            expectation.fulfill()
+                    +        }
+                    +        wait(for: [expectation], timeout: 120)
+                    +        return try XCTUnwrap(box.result).get()
+                    +    }
+                    +    private func countRows(in tableName: String, at url: URL) throws -> Int {
+                    +        var db: OpaquePointer?
+                    +        guard sqlite3_open_v2(url.path, &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX, nil) == SQLITE_OK else {
+                    +            sqlite3_close(db)
+                    +            XCTFail("Could not open benchmark database")
+                    +            return 0
+                    +        }
+                    +        defer { sqlite3_close(db) }
+                    +        var statement: OpaquePointer?
+                    +        guard sqlite3_prepare_v2(db, "SELECT COUNT(*) FROM \(tableName)", -1, &statement, nil) == SQLITE_OK else {
+                    +            sqlite3_finalize(statement)
+                    +            XCTFail("Could not prepare benchmark count query")
+                    +            return 0
+                    +        }
+                    +        defer { sqlite3_finalize(statement) }
+                    +        guard sqlite3_step(statement) == SQLITE_ROW else {
+                    +            return 0
+                    +        }
+                    +        return Int(sqlite3_column_int(statement, 0))
+                    +    }
+                    +}
+                    +private extension Int {
+                    +    var nonZero: Int? {
+                    +        self == 0 ? nil : self
+                    +    }
+                    +}

	@@ -392,9 +392,20 @@ Integration tests:
392	392	- export generation with manifest hashes
393	393	- high-frequency capture memory/performance
394	394	- deletion evidence via `HKDeletedObject`
	395	+- opt-in large synthetic full-import benchmark for SQLite archive write/finalize cost
395	396
396	397	Synthetic fixtures only. No real health values or identifiable metadata.
397	398
	399	+Large-import benchmark policy:
	400	+- keep one opt-in XCTest benchmark for a synthetic full import into SQLite;
	401	+- measure at least `XCTClockMetric` and `XCTMemoryMetric`;
	402	+- enable it only with explicit environment variables or launch arguments so
	403	+ normal test runs stay fast;
	404	+- use it to compare archive write/finalize regressions between commits, not to
	405	+ prove end-to-end HealthKit device performance by itself;
	406	+- combine it with real-device diagnostic reports before declaring background
	407	+ import safe on large live datasets.
	408	+
398	409	## 11. Performance Considerations
399	410
400	411	\| Operation \| Target \| Notes \|

	@@ -27,7 +27,7 @@ There are no real deployments, only test installations. Existing prototype datab
27	27	\|------\|----------------\|--------------------\|
28	28	\| Product docs \| Updated \| Keep `HealthProbe/Doc/README.md` as canonical index \|
29	29	\| 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, persists large HealthKit pages in smaller archive chunks while using type-specific import strategies, and has an expanded HealthKit type registry for full-dataset discovery while keeping the original 15-type profile as the tested default \| Run full dataset discovery/coverage on real devices before declaring import/storage complete; then revisit full checkpoint/resume and background collection \|
30		-\| 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, the hot write path now reuses prepared SQLite statements within grouped page writes instead of reparsing the same SQL for every sample, caches repeated sample-type/source/source-revision/device/metadata id lookups within grouped writes, skips redundant visibility close/existence checks when grouped imports create a brand-new sample or payload version, skips follow-up id lookup queries when SQLite confirms new sample/sample-version inserts, reuses verification aggregates instead of rescanning them twice, drives per-type finalize queries from sample-type-filtered sample ids, processes sample rows in a lower-allocation streaming loop, batches same-page deleted-object evidence in one transaction, adds composite indexes for visibility-range and sample-uuid hot lookups, and opens SQLite connections with import-friendly busy timeout / synchronous / temp-store pragmas \| Continue moving capture/Dashboard actions to archive/cache DTOs \|
	30	+\| 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, XCTest coverage, and an opt-in large synthetic full-import benchmark are in place; the legacy `archive_samples` mirror has been removed, the hot write path now reuses prepared SQLite statements within grouped page writes instead of reparsing the same SQL for every sample, caches repeated sample-type/source/source-revision/device/metadata id lookups within grouped writes, skips redundant visibility close/existence checks when grouped imports create a brand-new sample or payload version, skips follow-up id lookup queries when SQLite confirms new sample/sample-version inserts, reuses verification aggregates instead of rescanning them twice, drives per-type finalize queries from sample-type-filtered sample ids, processes sample rows in a lower-allocation streaming loop, batches same-page deleted-object evidence in one transaction, adds composite indexes for visibility-range and sample-uuid hot lookups, and opens SQLite connections with import-friendly busy timeout / synchronous / temp-store pragmas \| Continue moving capture/Dashboard actions to archive/cache DTOs \|
31	31	\| 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 \|
32	32	\| 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` \|
33	33	\| 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 \|
	@@ -63,6 +63,7 @@ Import performance iterations and measured reports live in [`Import-Optimization
63	63	the full HealthKit-accessible dataset.
64	64	- Old prototype database compatibility is no longer required.
65	65	- 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.
	66	+- Initial SQLite archive tests now also include a small always-on synthetic large-import smoke test plus an opt-in full-import benchmark to track archive write/finalize regressions without real HealthKit data.
66	67	- Initial Core Data cache tests cover full rebuild from SQLite and delete-cache-then-rebuild without losing archive data.
67	68
68	69	## Verification Checklist