feat: Hybrid sleep classifier with sensor calibration and historical priors

Major changes:
- Create hybrid classifier combining mic + HR with probability fusion
- Add SensorCalibration component for dream mode (mic + HR)
- Simplify MicrophoneTest to mic-only for settings
- Add prior night sleep stage proportions as classifier prior
- Remove HRV display from settings (not available on Pixel)
- Force model retrain at session start
- Add awake prior that fades over 5 minutes

Files:
- services/hybridClassifier.ts (NEW): Probability-based fusion
- components/SensorCalibration.tsx (NEW): Dual-sensor calibration
- services/sleepStageLearning.ts: Stage proportions calculation
- services/sleep.ts: Hybrid classifier integration
- app/(tabs)/dream.tsx: Use SensorCalibration
- app/(tabs)/settings.tsx: Remove HRV display
- components/MicrophoneTest.tsx: Simplified mic-only test

Author: jeremymanning

app/(tabs)/dream.tsx

@@ -8,7 +8,7 @@ import { Text, Heading } from '@/components/ui/Text';
 import { Button } from '@/components/ui/Button';
 import { useThemedAlert } from '@/components/ui/ThemedAlert';
 import { VolumeSetup } from '@/components/VolumeSetup';
-import { MicrophoneTest } from '@/components/MicrophoneTest';
+import { SensorCalibration } from '@/components/SensorCalibration';
 import { SleepStageGraph } from '@/components/SleepStageGraph';
 import { SleepHistoryCard } from '@/components/SleepHistoryCard';
 import { SleepSessionDetailModal } from '@/components/SleepSessionDetailModal';
@@ -22,8 +22,12 @@ import {
   onRemStart,
   onRemEnd,
   onStageHistoryChange,
+  onSleepStageChange,
+  startCalibrationTest,
+  stopCalibrationTest,
   type StageHistoryEntry,
 } from '@/services/sleep';
+import type { SleepStage } from '@/types/database';
 import { storage } from '@/lib/storage';
 import { fadeOut, configureSleepAudioSession } from '@/services/volume';
 import { colors, spacing, borderRadius } from '@/theme/tokens';
