The larger first-import gain remains attributable to the earlier hot `samples`

 index removal plus clean reset conditions.

 ## Optimization Iterations

 | Date | Commit | Change | Result / Status |

 | 2026-06-02 | `a281c51` | Stopped writing `verified` observation events for unchanged existing samples. | Awaiting comparable non-chain-start/full-scan report. Expected signal is lower `SummedInsertElapsed` and especially lower Heart Rate insert time when most rows are unchanged. |

 | 2026-06-02 | `3dd5f48` | Fortified scheduled test database reset with a disk marker and extra SQLite sidecar cleanup. | Real-device report confirmed reset produced `previousSnapshotID: none`, `isChainStart: true`, and a clean first-snapshot timeline. |

 | 2026-06-02 | `06ee6be` | Removed unused `sample_versions(start_date, end_date)` and redundant `sample_visibility_ranges(sample_id, last_observation_id)` indexes. | Comparable first-import report was flat: wall clock 12m43s -> 12m39s and summed insert 10m11s -> 10m07s. Treat as no material performance change. |

 ## Current Diagnosis

 - index maintenance while importing high-volume rows;

 - multiple dependent writes per sample;

 - commit / transaction shape;

 ## Open Issues / Observations

 - Very small pages reduced freeze risk but introduced visible overhead.

 - Some progress timing displayed in the UI did not include overhead, so elapsed time and rates looked better than the real operation.

 - A previous Heart Rate import appeared to stall for long periods around roughly 900k records, but later progress resumed; avoid classifying this as a hard timeout without report evidence.

 - Partial / old imported observations can pollute comparisons. Fresh first-snapshot performance comparisons should use a confirmed reset database.

 - Non-chain-start full scans can be slower than first imports if unchanged existing samples still write per-sample archive evidence.

 Prioritize experiments in this order:

 2. Run a non-chain-start/full-scan benchmark after skipping unchanged `verified` events and compare `SummedInsertElapsed`, `Heart Rate insertElapsed`, `Steps insertElapsed`, and `Walking + Running Distance insertElapsed`.

 3. Reduce remaining per-sample SQLite writes for unchanged existing samples during non-chain-start full scans, especially open visibility-range existence checks.

 4. Profile whether index maintenance dominates first-import insert cost.

 }

 // Interface updated 2026-05-24 — see AGENTS.md

     static let cacheSchemaVersion = 1

     let container: NSPersistentContainer

     }

 }

     nonisolated static func observationRow(_ object: NSManagedObject) -> CachedArchiveObservationRow {

         CachedArchiveObservationRow(

             observationID: object.value(forKey: "observationID") as? Int64 ?? 0,

     }

 }

     static let cacheEntityNames = [

         "CachedObservationRow",

         "CachedTypeSummary",

     }

 }

     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 {

     }

 }

     guard let message = sqlite3_errmsg(db) else { return "unknown SQLite error" }

     return String(cString: message)

 }

     guard sqlite3_column_type(statement, index) != SQLITE_NULL,

           let pointer = sqlite3_column_text(statement, index) else {

         return nil

     return String(cString: pointer)

 }

     guard sqlite3_column_type(statement, index) != SQLITE_NULL else { return nil }

     return sqlite3_column_double(statement, index)

 }

     guard sqlite3_column_type(statement, index) != SQLITE_NULL else { return nil }

     return sqlite3_column_int64(statement, index)

 }

     columnDouble(statement, index).map { Date(timeIntervalSince1970: $0) }

 }

     private var pendingPartialSnapshotID: UUID?

     private var pendingAmbiguousSnapshotID: UUID?

     func requestAuthorization() async {

         isRequestingAuth = true

         authError = nil

             }

             snapshotProgress = .complete

         } catch is CancellationError {

             snapshotError = "Snapshot creation exceeded the operation timeout. Individual metric timeouts are adaptive; retry failed metrics with an extended timeout when available."

             snapshotProgress = .idle

                 typeIdentifiers: ambiguousIDs,

                 using: healthKit

             )

         } catch {

             snapshotError = "Failed to save reviewed snapshot: \(error.localizedDescription)"

             showProgressSheet = true

         do {

             let outcome = try await LegacySwiftDataBridge.saveReviewedCompleteSnapshot(id: snapshotID, using: healthKit)

         } catch {

             snapshotError = "Failed to save reviewed snapshot: \(error.localizedDescription)"

             showProgressSheet = true

                 monitoredTypeSetHash: outcome.monitoredTypeSetHash,

                 monitoredRegistryVersion: outcome.monitoredRegistryVersion

             )

         } catch {

             snapshotError = "Failed to save partial snapshot: \(error.localizedDescription)"

             showProgressSheet = true

         }

     }

         applyOutcome(outcome)

         pendingAmbiguousSnapshotID = nil

         pendingPartialSnapshotID = nil

         fetchProgress = nil

         showProgressSheet = false

         snapshotProgress = .idle

     }

     private func applyOutcome(_ outcome: LegacySnapshotOutcome) {

         completedSnapshotRetryOfSnapshotID = outcome.retryOfSnapshotID

     }

         do {

             archiveCacheError = nil

         } catch {

             archiveObservationRows = []