| `WallClockDuration` / `Duration` | User-visible total operation time. |

 | `SummedFetchElapsed` | Time spent fetching HealthKit samples. Per-metric sums may overlap. |

 | `SummedProcessingElapsed` | Time spent converting HealthKit samples into archive rows. |

 | `SummedInsertElapsed` | Time spent writing rows to SQLite. Current main bottleneck. |

 | `SummedFinalizeElapsed` | Type verification, aggregate rebuild, and finalization cost. |

 | Per-type `insertElapsed` | Most useful field for high-volume types such as Heart Rate and Active Energy. |

 | 2026-06-04 | older build / schema v2 | Captured large first-import baseline on a bigger device database. | Initial full-profile snapshot on an older build completed with `127/127` metrics and `8,421,978` records, but it used `reportSchemaVersion: 2` and has no build fingerprint. Treat it as a volume/shape baseline, not a precise current-build comparison. Wall clock was `166m10s`; summed fetch `5m19s`, processing `20m29s`, insert `137m31s`, finalize `1m53s`. The high-volume types dominated: Heart Rate `2,225,738` records and `46m57s` total (`39m16s` insert), Active Energy `1,914,449` records and `41m35s` total (`35m21s` insert), another high-volume type around `2,007,920` records and `41m20s` total (`34m29s` insert), and Basal Energy `1,116,074` records and `21m37s` total (`17m48s` insert). Conclusion: for clean first imports on very large databases, SQLite insert/index/write-path cost remains the central risk; incremental daily-aggregate optimization should not add first-import indexes without measurement. |

 | 2026-06-05 | `6041bac` | Split daily aggregate finalization timings. | The first finalization phase report identified daily aggregate work as the remaining changed-type bottleneck, but `finalizeDailyAggregateElapsed` still mixed affected-bucket lookup, previous aggregate copy, destination delete, affected-bucket rebuild, replacement insert, and residual SQL/transaction overhead. Diagnostics now emit aggregate and per-type daily subphase fields: bucket lookup, copy, delete, rebuild, insert, and other. Follow-up report with `buildFingerprint: 1.0(1)-1780618540-92064` completed in `23.5s`, with `127/127` complete, `CaptureModes: unchangedDelta=118, delta=9`, and `DeltaEvents: 97`. Finalization was `10.5s`, daily aggregate work was `7.4s`, and daily rebuild alone was `6.9s`; daily copy was only `0.5s`. Heart Rate had `40` delta events and spent `4.8s` finalizing, of which `3.8s` was daily aggregate rebuild. Conclusion: copying previous materialized daily rows is not the bottleneck; affected-bucket rebuild scans are. |

 | 2026-06-05 | `bf5a861` | Rebuild changed daily aggregate buckets from time-ranged versions. | Confirmed on two full-profile repeated captures with `buildFingerprint: 1.0(1)-1780640325-92064`. The overnight-data run completed in `21.8s` with `127/127` complete, `CaptureModes: unchangedDelta=111, delta=16`, and `DeltaEvents: 322`; daily aggregate rebuild dropped from `6.9s` to `0.0s`, with daily aggregate work now only `0.6s` copy. The low-delta run completed in `6.6s` with `CaptureModes: unchangedDelta=125, delta=2`; daily aggregate rebuild again stayed `0.0s`. Conclusion: the time-ranged `sample_versions(start_date, sample_id)` query solved the affected-bucket rebuild bottleneck. Continue monitoring first-import insert timing because the new index is a write-path tradeoff. |

 ## Current Diagnosis

   handful of events. The next query shape starts from

   `sample_observation_events(observation_id, event_kind)` and joins to samples

   for type filtering.

 - A large older-build first import on an `8.4M`-record database completed but

   took `166m10s`, with `137m31s` summed insert time. This confirms that full

   authorized backup volume can be much larger than the original 15-type test

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

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

    Xcode test installs.

 9. Keep watching first-import insert timing on the next clean large-database

    import because the new `sample_versions(start_date, sample_id)` index from

    `bf5a861` is a write-path tradeoff.

             let firstPageApplyStartedAt = Date()

             deltaPages.append(firstDeltaPage)

             estimatedRecordCount += firstDeltaPage.samples.count - firstDeltaPage.deletedObjects.count

             processedEventCount += pageEventCount(firstDeltaPage)

             shouldFetchNextPage = firstDeltaPage.samples.count + firstDeltaPage.deletedObjects.count >= incrementalStrategy.queryPageLimit

             progress?.updateBlockProgress(

             let applyStartedAt = Date()

             deltaPages.append(page)

             estimatedRecordCount += page.samples.count - page.deletedObjects.count

             processedEventCount += pageEventCount(page)

             shouldFetchNextPage = page.samples.count + page.deletedObjects.count >= incrementalStrategy.queryPageLimit

             progress?.updateBlockProgress(

             sampleType: sampleType,

             deltaPages: deltaPages

         )

         captureTimings.addFinalization(try await finalizeArchiveVerification(

             sampleType: sampleType,

                     recordCount += 1

                 }

             }

             processedEventCount += pageEventCount(page)

             shouldFetchNextPage = page.samples.count + page.deletedObjects.count >= importStrategy.queryPageLimit

         let finalizeHashStartedAt = Date()

         let contentHash = hashBuilder.finalize()

         progress?.updateBlockProgress(

             typeIdentifier,

             detail: pageNumber == 1 ? "Imported 1 page" : "Imported \(pageNumber) pages",

         let archiveFinalizeStartedAt = Date()

         let recordArchiveData = archiveWriter.finalize()

         return SampleDistribution(

             totalCount: recordCount,

 private struct DistributionCaptureTimings: Sendable, Equatable {

     var fetchElapsedSeconds: TimeInterval = 0

     var processingElapsedSeconds: TimeInterval = 0

     var insertElapsedSeconds: TimeInterval = 0

     var finalizeElapsedSeconds: TimeInterval = 0

     var finalizeEventCountElapsedSeconds: TimeInterval = 0

         ImportTimingBreakdown(

             fetchElapsedSeconds: fetchElapsedSeconds,

             processingElapsedSeconds: processingElapsedSeconds,

             insertElapsedSeconds: insertElapsedSeconds,

             finalizeElapsedSeconds: finalizeElapsedSeconds,

             finalizeEventCountElapsedSeconds: finalizeEventCountElapsedSeconds,

 struct ImportTimingBreakdown: Sendable, Equatable {

     var fetchElapsedSeconds: TimeInterval = 0

     var processingElapsedSeconds: TimeInterval = 0

     var insertElapsedSeconds: TimeInterval = 0

     var finalizeElapsedSeconds: TimeInterval = 0

     var finalizeEventCountElapsedSeconds: TimeInterval = 0

         fetchElapsedSeconds + processingElapsedSeconds + insertElapsedSeconds + finalizeElapsedSeconds

     }

     var finalizeAccountedElapsedSeconds: TimeInterval {

         finalizeEventCountElapsedSeconds

         + finalizeTypeSummaryElapsedSeconds

             var combined = partial

             combined.fetchElapsedSeconds += type.timingBreakdown.fetchElapsedSeconds

             combined.processingElapsedSeconds += type.timingBreakdown.processingElapsedSeconds

             combined.insertElapsedSeconds += type.timingBreakdown.insertElapsedSeconds

             combined.finalizeElapsedSeconds += type.timingBreakdown.finalizeElapsedSeconds

             combined.finalizeEventCountElapsedSeconds += type.timingBreakdown.finalizeEventCountElapsedSeconds

         lines.append("SummedMetricTotalElapsed: \(formatDuration(summedMetricTotalElapsed))")

         lines.append("SummedFetchElapsed: \(formatDuration(aggregateTiming.fetchElapsedSeconds))")

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

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

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

         if aggregateTiming.finalizeAccountedElapsedSeconds > 0 {

             lines.append("  totalElapsed: \(formatDuration(type.totalElapsedSeconds))")

             lines.append("  fetchElapsed: \(formatDuration(type.timingBreakdown.fetchElapsedSeconds))")

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

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

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

             if type.timingBreakdown.finalizeAccountedElapsedSeconds > 0 {