Phase 6: Performance optimizations, enhanced activity data, and meal card fixes

P1: Parallel HealthKit queries via async let (6 concurrent fetches)
P2: Single-pass TIR zone counting (5-zone) replacing multiple filter passes
P3: Pre-fetch raw data in DataAggregator, cache for cross-component reuse
P4: Binary search for glucose lookups in FoodResponseAnalyzer
P5: Pre-sorted glucose samples with binary search in AdvancedAnalyzers
P6: Pre-compute AGP data in ViewModel instead of SwiftUI view body
P7: Static DateFormatter in LoopInsightsTimeBlock.formatTime
P8: Pre-sort schedule items before dose loops, pre-sort in ViewModel
P9: Pre-convert glucose to parallel arrays avoiding repeated doubleValue calls
P10: Pass precomputed hourly averages to circadian profile builder

Also: enhanced step/activity data in AI prompts with time-of-day breakdowns
and activity-glucose correlation analysis (2h lag), and meal card layout cleanup.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: taylorpatterson-T1D

Loop/Localizable.xcstrings

@@ -629,6 +629,18 @@
         }
       }
     },
+    "%@ [%lld chars]" : {
+      "comment" : "A view that displays a meal with its food type, date, and glucose response. The \"Pre-Meal Advice\" tab in the Loop Insights app uses this view to show individual meal cards.",
+      "isCommentAutoGenerated" : true,
+      "localizations" : {
+        "en" : {
+          "stringUnit" : {
+            "state" : "new",
+            "value" : "%1$@ [%2$lld chars]"
+          }
+        }
+      }
+    },
     "%@ %@" : {
       "comment" : "The format for an active custom preset. (1: preset symbol)(2: preset name)",
       "localizations" : {
@@ -33872,10 +33884,10 @@
     "Review recommended — significant adjustments may help" : {
       "comment" : "LoopInsights score: review"
     },
-    "Rise > 50 mg/dL" : {
+    "Rise is > 50 mg/dL" : {
       "comment" : "LoopInsights meal legend orange"
     },
-    "Rise ≤ 50 mg/dL" : {
+    "Rise is ≤ 50 mg/dL" : {
       "comment" : "LoopInsights meal legend green"
     },
     "Rise: %+.0f mg/dL" : {

Loop/Managers/LoopInsights/LoopInsights_Coordinator.swift

@@ -123,16 +123,19 @@ final class LoopInsights_Coordinator: ObservableObject {
 
     /// Build supplemental context for AI prompt enrichment from Phase 5 analyzers.
     /// Returns nil if no Phase 5 features are enabled.
+    /// P3: Accept pre-fetched glucose + carbs to avoid duplicate data fetches.
+    /// P10: Pass hourly averages to circadian profile builder.
     func buildSupplementalContext(
         stats: LoopInsightsAggregatedStats,
-        glucoseSamples: [StoredGlucoseSample]? = nil
+        glucoseSamples: [StoredGlucoseSample]? = nil,
+        carbEntries: [StoredCarbEntry]? = nil
     ) async -> String? {
         var context: [String] = []
 
         let start = Date().addingTimeInterval(-stats.period.timeInterval)
         let end = Date()
 
-        // Fetch glucose samples once if not provided
+        // P3: Use pre-fetched glucose, fall back to bridge only if not provided
         var resolvedGlucose: [StoredGlucoseSample]? = glucoseSamples
         if resolvedGlucose == nil, let bridge = dataProviderBridge {
             resolvedGlucose = try? await bridge.getGlucoseSamples(start: start, end: end)
@@ -142,9 +145,11 @@ final class LoopInsights_Coordinator: ObservableObject {
         if LoopInsights_FeatureFlags.circadianEnabled {
             // Circadian profile from glucose + sleep data
             if let samples = resolvedGlucose {
+                // P10: Pass pre-computed hourly averages to avoid re-bucketing
                 if let profile = LoopInsights_AdvancedAnalyzers.buildCircadianProfile(
                     glucoseSamples: samples,
-                    sleepStats: stats.biometricStats?.sleep
+                    sleepStats: stats.biometricStats?.sleep,
+                    precomputedHourlyAverages: stats.glucoseStats.hourlyAverages
                 ) {
                     context.append(LoopInsights_AdvancedAnalyzers.buildCircadianPromptContext(profile))
                 }
@@ -163,11 +168,14 @@ final class LoopInsights_Coordinator: ObservableObject {
 
         // Food response patterns
         if LoopInsights_FeatureFlags.foodResponseEnabled {
-            if let bridge = dataProviderBridge,
-               let carbEntries = try? await bridge.getCarbEntries(start: start, end: end),
-               let glucSamples = resolvedGlucose {
+            // P3: Use pre-fetched carbs, fall back to bridge only if not provided
+            var resolvedCarbs: [StoredCarbEntry]? = carbEntries
+            if resolvedCarbs == nil, let bridge = dataProviderBridge {
+                resolvedCarbs = try? await bridge.getCarbEntries(start: start, end: end)
+            }
+            if let carbs = resolvedCarbs, let glucSamples = resolvedGlucose {
                 let patterns = LoopInsights_FoodResponseAnalyzer.analyzeFoodResponses(
-                    carbEntries: carbEntries,
+                    carbEntries: carbs,
                     glucoseSamples: glucSamples
                 )
                 let foodCtx = LoopInsights_FoodResponseAnalyzer.buildFoodResponsePromptContext(patterns)

Loop/Models/LoopInsights/LoopInsights_Models.swift

@@ -531,15 +531,17 @@ struct LoopInsightsTimeBlock: Codable, Identifiable, Equatable {
         return ((proposedValue - currentValue) / currentValue) * 100
     }
 
-    private static func formatTime(_ seconds: TimeInterval) -> String {
-        let hours = Int(seconds) / 3600
-        let minutes = (Int(seconds) % 3600) / 60
+    private static let timeFormatter: DateFormatter = {
         let formatter = DateFormatter()
-        formatter.dateFormat = hours >= 12 ? "h:mm a" : "h:mm a"
+        formatter.dateFormat = "h:mm a"
+        return formatter
+    }()
+
+    private static func formatTime(_ seconds: TimeInterval) -> String {
         var calendar = Calendar.current
         calendar.timeZone = TimeZone.current
         let date = calendar.startOfDay(for: Date()).addingTimeInterval(seconds)
-        return formatter.string(from: date)
+        return timeFormatter.string(from: date)
     }
 }
 
@@ -682,6 +684,7 @@ struct LoopInsightsAggregatedStats: Codable {
 
     struct ActiveEnergyStats: Codable {
         let averageDailyCalories: Double
+        let hourlyAverages: [Int: Double]     // hour → avg kcal burned
     }
 
     struct WeightStats: Codable {

Loop/Services/LoopInsights/LoopInsights_AIAnalysis.swift

@@ -322,6 +322,44 @@ final class LoopInsights_AIAnalysis {
             if let steps = bio.steps {
                 prompt += "### Steps/Activity\n"
                 prompt += "- Average Daily Steps: \(String(format: "%.0f", steps.averageDailySteps))\n"
+                if !steps.hourlyAverages.isEmpty {
+                    // Group into time-of-day activity levels
+                    let activityPeriods: [(name: String, hours: ClosedRange<Int>)] = [
+                        ("Morning 6-10AM", 6...9), ("Midday 10AM-2PM", 10...13),
+                        ("Afternoon 2-6PM", 14...17), ("Evening 6-10PM", 18...21)
+                    ]
+                    for period in activityPeriods {
+                        let periodSteps = period.hours.compactMap { steps.hourlyAverages[$0] }
+                        if !periodSteps.isEmpty {
+                            let total = periodSteps.reduce(0, +)
+                            prompt += "- \(period.name): \(String(format: "%.0f", total)) avg steps\n"
+                        }
+                    }
+                    // Peak activity hour
+                    if let peakHour = steps.hourlyAverages.max(by: { $0.value < $1.value }) {
+                        prompt += "- Peak activity hour: \(String(format: "%02d", peakHour.key)):00 (\(String(format: "%.0f", peakHour.value)) steps)\n"
+                    }
+
+                    // Activity-glucose correlation: compare high-activity hours to glucose
+                    let glucoseHourly = stats.glucoseStats.hourlyAverages
+                    if !glucoseHourly.isEmpty {
+                        var correlations: [String] = []
+                        let avgGlucose = stats.glucoseStats.averageGlucose
+                        for (hour, stepCount) in steps.hourlyAverages where stepCount > 200 {
+                            let postActivityHour = (hour + 2) % 24
+                            if let postGlucose = glucoseHourly[postActivityHour] {
+                                let delta = postGlucose - avgGlucose
+                                if abs(delta) > 10 {
+                                    correlations.append("Activity at \(String(format: "%02d", hour)):00 → glucose \(delta > 0 ? "+" : "")\(String(format: "%.0f", delta)) mg/dL vs avg at \(String(format: "%02d", postActivityHour)):00")
+                                }
+                            }
+                        }
+                        if !correlations.isEmpty {
+                            prompt += "- **Activity-Glucose Correlations (2h lag)**:\n"
+                            for c in correlations.prefix(5) { prompt += "  - \(c)\n" }
+                        }
+                    }
+                }
             }
 
             if let sleep = bio.sleep {
@@ -334,6 +372,19 @@ final class LoopInsights_AIAnalysis {
             if let energy = bio.activeEnergy {
                 prompt += "### Active Energy\n"
                 prompt += "- Average Daily Active Calories: \(String(format: "%.0f", energy.averageDailyCalories)) kcal\n"
+                if !energy.hourlyAverages.isEmpty {
+                    let activityPeriods: [(name: String, hours: ClosedRange<Int>)] = [
+                        ("Morning 6-10AM", 6...9), ("Midday 10AM-2PM", 10...13),
+                        ("Afternoon 2-6PM", 14...17), ("Evening 6-10PM", 18...21)
+                    ]
+                    for period in activityPeriods {
+                        let periodKcal = period.hours.compactMap { energy.hourlyAverages[$0] }
+                        if !periodKcal.isEmpty {
+                            let total = periodKcal.reduce(0, +)
+                            prompt += "- \(period.name): \(String(format: "%.0f", total)) avg kcal\n"
+                        }
+                    }
+                }
             }
 
             if let weight = bio.weight {

Loop/Services/LoopInsights/LoopInsights_AdvancedAnalyzers.swift

@@ -19,14 +19,14 @@ final class LoopInsights_AdvancedAnalyzers {
 
     /// Build a circadian glucose profile using sleep data and glucose samples.
     /// Uses actual wake/bed times from HealthKit sleep data when available.
+    /// P10: Accept optional pre-computed hourlyAverages to avoid re-bucketing glucose
     static func buildCircadianProfile(
         glucoseSamples: [StoredGlucoseSample],
-        sleepStats: LoopInsightsAggregatedStats.SleepStats?
+        sleepStats: LoopInsightsAggregatedStats.SleepStats?,
+        precomputedHourlyAverages: [Int: Double]? = nil
     ) -> LoopInsightsCircadianProfile? {
         guard !glucoseSamples.isEmpty else { return nil }
 
-        let calendar = Calendar.current
-
         // Determine wake/bed hours from sleep data or use defaults
         let wakeHour: Int
         let bedHour: Int
@@ -38,31 +38,37 @@ final class LoopInsights_AdvancedAnalyzers {
             bedHour = 22
         }
 
-        // Bucket glucose by hour
-        var hourlyBuckets: [Int: [Double]] = [:]
-        for sample in glucoseSamples {
-            let hour = calendar.component(.hour, from: sample.startDate)
-            let value = sample.quantity.doubleValue(for: .milligramsPerDeciliter)
-            hourlyBuckets[hour, default: []].append(value)
-        }
-
-        let hourlyAvg: (Int) -> Double = { hour in
-            guard let vals = hourlyBuckets[hour], !vals.isEmpty else { return 0 }
-            return vals.reduce(0, +) / Double(vals.count)
+        // P10: Reuse pre-computed hourly averages when available
+        let hourlyAvg: (Int) -> Double
+        if let precomputed = precomputedHourlyAverages {
+            hourlyAvg = { hour in precomputed[hour] ?? 0 }
+        } else {
+            let calendar = Calendar.current
+            var hourlyBuckets: [Int: [Double]] = [:]
+            for sample in glucoseSamples {
+                let hour = calendar.component(.hour, from: sample.startDate)
+                let value = sample.quantity.doubleValue(for: .milligramsPerDeciliter)
+                hourlyBuckets[hour, default: []].append(value)
+            }
+            hourlyAvg = { hour in
+                guard let vals = hourlyBuckets[hour], !vals.isEmpty else { return 0 }
+                return vals.reduce(0, +) / Double(vals.count)
+            }
         }
 
         // Pre-sleep: hour before bed
         let preSleepHour = (bedHour - 1 + 24) % 24
         let preSleepAvg = hourlyAvg(preSleepHour)
 
-        // Overnight: bed to wake
-        var overnightValues: [Double] = []
+        // Overnight: bed to wake (use hourlyAvg function to work with both precomputed and bucketed data)
+        var overnightHourAvgs: [Double] = []
         var h = bedHour
         while h != wakeHour {
-            if let vals = hourlyBuckets[h] { overnightValues.append(contentsOf: vals) }
+            let avg = hourlyAvg(h)
+            if avg > 0 { overnightHourAvgs.append(avg) }
             h = (h + 1) % 24
         }
-        let overnightAvg = overnightValues.isEmpty ? 0 : overnightValues.reduce(0, +) / Double(overnightValues.count)
+        let overnightAvg = overnightHourAvgs.isEmpty ? 0 : overnightHourAvgs.reduce(0, +) / Double(overnightHourAvgs.count)
 
         // Wake glucose
         let wakeGlucose = hourlyAvg(wakeHour)
@@ -132,6 +138,12 @@ final class LoopInsights_AdvancedAnalyzers {
 
         let totalMinutes = Double(periodDays) * 24 * 60
 
+        // P8: Pre-sort schedule items once instead of per-dose
+        let sortedBasalItems = scheduledBasalItems.sorted { $0.startTime < $1.startTime }
+
+        // P5: Sort glucose samples by date for binary search overcorrection lookups
+        let sortedGlucose = glucoseSamples.sorted { $0.startDate < $1.startDate }
+
         for dose in doses {
             let durationMinutes = dose.endDate.timeIntervalSince(dose.startDate) / 60
             let hour = calendar.component(.hour, from: dose.startDate)
@@ -141,16 +153,23 @@ final class LoopInsights_AdvancedAnalyzers {
                 totalSuspensionMinutes += durationMinutes
                 hourlyDistribution[hour, default: 0] += durationMinutes
 
-                // Check for overcorrection: glucose > 180 within 2h after suspension ends
-                let checkWindow = dose.endDate...dose.endDate.addingTimeInterval(2 * 3600)
-                let reboundHigh = glucoseSamples.contains { sample in
-                    checkWindow.contains(sample.startDate) &&
-                    sample.quantity.doubleValue(for: .milligramsPerDeciliter) > 180
+                // P5: Binary search for overcorrection check instead of linear scan
+                let checkStart = dose.endDate
+                let checkEnd = dose.endDate.addingTimeInterval(2 * 3600)
+                let startIdx = Self.binarySearchFirstIndex(in: sortedGlucose, afterOrAt: checkStart)
+                var reboundHigh = false
+                for i in startIdx..<sortedGlucose.count {
+                    let sample = sortedGlucose[i]
+                    if sample.startDate > checkEnd { break }
+                    if sample.quantity.doubleValue(for: .milligramsPerDeciliter) > 180 {
+                        reboundHigh = true
+                        break
+                    }
                 }
                 if reboundHigh { overcorrectionEvents += 1 }
             } else if dose.type == .tempBasal {
                 let rate = dose.unitsPerHour
-                let scheduledRate = effectiveScheduledRate(at: dose.startDate, items: scheduledBasalItems)
+                let scheduledRate = effectiveScheduledRate(at: dose.startDate, sortedItems: sortedBasalItems)
                 if rate < scheduledRate {
                     let minutes = durationMinutes
                     subBasalMinutes += minutes
@@ -252,18 +271,18 @@ final class LoopInsights_AdvancedAnalyzers {
 
     // MARK: - Helpers
 
+    /// Find the effective scheduled rate at a given date. Expects pre-sorted items (P8).
     private static func effectiveScheduledRate(
         at date: Date,
-        items: [LoopInsightsTherapySnapshot.LoopInsightsScheduleItem]
+        sortedItems: [LoopInsightsTherapySnapshot.LoopInsightsScheduleItem]
     ) -> Double {
         let calendar = Calendar.current
         let secondsSinceMidnight = TimeInterval(
             calendar.component(.hour, from: date) * 3600 +
             calendar.component(.minute, from: date) * 60
         )
-        let sorted = items.sorted { $0.startTime < $1.startTime }
-        var result = sorted.first?.value ?? 0
-        for item in sorted {
+        var result = sortedItems.first?.value ?? 0
+        for item in sortedItems {
             if item.startTime <= secondsSinceMidnight {
                 result = item.value
             } else {
@@ -272,4 +291,21 @@ final class LoopInsights_AdvancedAnalyzers {
         }
         return result
     }
+
+    /// P5: Binary search to find the first glucose sample at or after `date` in a sorted array.
+    static func binarySearchFirstIndex(
+        in samples: [StoredGlucoseSample],
+        afterOrAt date: Date
+    ) -> Int {
+        var lo = 0, hi = samples.count
+        while lo < hi {
+            let mid = (lo + hi) / 2
+            if samples[mid].startDate < date {
+                lo = mid + 1
+            } else {
+                hi = mid
+            }
+        }
+        return lo
+    }
 }