Fix sleep duration underreporting: aggregate per day instead of per session

The starter-pack engine averaged sleep duration across individual sessions
(38 sessions / 30 days) instead of grouping by wake date and summing per day.
Naps and short sleep segments (1-3h) dragged the average from 8.27h to 6.97h
(~19% underreported). Also fixed date attribution from start_time to wake date.

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

Author: schwaaamp

supabase/functions/ai-engine/engines/starter-pack.test.ts

@@ -41,27 +41,49 @@ vi.mock('../../_shared/supabaseClient.ts', () => ({
 }));
 
 vi.mock('../../_shared/metric-extraction.ts', () => ({
-  extractDeepSleepPct: (row: Record<string, unknown>) => {
-    const vm = row.vendor_metadata as Record<string, unknown> | null;
-    if (!vm) return null;
-    const deep = vm.deep_minutes;
-    const total = row.total_duration_minutes as number;
-    return deep != null && total > 0 ? ((deep as number) / total) * 100 : null;
-  },
-  extractRemSleepPct: (row: Record<string, unknown>) => {
-    const vm = row.vendor_metadata as Record<string, unknown> | null;
-    if (!vm) return null;
-    const rem = vm.rem_minutes;
-    const total = row.total_duration_minutes as number;
-    return rem != null && total > 0 ? ((rem as number) / total) * 100 : null;
-  },
   extractHrvFromDailySummary: (row: Record<string, unknown>) => {
     const vm = row.vendor_metadata as Record<string, unknown> | null;
     return vm?.hrv_ms != null ? vm.hrv_ms as number : null;
   },
-  extractHrvFromSleepSession: (row: Record<string, unknown>) => {
-    const vm = row.vendor_metadata as Record<string, unknown> | null;
-    return vm?.hrv_ms != null ? vm.hrv_ms as number : null;
+}));
+
+// Mock daily-aggregation to avoid pulling in the full metric-extraction surface.
+// Provides a simplified aggregateSleepByDay that groups by wake date and computes
+// the metrics the starter-pack actually reads.
+vi.mock('../../_shared/daily-aggregation.ts', () => ({
+  aggregateSleepByDay: (sessions: Array<Record<string, unknown>>) => {
+    const groups = new Map<string, Array<Record<string, unknown>>>();
+    for (const s of sessions) {
+      const start = s.start_time as string;
+      const dur = s.total_duration_minutes as number;
+      if (!start || !dur || dur <= 0) continue;
+      const wakeMs = new Date(start).getTime() + dur * 60 * 1000;
+      const wakeDate = new Date(wakeMs).toISOString().split('T')[0];
+      if (!groups.has(wakeDate)) groups.set(wakeDate, []);
+      groups.get(wakeDate)!.push(s);
+    }
+    const result = new Map<string, Map<string, number | null>>();
+    for (const [date, daySessions] of groups) {
+      let totalMin = 0;
+      let longest = daySessions[0];
+      let longestDur = 0;
+      for (const s of daySessions) {
+        const d = (s.total_duration_minutes as number) ?? 0;
+        totalMin += d;
+        if (d > longestDur) { longestDur = d; longest = s; }
+      }
+      const vm = longest.vendor_metadata as Record<string, unknown> | null;
+      const deep = vm?.deep_minutes as number | undefined;
+      const rem = vm?.rem_minutes as number | undefined;
+      const hrv = vm?.hrv_ms as number | undefined;
+      const metrics = new Map<string, number | null>();
+      metrics.set('sleep_duration', totalMin > 0 ? totalMin / 60 : null);
+      metrics.set('sleep_deep_pct', deep != null && longestDur > 0 ? (deep / longestDur) * 100 : null);
+      metrics.set('sleep_rem_pct', rem != null && longestDur > 0 ? (rem / longestDur) * 100 : null);
+      metrics.set('hrv_sleep', hrv ?? null);
+      result.set(date, metrics);
+    }
+    return result;
   },
 }));
 
@@ -137,7 +159,9 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
       makeDailySummary('2026-03-03', 61, 7500, 42),
     ];
     mockSleepSessions = [
+      // start 03-01T22:00Z + 480min → wake 03-02T06:00Z → wake date: 03-02
       makeSleepSession('2026-03-01', 480, 90, 100),
+      // start 03-02T22:00Z + 460min → wake 03-03T05:40Z → wake date: 03-03
       makeSleepSession('2026-03-02', 460, 85, 95),
     ];
 
