| 2026-06-04 | `1ba6c38` | Hash delta compact archives in recorded order. | Small-delta follow-up completed in `24.0s` with `127/127` complete, `0` degraded, `CaptureModes: unchangedDelta=124, delta=3, initialImport=0`, and `DeltaEvents: 13`. This finally validated the remaining bottleneck: Heart Rate still spent `5.7s` processing only `6` events, Active Energy spent `2.1s` for `5` events, and Basal Energy spent `1.8s` for `2` events. The delta rebuild no longer builds a full UUID record map, but it still collected every fingerprint into a large array and sorted it for the per-type hash. Delta rebuild now uses the same recorded-order `TypeHashBuilder` strategy as initial import, avoiding the all-record fingerprint array and sort. |

 | 2026-06-04 | `d4de48c` | Copy unchanged daily aggregates inside SQLite. | First small-delta run before this commit completed in `23.6s` with `127/127` complete, `0` degraded, `CaptureModes: unchangedDelta=120, delta=7`, and `DeltaEvents: 11`. The hash change helped processing (`9.6s -> 8.1s`; Heart Rate `5.7s -> 4.2s`), but finalization stayed high (`11.4s`, Heart Rate `4.8s`). Changed daily aggregates were copying all previous daily rows through Swift before replacing affected buckets. This commit moved unchanged daily aggregate copying to SQLite `INSERT ... SELECT`, while affected buckets remain recalculated. Follow-up report completed in `21.1s` with `127/127` complete, `0` degraded, `CaptureModes: unchangedDelta=123, delta=4`, and `DeltaEvents: 50`. `SummedFinalizeElapsed` improved `11.4s -> 9.3s` and wall clock improved `23.6s -> 21.1s`; however Heart Rate finalize was still `5.0s` with `4` events, so this helped overall finalize cost but did not remove the high-volume changed-type floor. |

 | 2026-06-04 | `c9091de` | Include build identity in diagnostic reports. | The latest diagnostic report only included `App Version: 1.0(1)` near the end and did not include a commit/build source identifier. This makes it too easy to compare reports from the wrong installed binary. Diagnostics now emit `appVersion`, `buildFingerprint`, `sourceCommit`, and `sourceDirty` in `OPERATION METADATA`. `buildFingerprint` is derived from the installed executable and should change when a different binary is installed; `sourceCommit/sourceDirty` remain available for builds that inject those Info.plist keys. Expected signal: future pasted reports have enough build identity to detect wrong-version reports immediately. |

 ## Current Diagnosis

   newer/larger replacement no longer needs a full visible aggregate scan. The

   archive still falls back to the full scan when a removed earliest/latest/max

   leaves the new extreme genuinely unknown.

 ## Open Issues / Observations

    identity unless the build provenance is otherwise certain. `sourceCommit`

    and `sourceDirty` are useful when present, but may be `unknown` for normal

    Xcode test installs.

    Compare slow empty types across reports before changing behavior; any skip or

    lower-frequency strategy must preserve the promise that full authorized

    backup can notice newly appearing data.

    - keep archive semantics unchanged;

    - only relax work that can be safely reconstructed or validated;

    - re-enable normal idempotent paths for incremental observations.

 ## Verification Checklist For Each Optimization

                     earliestDate: earliestDate,

                     latestDate: latestDate

                ) {

                     sampleType: sampleType,

                     typeIdentifier: typeIdentifier,

                     recordCount: unchanged.totalCount,

                     processedEventCount: processedEventCount,

                     archiveObservationID: archiveObservationID,

                     progress: progress

                 progress?.updateBlockProgress(

                     typeIdentifier,

                     detail: "No HealthKit delta",

         )

         captureTimings.processingElapsedSeconds += Date().timeIntervalSince(archiveRebuildStartedAt)

             sampleType: sampleType,

             typeIdentifier: typeIdentifier,

             recordCount: rebuiltArchive.count,

             processedEventCount: processedEventCount,

             archiveObservationID: archiveObservationID,

             progress: progress

         progress?.updateBlockProgress(

             typeIdentifier,

             )

         )

             sampleType: sampleType,

             typeIdentifier: typeIdentifier,

             recordCount: recordCount,

             processedEventCount: processedEventCount,

             archiveObservationID: archiveObservationID,

             progress: progress

         guard recordCount > 0 || anchor != nil else {

             return SampleDistribution(

         processedEventCount: Int,

         archiveObservationID: Int64,

         progress: SnapshotFetchProgress?

         try await finalizeArchiveVerification(

             sampleType: sampleType,

             typeIdentifier: typeIdentifier,

         processedEventCount: Int,

         archiveObservationID: Int64,

         progress: SnapshotFetchProgress?,

         let elapsedBeforeFinalize = Date().timeIntervalSince(progressStarted)

         progress?.updateBlockProgress(

             typeIdentifier,

         )

         let verificationStartedAt = Date()

         if let markVerification {

         } else {

                 sampleType: sampleType,

                 verifiedAt: Date(),

                 observationID: archiveObservationID

             )

         }

         let finalizeElapsed = Date().timeIntervalSince(verificationStartedAt)

         let elapsedAfterFinalize = Date().timeIntervalSince(progressStarted)

         progress?.updateBlockProgress(

             )

         )

     }

     private static func pageProgressDetail(

     var processingElapsedSeconds: TimeInterval = 0

     var insertElapsedSeconds: TimeInterval = 0

     var finalizeElapsedSeconds: TimeInterval = 0

     static let zero = DistributionCaptureTimings()

     var importBreakdown: ImportTimingBreakdown {

         ImportTimingBreakdown(

             fetchElapsedSeconds: fetchElapsedSeconds,

             processingElapsedSeconds: processingElapsedSeconds,

             insertElapsedSeconds: insertElapsedSeconds,

         )

     }

 }

     func upsertTypeCaptureState(_ state: HealthArchiveTypeCaptureState, observationID: Int64) async throws

     func upsertSamples(_ samples: [HKSample], observedAt: Date) async throws -> HealthArchiveWriteSummary

     func upsertSamples(_ samples: [HKSample], observedAt: Date, observationID: Int64) async throws -> HealthArchiveWriteSummary

     func recordDisappearance(sampleUUIDHash: String, sampleTypeIdentifier: String, observedMissingAt: Date) async throws

     func recordDisappearance(sampleUUIDHash: String, sampleTypeIdentifier: String, observedMissingAt: Date, observationID: Int64) async throws

     func recordDisappearances(sampleUUIDHashes: [String], sampleTypeIdentifier: String, observedMissingAt: Date, observationID: Int64) async throws -> Int

     let unchangedCount: Int

 }

 struct HealthArchiveTypeCaptureState: Equatable, Sendable {

     let sampleTypeIdentifier: String

     let observationID: Int64?

         }

     }

         let db = try openDatabase()

         defer { sqlite3_close(db) }

         try prepareSchemaIfNeeded(db)

                 status: "completed",

                 db: db

             )

             try execute("COMMIT", db: db)

         } catch {

             try? execute("ROLLBACK", db: db)

             throw error

         }

     }

         let db = try openDatabase()

         defer { sqlite3_close(db) }

         try prepareSchemaIfNeeded(db)

         try execute("BEGIN IMMEDIATE TRANSACTION", db: db)

         do {

             try execute("COMMIT", db: db)

         } catch {

             try? execute("ROLLBACK", db: db)

             throw error

         }

     }

         let db = try openDatabase()

         defer { sqlite3_close(db) }

         try prepareSchemaIfNeeded(db)

         try execute("BEGIN IMMEDIATE TRANSACTION", db: db)

         do {

                 sampleType: sampleType,

                 verifiedAt: verifiedAt,

                 observationID: observationID,

                 db: db

             )

             try execute("COMMIT", db: db)

         } catch {

             try? execute("ROLLBACK", db: db)

             throw error

         verifiedAt: Date,

         observationID: Int64,

         db: OpaquePointer?

         let statementCache = SQLiteStatementCache(db: db)

         defer { statementCache.finalizeAll() }

         let lookupCache = SQLiteWriteLookupCache()

             statementCache: statementCache,

             lookupCache: lookupCache

         )

         let counts = try eventCounts(observationID: observationID, sampleTypeID: sampleTypeID, db: db)

         let previousSummary = try previousTypeSummary(

             sampleTypeID: sampleTypeID,

             db: db,

             statementCache: statementCache

         )

         if counts.appeared == 0,

            counts.disappeared == 0,

            counts.representationChanged == 0,

            let previousSummary {

             try insertObservationTypeRun(

                 observationID: observationID,

                 sampleTypeID: sampleTypeID,

                 db: db,

                 statementCache: statementCache

             )

             try upsertTypeSummary(

                 observationID: observationID,

                 sampleTypeID: sampleTypeID,

                 aggregate: previousSummary.aggregate,

                 db: db

             )

             try copyDailyAggregates(

                 fromObservationID: previousSummary.observationID,

                 toObservationID: observationID,

                 sampleTypeID: sampleTypeID,

                 db: db

             )

         }

         let aggregate = try incrementalVisibleAggregate(

             previous: previousSummary?.aggregate,

             observationID: observationID,

             db: db

         ) ?? visibleAggregate(sampleTypeID: sampleTypeID, db: db)

         let visibleCount = aggregate.visibleRecordCount

         try insertObservationTypeRun(

             observationID: observationID,

             sampleTypeID: sampleTypeID,

             db: db,

             statementCache: statementCache

         )

         try upsertTypeSummary(

             observationID: observationID,

             sampleTypeID: sampleTypeID,

             aggregate: aggregate,

             db: db

         )

         if let previousSummary,

            try replaceChangedDailyAggregates(

             fromObservationID: previousSummary.observationID,

             observedAt: verifiedAt,

             db: db

            ) {

         }

         try rebuildDailyAggregates(

             observedAt: verifiedAt,

             db: db

         )

     }

     private func markUnchangedVerification(

         verifiedAt: Date,

         observationID: Int64,

         db: OpaquePointer?

         let statementCache = SQLiteStatementCache(db: db)

         defer { statementCache.finalizeAll() }

         let lookupCache = SQLiteWriteLookupCache()

             statementCache: statementCache,

             lookupCache: lookupCache

         )

         guard let previousSummary = try previousTypeSummary(

             sampleTypeID: sampleTypeID,

             beforeObservationID: observationID,

             db: db,

             statementCache: statementCache

         ) else {

                 sampleType: sampleType,

                 verifiedAt: verifiedAt,

                 observationID: observationID,

                 db: db

             )

         }

         try insertObservationTypeRun(

             observationID: observationID,

             sampleTypeID: sampleTypeID,

             db: db,

             statementCache: statementCache

         )

         try upsertTypeSummary(

             observationID: observationID,

             sampleTypeID: sampleTypeID,

             aggregate: previousSummary.aggregate,

             db: db

         )

         try copyDailyAggregates(

             fromObservationID: previousSummary.observationID,

             toObservationID: observationID,

             sampleTypeID: sampleTypeID,

             db: db

         )

     }

     private func recordDisappearance(

     var processingElapsedSeconds: TimeInterval = 0

     var insertElapsedSeconds: TimeInterval = 0

     var finalizeElapsedSeconds: TimeInterval = 0

     static let zero = ImportTimingBreakdown()

     var accountedElapsedSeconds: TimeInterval {

         fetchElapsedSeconds + processingElapsedSeconds + insertElapsedSeconds + finalizeElapsedSeconds

     }

 }

 struct HealthKitAPICallResult: Sendable, Equatable {

             combined.processingElapsedSeconds += type.timingBreakdown.processingElapsedSeconds

             combined.insertElapsedSeconds += type.timingBreakdown.insertElapsedSeconds

             combined.finalizeElapsedSeconds += type.timingBreakdown.finalizeElapsedSeconds

             return combined

         }

     }

         lines.append("SummedProcessingElapsed: \(formatDuration(aggregateTiming.processingElapsedSeconds))")

         lines.append("SummedInsertElapsed: \(formatDuration(aggregateTiming.insertElapsedSeconds))")

         lines.append("SummedFinalizeElapsed: \(formatDuration(aggregateTiming.finalizeElapsedSeconds))")

         lines.append("SummedResidualElapsed: \(formatDuration(summedMetricResidualElapsed))")

         lines.append("CaptureModes: unchangedDelta=\(captureModeCounts["unchangedDelta", default: 0]), delta=\(captureModeCounts["delta", default: 0]), initialImport=\(captureModeCounts["initialImport", default: 0]), unavailable=\(captureModeCounts["unavailable", default: 0])")

         lines.append("DeltaEvents: \(summedDeltaEventCount)")

             lines.append("  processingElapsed: \(formatDuration(type.timingBreakdown.processingElapsedSeconds))")

             lines.append("  insertElapsed: \(formatDuration(type.timingBreakdown.insertElapsedSeconds))")

             lines.append("  finalizeElapsed: \(formatDuration(type.timingBreakdown.finalizeElapsedSeconds))")

             lines.append("  residualElapsed: \(formatDuration(timingResidual(totalElapsed: type.totalElapsedSeconds, breakdown: type.timingBreakdown)))")

             if type.blockElapsedSeconds > 0 {

                 lines.append("  fetchProgressElapsed: \(formatDuration(type.blockElapsedSeconds))")