@@ -37,7 +41,7 @@ export default function DreamScreen() {
   const { queue, getNext, complete } = useLaunchQueue();
 
   const [showVolumeSetup, setShowVolumeSetup] = useState(false);
-  const [showMicTest, setShowMicTest] = useState(false);
+  const [showSensorCalibration, setShowSensorCalibration] = useState(false);
   const [selectedSession, setSelectedSession] = useState<SleepSession | null>(null);
   const [showSleepSummary, setShowSleepSummary] = useState(false);
   const [sleepSummaryData, setSleepSummaryData] = useState<{
@@ -62,7 +66,9 @@ export default function DreamScreen() {
   const remUnsubscribeRef = useRef<(() => void) | null>(null);
   const remEndUnsubscribeRef = useRef<(() => void) | null>(null);
   const stageHistoryUnsubscribeRef = useRef<(() => void) | null>(null);
+  const meditationSleepUnsubscribeRef = useRef<(() => void) | null>(null);
   const currentQueueIdRef = useRef<string | null>(null);
+  const isMeditationFadingRef = useRef(false);
 
   useEffect(() => {
     return () => {
@@ -106,8 +112,53 @@ export default function DreamScreen() {
       } catch {}
       meditationSoundRef.current = null;
     }
+    if (meditationSleepUnsubscribeRef.current) {
+      meditationSleepUnsubscribeRef.current();
+      meditationSleepUnsubscribeRef.current = null;
+    }
+    stopCalibrationTest();
   };
 
+  const handleSleepDetectedDuringMeditation = useCallback(
+    async (stage: SleepStage) => {
+      if (stage === 'awake' || !meditationSoundRef.current || isMeditationFadingRef.current) {
+        return;
+      }
+
+      console.log('[Dream] Sleep detected during meditation:', stage);
+      isMeditationFadingRef.current = true;
+
+      try {
+        const status = await meditationSoundRef.current.getStatusAsync();
+        if (!status.isLoaded) return;
+
+        const currentVolume = status.volume ?? 1.0;
+        await fadeOut(meditationSoundRef.current, currentVolume, 10000);
+
+        await meditationSoundRef.current.stopAsync();
+        await meditationSoundRef.current.unloadAsync();
+        meditationSoundRef.current = null;
+
+        if (meditationSleepUnsubscribeRef.current) {
+          meditationSleepUnsubscribeRef.current();
+          meditationSleepUnsubscribeRef.current = null;
+        }
+        stopCalibrationTest();
+
+        setIsMeditating(false);
+        setIsMeditationPaused(false);
+        setMeditationProgress(0);
+
+        await start('audio');
+      } catch (err) {
+        console.warn('Failed to handle sleep transition:', err);
+      } finally {
+        isMeditationFadingRef.current = false;
+      }
+    },
+    [start]
+  );
+
   const handleRemStart = async () => {
     console.log('[Dream] REM detected - starting playback');
     if (isPlaying) return;
@@ -218,6 +269,11 @@ export default function DreamScreen() {
       try {
         await configureSleepAudioSession();
 
+        await startCalibrationTest();
+        meditationSleepUnsubscribeRef.current = onSleepStageChange(
+          handleSleepDetectedDuringMeditation
+        );
+
         const { sound, status } = await Audio.Sound.createAsync(
           { uri: getMeditationUrl() },
           {
@@ -236,6 +292,11 @@ export default function DreamScreen() {
             }
 
             if (playbackStatus.didJustFinish) {
+              if (meditationSleepUnsubscribeRef.current) {
+                meditationSleepUnsubscribeRef.current();
+                meditationSleepUnsubscribeRef.current = null;
+              }
+              stopCalibrationTest();
               setIsMeditating(false);
               setIsMeditationPaused(false);
               setMeditationProgress(0);
@@ -252,15 +313,25 @@ export default function DreamScreen() {
         setIsMeditationPaused(false);
       } catch (err) {
         console.warn('Failed to play meditation:', err);
+        if (meditationSleepUnsubscribeRef.current) {
+          meditationSleepUnsubscribeRef.current();
+          meditationSleepUnsubscribeRef.current = null;
+        }
+        stopCalibrationTest();
         start('audio').catch(() => {
           showAlert('Error', 'Failed to start sleep tracking.');
         });
       }
     },
-    [start]
+    [start, handleSleepDetectedDuringMeditation]
   );
 
   const skipMeditation = useCallback(async () => {
+    if (meditationSleepUnsubscribeRef.current) {
+      meditationSleepUnsubscribeRef.current();
+      meditationSleepUnsubscribeRef.current = null;
+    }
+    stopCalibrationTest();
     if (meditationSoundRef.current) {
       try {
         await meditationSoundRef.current.stopAsync();
@@ -311,6 +382,11 @@ export default function DreamScreen() {
   }, [playMeditation]);
 
   const stopMeditation = useCallback(async () => {
+    if (meditationSleepUnsubscribeRef.current) {
+      meditationSleepUnsubscribeRef.current();
+      meditationSleepUnsubscribeRef.current = null;
+    }
+    stopCalibrationTest();
     if (meditationSoundRef.current) {
       try {
         await meditationSoundRef.current.stopAsync();
@@ -325,11 +401,11 @@ export default function DreamScreen() {
 
   const handleVolumeComplete = useCallback(() => {
     setShowVolumeSetup(false);
-    setShowMicTest(true);
+    setShowSensorCalibration(true);
   }, []);
 
-  const handleMicTestComplete = useCallback(async () => {
-    setShowMicTest(false);
+  const handleCalibrationComplete = useCallback(async () => {
+    setShowSensorCalibration(false);
 
     if (helpMeFallAsleep) {
       await playMeditation();
@@ -339,14 +415,14 @@ export default function DreamScreen() {
       } catch {
         showAlert(
           'Error',
-          'Failed to start sleep tracking. Please ensure microphone access is enabled.'
+          'Failed to start sleep tracking. Please ensure sensor access is enabled.'
         );
       }
     }
   }, [start, helpMeFallAsleep, playMeditation]);
 
-  const handleMicTestSkip = useCallback(async () => {
-    setShowMicTest(false);
+  const handleCalibrationSkip = useCallback(async () => {
+    setShowSensorCalibration(false);
 
     if (helpMeFallAsleep) {
       await playMeditation();
@@ -356,7 +432,7 @@ export default function DreamScreen() {
       } catch {
         showAlert(
           'Error',
-          'Failed to start sleep tracking. Please ensure microphone access is enabled.'
+          'Failed to start sleep tracking. Please ensure sensor access is enabled.'
         );
       }
     }
@@ -733,25 +809,28 @@ export default function DreamScreen() {
             onComplete={handleVolumeComplete}
             onSkip={() => {
               setShowVolumeSetup(false);
-              setShowMicTest(true);
+              setShowSensorCalibration(true);
             }}
           />
         </SafeAreaView>
       </Modal>
 
       <Modal
-        visible={showMicTest}
+        visible={showSensorCalibration}
         animationType="slide"
         presentationStyle="pageSheet"
-        onRequestClose={() => setShowMicTest(false)}
+        onRequestClose={() => setShowSensorCalibration(false)}
       >
         <SafeAreaView style={styles.modalContainer} edges={['top', 'bottom']}>
           <View style={styles.modalHeader}>
-            <Pressable onPress={() => setShowMicTest(false)} style={styles.closeButton}>
+            <Pressable onPress={() => setShowSensorCalibration(false)} style={styles.closeButton}>
               <Ionicons name="close" size={24} color={colors.gray[400]} />
             </Pressable>
           </View>
-          <MicrophoneTest onComplete={handleMicTestComplete} onSkip={handleMicTestSkip} />
+          <SensorCalibration
+            onComplete={handleCalibrationComplete}
+            onSkip={handleCalibrationSkip}
+          />
         </SafeAreaView>
       </Modal>
     </SafeAreaView>

app/(tabs)/settings.tsx

@@ -24,6 +24,10 @@ import {
   clearModel,
   type DebugReport,
 } from '@/services/sleepStageLearning';
+import {
+  runHealthConnectDebugReport,
+  formatHealthConnectDebugReport,
+} from '@/services/healthConnect';
 
 export default function SettingsScreen() {
   const [showSleepDebug, setShowSleepDebug] = useState(false);
@@ -33,6 +37,9 @@ export default function SettingsScreen() {
   const [showModelDebug, setShowModelDebug] = useState(false);
   const [modelDebugReport, setModelDebugReport] = useState<string | null>(null);
   const [isLoadingModelDebug, setIsLoadingModelDebug] = useState(false);
+  const [showHCDebug, setShowHCDebug] = useState(false);
+  const [hcDebugReport, setHcDebugReport] = useState<string | null>(null);
+  const [isLoadingHCDebug, setIsLoadingHCDebug] = useState(false);
 
   const health = useHealth();
 
@@ -65,6 +72,19 @@ export default function SettingsScreen() {
     setModelDebugReport('Model cleared. Tap "Run Debug Report" to see current state.');
   };
 
+  const handleRunHCDebug = async () => {
+    setIsLoadingHCDebug(true);
+    setHcDebugReport(null);
+    try {
+      const report = await runHealthConnectDebugReport(24);
+      setHcDebugReport(formatHealthConnectDebugReport(report));
+    } catch (error) {
+      setHcDebugReport(`Error: ${error}`);
+    } finally {
+      setIsLoadingHCDebug(false);
+    }
+  };
+
   useEffect(() => {
     if (showWearable && health.status?.permissionsGranted) {
       health.startVitalsPolling();
@@ -157,12 +177,6 @@ export default function SettingsScreen() {
                             {health.vitals?.heartRate ?? '--'} bpm
                           </Text>
                         </View>
-                        <View style={styles.vitalItem}>
-                          <Ionicons name="pulse" size={16} color={colors.accent.cyan} />
-                          <Text variant="caption" color="primary">
-                            {health.vitals?.hrv?.toFixed(0) ?? '--'} ms HRV
-                          </Text>
-                        </View>
                         <View style={styles.pollingIndicator}>
                           {health.isPolling && <View style={styles.pollingDot} />}
                           <Pressable style={styles.refreshButton} onPress={health.refreshVitals}>
@@ -332,6 +346,55 @@ export default function SettingsScreen() {
               )}
             </View>
           )}
+
+          {(Platform.OS === 'android' || Platform.OS === 'ios') && (
+            <>
+              <MenuRow
+                icon="medkit-outline"
+                label="Health Connect Data Debug"
+                onPress={() => setShowHCDebug(!showHCDebug)}
+              />
+              {showHCDebug && (
+                <View style={styles.expandedSection}>
+                  <View style={styles.debugButtonRow}>
+                    <Pressable
+                      style={styles.debugButton}
+                      onPress={handleRunHCDebug}
+                      disabled={isLoadingHCDebug}
+                    >
+                      {isLoadingHCDebug ? (
+                        <ActivityIndicator size="small" color={colors.primary[500]} />
+                      ) : (
+                        <Ionicons name="play" size={16} color={colors.primary[500]} />
+                      )}
+                      <Text variant="caption" color="primary">
+                        Run Debug Report
+                      </Text>
+                    </Pressable>
+                  </View>
+                  <Text variant="caption" color="muted" style={{ marginBottom: spacing.sm }}>
+                    Shows all Health Connect data available from your wearable (last 24h)
+                  </Text>
+                  {hcDebugReport && (
+                    <ScrollView
+                      style={styles.debugOutput}
+                      horizontal={false}
+                      nestedScrollEnabled={true}
+                    >
+                      <Text
+                        variant="caption"
+                        color="muted"
+                        style={styles.debugOutputText}
+                        selectable={true}
+                      >
+                        {hcDebugReport}
+                      </Text>
+                    </ScrollView>
+                  )}
+                </View>
+              )}
+            </>
+          )}
         </View>
 
         <View style={styles.versionSection}>