@@ -147,7 +171,8 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
       mockProvider,
     );
 
-    // 3 unique dates from daily_summary + 2 from sleep (but 2026-03-01 and 2026-03-02 overlap)
+    // daily_summary dates: 03-01, 03-02, 03-03
+    // sleep wake dates: 03-02, 03-03 (overlap with daily_summary)
     // Unique dates: 2026-03-01, 2026-03-02, 2026-03-03
     expect(result.days_of_data).toBe(3);
   });
@@ -158,6 +183,7 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
       makeDailySummary('2026-03-02', 60, 9000, 48),
     ];
     mockSleepSessions = [
+      // start 03-01T22:00Z + 480min → wake 03-02T06:00Z → wake date: 03-02
       makeSleepSession('2026-03-01', 480, 90, 100, 50),
     ];
 
@@ -178,9 +204,9 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
     // steps should have 2 entries
     expect(dh.steps).toHaveLength(2);
 
-    // sleep_duration should have 1 entry (480 min = 8 hrs)
+    // sleep_duration should have 1 entry (480 min = 8 hrs), attributed to wake date 03-02
     expect(dh.sleep_duration).toHaveLength(1);
-    expect(dh.sleep_duration[0].value).toBe(8);
+    expect(dh.sleep_duration[0]).toEqual({ date: '2026-03-02', value: 8 });
 
     // sleep_deep_pct should have 1 entry (90/480 * 100 = 18.75)
     expect(dh.sleep_deep_pct).toHaveLength(1);
@@ -232,8 +258,34 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
     }
   });
 
