| 2026-06-03 | pending | Persist HealthKit capture anchors in SQLite. | A later no-delta attempt still reimported full high-volume types (`Records: 2,646,590`, `WallClock: 45.8s`, Heart Rate `922,521`, Active Energy `346,473`) because incremental anchors were still read from legacy SwiftData `TypeCount`, while the refactored app now chains observations from SQLite. SQLite now stores per-type capture state (`anchor_data`, count, content hash, yearly counts, range) and the import path uses it when legacy `TypeCount` state is missing. Expected signal: the first run after this change may seed anchors; the following no-delta run should report empty HealthKit delta pages instead of full `record_import` counts for large stable types. |

 | 2026-06-03 | pending | Clarify capture mode in record-import diagnostics. | Two full-profile repeated snapshots after SQLite capture-state persistence completed successfully with stable checksum and identical record count (`2,646,613`). The first ran in `6.3s` with `SummedProcessingElapsed: 0.0s`, `SummedInsertElapsed: 0.0s`, `SummedFinalizeElapsed: 2.6s`; the second ran in `6.4s` with `0.0s` processing/insert and `2.7s` finalize. Heart Rate `922,526` and Active Energy `346,478` each completed around `0.2s`, proving the heavy full reimport path was avoided. The report wording still said "`N` samples in 1 anchored segment", which is ambiguous for inherited unchanged summaries; diagnostics now label unchanged empty-delta, delta-apply, and full-import modes explicitly. |

 | 2026-06-03 | pending | Add capture-mode summary to diagnostics. | Repeated full-profile captures rarely produce a perfect no-delta report because at least one metric can change between manual runs. Diagnostic reports now include aggregate `CaptureModes` counts plus per-metric `captureMode`, so comparisons can separate unchanged empty-delta metrics from delta-applied metrics and full imports without manually reading every `record_import` line. Expected signal: stable checksum plus high `unchangedDelta` count and zero summed processing/insert confirms the fast path even when a few metrics changed. |

 ## Current Diagnosis

   identical record count, zero summed processing/insert, and sub-second

   high-volume metric timings are acceptable evidence that the expensive full

   import path was skipped.

 ## Open Issues / Observations

    `CaptureModes`, and high-volume type timings. Treat stable checksum, a high

    `unchangedDelta` count, and zero processing/insert as the main unchanged-path

    signal.

 5. Run a non-chain-start/full-scan benchmark after skipping unchanged `verified` events and fast-pathing already-open visibility ranges. Compare `SummedInsertElapsed`, `Heart Rate insertElapsed`, `Steps insertElapsed`, and `Walking + Running Distance insertElapsed`.

 6. Reduce any remaining per-sample SQLite writes for unchanged existing samples during non-chain-start full scans.

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

             case .unchangedDelta:

                 return "\(distribution.totalCount) unchanged samples via empty HealthKit delta"

             case .delta:

             case .initialImport:

                 return "\(distribution.totalCount) samples from full HealthKit import"

             }

             recordArchiveData: recordArchiveData

         )

         result.captureMode = distribution.captureMode.diagnosticValue

         result.timingBreakdown = timingBreakdown

         await persistTypeCaptureState(from: result, observationID: archiveObservationID)

         return result

                     yearlyCounts: unchanged.yearlyCounts,

                     recordArchiveData: unchanged.recordArchiveData,

                     captureMode: .unchangedDelta,

                     timingBreakdown: captureTimings.importBreakdown

                 )

             }

                 yearlyCounts: nil,

                 recordArchiveData: nil,

                 captureMode: .initialImport,

                 timingBreakdown: captureTimings.importBreakdown

             )

         }

             yearlyCounts: nil,

             recordArchiveData: nil,

             captureMode: .delta,

             timingBreakdown: captureTimings.importBreakdown

         )

     }

                 yearlyCounts: nil,

                 recordArchiveData: nil,

                 captureMode: .initialImport,

                 timingBreakdown: captureTimings.importBreakdown

             )

         }

             yearlyCounts: yearMap,

             recordArchiveData: recordArchiveData,

             captureMode: .initialImport,

             timingBreakdown: captureTimings.importBreakdown

         )

     }

     let yearlyCounts: [Int: Int]?

     let recordArchiveData: Data?

     let captureMode: CaptureMode

     let timingBreakdown: ImportTimingBreakdown

 }

             yearlyCounts: yearlyCounts,

             recordArchiveData: recordArchiveData,

             captureMode: .unchangedDelta,

             timingBreakdown: .zero

         )

     }

     let records: [RecordData]

     let recordArchiveData: Data?

     var captureMode: String = "unavailable"

     var timeoutConfiguredSeconds: TimeInterval = 0

     var totalElapsedSeconds: TimeInterval = 0

     var timeoutMode: String = "default"

             timeoutCount: result.timeoutCount,

             successCount: result.successCount,

             timingBreakdown: result.timingBreakdown,

         )

     }

         var successCount: Int = 0

         var timingBreakdown: ImportTimingBreakdown = .zero

         var captureMode: String = "unavailable"

         var blockProgress: String = ""

         var blockElapsedSeconds: TimeInterval = 0

         var blockSamplesPerSecond: Double = 0

         timeoutCount: Int,

         successCount: Int,

         timingBreakdown: ImportTimingBreakdown,

     ) {

         let index = visibleTypeIndex(for: id)

         types[index].quality = quality

         types[index].successCount = successCount

         types[index].timingBreakdown = timingBreakdown

         types[index].captureMode = captureMode

     }

     func updateTimeoutProfile(

         }

         let captureModeCounts = Dictionary(grouping: progress.types, by: \.captureMode)

             .mapValues(\.count)

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

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

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

         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("")

         lines.append(failedLines)

             lines.append("  quality: \(type.quality)")

             lines.append("  count: \(type.recordCount)")

             lines.append("  captureMode: \(type.captureMode)")

             lines.append("  timeoutMode: \(type.timeoutMode)")

             lines.append("  timeoutConfigured: \(formatDuration(type.timeoutConfiguredSeconds))")

             lines.append("  lastSuccessfulElapsed: \(type.lastSuccessfulElapsed > 0 ? formatDuration(type.lastSuccessfulElapsed) : "none")")