-  it('sleep_sessions use date derived from start_time for daily_history', async () => {
+  it('sums nap + main sleep per day instead of averaging per session', async () => {
+    mockSleepSessions = [
+      // Main sleep: start 03-01T22:00Z + 480min → wake 03-02T06:00Z (8h)
+      makeSleepSession('2026-03-01', 480, 90, 100),
+      // Nap same wake day: start 03-02T13:00 + 90min → wake 03-02T14:30 (1.5h)
+      { start_time: '2026-03-02T13:00:00Z', total_duration_minutes: 90, vendor_metadata: {} },
+    ];
+
+    const result = await getStarterPack(
+      { connected_providers: ['whoop'] },
+      'test-user',
+      mockProvider,
+    );
+
+    const dh = result.daily_history as Record<string, { date: string; value: number }[]>;
+    // Both sessions wake on 03-02, so they should be summed: 8 + 1.5 = 9.5h
+    expect(dh.sleep_duration).toHaveLength(1);
+    expect(dh.sleep_duration[0]).toEqual({ date: '2026-03-02', value: 9.5 });
+
+    // The average should also be 9.5 (one day), not (8 + 1.5) / 2 = 4.75
+    const scorecard = result.metric_scorecard as Array<{ metric_key: string; current_value: number }>;
+    const sleepMetric = scorecard.find((m) => m.metric_key === 'sleep_duration');
+    expect(sleepMetric?.current_value).toBe(9.5);
+  });
+
+  it('sleep_sessions are attributed to wake date, not start date', async () => {
     mockSleepSessions = [
+      // start 03-05T22:00Z + 480min → wake 03-06T06:00Z → wake date: 03-06
       makeSleepSession('2026-03-05', 480, 90, 100),
     ];
 
@@ -244,8 +296,7 @@ describe('StarterPack — R2: daily_history and days_of_data', () => {
     );
 
     const dh = result.daily_history as Record<string, { date: string; value: number }[]>;
-    // Sleep entries should have dates derived from start_time
     expect(dh.sleep_duration).toHaveLength(1);
-    expect(dh.sleep_duration[0].date).toBe('2026-03-05');
+    expect(dh.sleep_duration[0].date).toBe('2026-03-06');
   });
 });

supabase/functions/ai-engine/engines/starter-pack.ts

@@ -8,11 +8,9 @@
 
 import { createClient } from '../../_shared/supabaseClient.ts';
 import {
-  extractDeepSleepPct,
-  extractRemSleepPct,
   extractHrvFromDailySummary,
-  extractHrvFromSleepSession,
 } from '../../_shared/metric-extraction.ts';
+import { aggregateSleepByDay } from '../../_shared/daily-aggregation.ts';
 import { autoCorrectCompliance } from '../../_shared/compliance/output-validator.ts';
 import type { AIProvider } from '../providers/types.ts';
 import {
@@ -218,33 +216,35 @@ export async function getStarterPack(
     }
   }
 
-  for (const ss of sleepSessions ?? []) {
-    const total = ss.total_duration_minutes as number;
-    // Derive date from start_time (YYYY-MM-DD portion)
-    const startTime = ss.start_time as string | undefined;
-    const sleepDate = startTime ? startTime.split('T')[0] : undefined;
-    if (sleepDate) uniqueDates.add(sleepDate);
-
-    if (total > 0) {
-      const durationHrs = total / 60;
-      metricValues.sleep_duration.push(durationHrs);
-      if (sleepDate) dailyHistory.sleep_duration.push({ date: sleepDate, value: durationHrs });
-
-      const deepPct = extractDeepSleepPct(ss as Record<string, unknown>);
-      if (deepPct !== null) {
-        metricValues.sleep_deep_pct.push(deepPct);
-        if (sleepDate) dailyHistory.sleep_deep_pct.push({ date: sleepDate, value: deepPct });
-      }
-      const remPct = extractRemSleepPct(ss as Record<string, unknown>);
-      if (remPct !== null) {
-        metricValues.sleep_rem_pct.push(remPct);
-        if (sleepDate) dailyHistory.sleep_rem_pct.push({ date: sleepDate, value: remPct });
-      }
-      const hrvFromSleep = extractHrvFromSleepSession(ss as Record<string, unknown>);
-      if (hrvFromSleep !== null) {
-        metricValues.hrv.push(hrvFromSleep);
-        if (sleepDate) dailyHistory.hrv.push({ date: sleepDate, value: hrvFromSleep });
-      }
+  // Group sleep sessions by wake date and aggregate per day.
+  // This correctly sums naps + main sleep per day (instead of averaging
+  // per-session, which under-reports when naps/short sessions exist).
+  const sleepByDay = aggregateSleepByDay(
+    (sleepSessions ?? []) as Array<Record<string, unknown>>,
+  );
+
+  for (const [wakeDate, metrics] of sleepByDay) {
+    uniqueDates.add(wakeDate);
+
+    const duration = metrics.get('sleep_duration');
+    if (duration != null) {
+      metricValues.sleep_duration.push(duration);
+      dailyHistory.sleep_duration.push({ date: wakeDate, value: duration });
+    }
+    const deepPct = metrics.get('sleep_deep_pct');
+    if (deepPct != null) {
+      metricValues.sleep_deep_pct.push(deepPct);
+      dailyHistory.sleep_deep_pct.push({ date: wakeDate, value: deepPct });
+    }
+    const remPct = metrics.get('sleep_rem_pct');
+    if (remPct != null) {
+      metricValues.sleep_rem_pct.push(remPct);
+      dailyHistory.sleep_rem_pct.push({ date: wakeDate, value: remPct });
+    }
+    const hrvSleep = metrics.get('hrv_sleep');
+    if (hrvSleep != null) {
+      metricValues.hrv.push(hrvSleep);
+      dailyHistory.hrv.push({ date: wakeDate, value: hrvSleep });
     }
   }