@ateam-ai-mobile/expo 0.1.5 → 0.1.7

package/src/device-bridge/collectors/health.ts

@@ -0,0 +1,299 @@
+/**
+ * Health Collector — reads HealthKit aggregates via @kingstinct/react-native-healthkit
+ * (TurboModule / Nitro-Modules based; works in React Native's New Architecture).
+ *
+ * iOS only. On Android the functions resolve with zeros so the caller doesn't
+ * need to platform-check.
+ *
+ * Public:
+ *   - hasPermission()        — returns true once authorization has been requested.
+ *   - requestPermission()    — triggers the iOS HealthKit permission sheet (red heart).
+ *   - collectToday()         — one HealthDayMetrics for today.
+ *   - collectHistory(days)   — array of HealthDayMetrics, newest-first.
+ */
+import { Platform } from 'react-native';
+import type { HealthDayMetrics } from '../types';
+
+// Lazy-loaded so the module is harmless on Android / Expo Go / non-iOS.
+// In Expo Go the JS module resolves but the native bridge is missing —
+// resulting object exists yet methods like requestAuthorization are undefined.
+let _HK: any = null;
+let _hkProbed = false;
+function getHK(): any | null {
+  if (Platform.OS !== 'ios') return null;
+  if (_hkProbed) return _HK;
+  _hkProbed = true;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const mod = require('@kingstinct/react-native-healthkit');
+    if (mod && typeof mod.requestAuthorization === 'function') {
+      _HK = mod;
+    } else {
+      console.warn('[health] @kingstinct/react-native-healthkit native bridge unavailable — HealthKit disabled (Expo Go?)');
+    }
+  } catch (e) {
+    console.warn('[health] @kingstinct/react-native-healthkit require failed:', e);
+  }
+  return _HK;
+}
+
+// Last error from requestAuthorization — surfaced to UI so we don't fail silently.
+export let lastHealthInitError: string | null = null;
+
+const READ_TYPES = [
+  'HKQuantityTypeIdentifierStepCount',
+  'HKQuantityTypeIdentifierFlightsClimbed',
+  'HKQuantityTypeIdentifierActiveEnergyBurned',
+  'HKQuantityTypeIdentifierDistanceWalkingRunning',
+  // Added for mood signals — all read-only, covered by the same auth sheet.
+  'HKQuantityTypeIdentifierRestingHeartRate',
+  'HKQuantityTypeIdentifierAppleExerciseTime',
+  'HKCategoryTypeIdentifierSleepAnalysis',
+] as const;
+
+let _initPromise: Promise<boolean> | null = null;
+
+/** Request HealthKit authorization once; subsequent calls reuse the result. */
+async function ensureInit(): Promise<boolean> {
+  const HK = getHK();
+  if (!HK) {
+    lastHealthInitError = '@kingstinct/react-native-healthkit native module not loaded';
+    return false;
+  }
+  if (_initPromise) return _initPromise;
+  _initPromise = (async () => {
+    try {
+      // requestAuthorization triggers the iOS HealthKit permission sheet.
+      // Resolves once the user dismisses it (regardless of allow/deny).
+      // Returns the authorization status — but iOS deliberately does not
+      // disclose per-type read permission state for privacy, so we just
+      // treat "we asked" as "ready to read" and let reads return 0 if denied.
+      await HK.requestAuthorization({ toRead: READ_TYPES, toWrite: [] });
+      lastHealthInitError = null;
+      return true;
+    } catch (e: any) {
+      lastHealthInitError = `requestAuthorization threw: ${e?.message || String(e)}`;
+      console.warn('[health]', lastHealthInitError);
+      _initPromise = null;
+      return false;
+    }
+  })();
+  return _initPromise;
+}
+
+export async function hasPermission(): Promise<boolean> {
+  return ensureInit();
+}
+
+export async function requestPermission(): Promise<boolean> {
+  return ensureInit();
+}
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function startOfDay(d: Date): Date {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+
+function dateKey(d: Date): string {
+  // Local-date YYYY-MM-DD
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const day = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${day}`;
+}
+
+/**
+ * Read a single daily-aggregate sum for [start, end) in the given unit.
+ * Returns 0 when no data, HealthKit unavailable, or the call throws.
+ *
+ * `queryStatisticsForQuantity` is the modern statistics API; we ask only for
+ * the cumulative sum since that's what we need for these data types.
+ */
+async function readDailySum(identifier: string, unit: string, start: Date, end: Date): Promise<number> {
+  const HK = getHK();
+  if (!HK?.queryStatisticsForQuantity) return 0;
+  try {
+    // The kingstinct API takes the date range nested under filter.date — not
+    // top-level from/to. Without filter.date the call returns the cumulative
+    // sum across ALL historical data, which is what we hit before this fix
+    // (millions of steps, thousands of km, hundreds of thousands of kcal).
+    const result: any = await HK.queryStatisticsForQuantity(
+      identifier,
+      ['cumulativeSum'],
+      {
+        unit,
+        filter: { date: { startDate: start, endDate: end } },
+      },
+    );
+    const q = result?.sumQuantity?.quantity;
+    return typeof q === 'number' ? q : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Daily discrete-average for a quantity (e.g. resting heart rate). Returns
+ * null when no sample exists for the day so the backend can tell "no data"
+ * apart from a real zero.
+ */
+async function readDailyAverage(identifier: string, unit: string, start: Date, end: Date): Promise<number | null> {
+  const HK = getHK();
+  if (!HK?.queryStatisticsForQuantity) return null;
+  try {
+    const result: any = await HK.queryStatisticsForQuantity(
+      identifier,
+      ['discreteAverage'],
+      { unit, filter: { date: { startDate: start, endDate: end } } },
+    );
+    const q = result?.averageQuantity?.quantity;
+    return typeof q === 'number' ? q : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Total minutes asleep for [start, end) from HKCategoryTypeIdentifierSleepAnalysis.
+ * Sums sample durations that represent actual sleep (any "asleep*" value),
+ * excluding inBed/awake. Heavily guarded — sleep-stage enums differ across iOS
+ * versions and the kingstinct API surface, so any failure returns null.
+ */
+async function readSleepMinutes(start: Date, end: Date): Promise<number | null> {
+  const HK = getHK();
+  const query = HK?.queryCategorySamples || HK?.queryCategorySamplesAsync || HK?.querySamples;
+  if (!query) return null;
+  try {
+    const samples: any[] = await query.call(
+      HK,
+      'HKCategoryTypeIdentifierSleepAnalysis',
+      { filter: { date: { startDate: start, endDate: end } } },
+    );
+    if (!Array.isArray(samples) || samples.length === 0) return null;
+    // value semantics: 0 = inBed, 2 = awake; everything else = a sleep stage.
+    // Treat anything that isn't explicitly inBed/awake as asleep.
+    let ms = 0;
+    for (const s of samples) {
+      const v = s?.value;
+      const isAsleep = v !== 0 && v !== 2; // exclude inBed + awake
+      if (!isAsleep) continue;
+      const a = new Date(s?.startDate).getTime();
+      const b = new Date(s?.endDate).getTime();
+      if (Number.isFinite(a) && Number.isFinite(b) && b > a) ms += b - a;
+    }
+    return ms > 0 ? Math.round(ms / 60000) : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Mood-relevant HealthKit extras for today: sleep minutes, resting heart rate,
+ * active energy (kcal), exercise minutes. Each is null when unavailable so the
+ * backend weights only present fields.
+ */
+export async function collectMoodExtras(): Promise<{
+  sleep_min: number | null;
+  resting_hr: number | null;
+  active_energy_kcal: number | null;
+  exercise_min: number | null;
+}> {
+  const ok = await ensureInit();
+  if (!ok) return { sleep_min: null, resting_hr: null, active_energy_kcal: null, exercise_min: null };
+  const start = startOfDay(new Date());
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  // Sleep window: look back from this morning over the past night (~last 18h)
+  // so an evening collection still captures the prior night.
+  const sleepStart = new Date(start);
+  sleepStart.setHours(sleepStart.getHours() - 6); // include after-midnight + prev evening within today's window
+  const [sleep_min, resting_hr, energy, exercise] = await Promise.all([
+    readSleepMinutes(sleepStart, end),
+    readDailyAverage('HKQuantityTypeIdentifierRestingHeartRate', 'count/min', start, end),
+    readDailySum('HKQuantityTypeIdentifierActiveEnergyBurned', 'kcal', start, end),
+    readDailySum('HKQuantityTypeIdentifierAppleExerciseTime', 'min', start, end),
+  ]);
+  return {
+    sleep_min,
+    resting_hr: resting_hr != null ? Math.round(resting_hr) : null,
+    active_energy_kcal: energy ? Math.round(energy) : null,
+    exercise_min: exercise ? Math.round(exercise) : null,
+  };
+}
+
+async function readDay(date: Date): Promise<HealthDayMetrics> {
+  const start = startOfDay(date);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+
+  const [steps, floors, energy, distance] = await Promise.all([
+    readDailySum('HKQuantityTypeIdentifierStepCount', 'count', start, end),
+    readDailySum('HKQuantityTypeIdentifierFlightsClimbed', 'count', start, end),
+    readDailySum('HKQuantityTypeIdentifierActiveEnergyBurned', 'kcal', start, end),
+    // Ask for kilometers directly so we don't have to convert from meters.
+    readDailySum('HKQuantityTypeIdentifierDistanceWalkingRunning', 'km', start, end),
+  ]);
+
+  return {
+    date: dateKey(start),
+    available: true,
+    steps: Math.round(steps),
+    floors: Math.round(floors),
+    active_energy_kcal: Math.round(energy),
+    distance_km: Math.round(distance * 100) / 100,
+  };
+}
+
+// ─── Public API ─────────────────────────────────────────────
+
+/**
+ * A day we could not read: metrics null, availability stated.
+ *
+ * The distinction this preserves is the whole point — "no data" and "a day
+ * with no activity" look identical once you write a zero, and only one of
+ * them is something to tell the user about.
+ */
+function unavailableDay(date: Date): HealthDayMetrics {
+  return {
+    date: dateKey(date),
+    available: false,
+    steps: null,
+    floors: null,
+    active_energy_kcal: null,
+    distance_km: null,
+  };
+}
+
+export async function collectToday(): Promise<HealthDayMetrics> {
+  const ok = await ensureInit();
+  if (!ok) {
+    // HealthKit unavailable or access denied. NOT a day with no activity —
+    // reporting zeros here is how "you have taken 0 steps today" reached the
+    // user as a fact, with a coaching skill ready to act on it.
+    return unavailableDay(new Date());
+  }
+  return readDay(new Date());
+}
+
+/**
+ * Last `days` days, newest-first. Index 0 is today.
+ * Caller passes 1..30 — we clamp defensively.
+ */
+export async function collectHistory(days: number): Promise<HealthDayMetrics[]> {
+  const n = Math.max(1, Math.min(30, Math.floor(days)));
+  const ok = await ensureInit();
+  if (!ok) return [];
+
+  const today = startOfDay(new Date());
+  const out: HealthDayMetrics[] = [];
+  // Sequential to avoid hammering HealthKit with 30 parallel queries.
+  for (let i = 0; i < n; i++) {
+    const d = new Date(today);
+    d.setDate(d.getDate() - i);
+    out.push(await readDay(d));
+  }
+  return out;
+}

package/src/device-bridge/collectors/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Collectors — one per device data domain.
+ * Each collector reads from a specific Expo API and returns data
+ * matching the exact schema from device-mock-mcp.
+ */
+
+export * as calendar from './calendar';
+export * as contacts from './contacts';
+export * as location from './location';
+export * as battery from './battery';
+export * as connectivity from './connectivity';
+export * as notifications from './notifications';

package/src/device-bridge/collectors/location.ts

@@ -0,0 +1,224 @@
+/**
+ * Location Collector — reads device location via expo-location.
+ * Output format matches device-mock-mcp's location.current schema.
+ */
+
+import * as ExpoLocation from 'expo-location';
+// Type-only alias: the value namespace above cannot be used in type
+// position, so `ExpoLocation.Calendar`-style annotations need this.
+// Not re-exported from the package entry — derive from the API that
+// returns it, so the shape follows the installed expo-location.
+type LocationGeocodedAddress = Awaited<ReturnType<typeof ExpoLocation.reverseGeocodeAsync>>[number];
+import type { LocationData } from '../types';
+
+/**
+ * Request location permissions (foreground + background).
+ */
+export async function requestPermission(): Promise<boolean> {
+  const { status: fg } = await ExpoLocation.requestForegroundPermissionsAsync();
+  if (fg !== 'granted') return false;
+
+  // Background is optional — skip in Expo Go (crashes without native module)
+  try {
+    await ExpoLocation.requestBackgroundPermissionsAsync();
+  } catch {
+    // Expected in Expo Go — foreground is enough for basic functionality
+  }
+  return fg === 'granted';
+}
+
+/**
+ * Check if location permission is granted.
+ */
+export async function hasPermission(): Promise<boolean> {
+  const { status } = await ExpoLocation.getForegroundPermissionsAsync();
+  return status === 'granted';
+}
+
+/**
+ * Collect current location.
+ * Matches the device.location.current tool output schema.
+ */
+export async function collectCurrent(): Promise<LocationData> {
+  const location = await ExpoLocation.getCurrentPositionAsync({
+    accuracy: ExpoLocation.Accuracy.Balanced,
+  });
+
+  // Reverse geocode to get address
+  let place = 'Current Location';
+  let address = `${location.coords.latitude.toFixed(4)}, ${location.coords.longitude.toFixed(4)}`;
+  let locationType = 'unknown';
+
+  try {
+    const [geocoded] = await ExpoLocation.reverseGeocodeAsync({
+      latitude: location.coords.latitude,
+      longitude: location.coords.longitude,
+    });
+
+    if (geocoded) {
+      place = geocoded.name || geocoded.street || place;
+      address = [
+        geocoded.streetNumber,
+        geocoded.street,
+        geocoded.city,
+        geocoded.region,
+      ]
+        .filter(Boolean)
+        .join(', ') || address;
+
+      // Attempt to classify location type
+      locationType = classifyLocation(geocoded);
+    }
+  } catch {
+    // Reverse geocoding can fail — use coordinates only
+  }
+
+  return {
+    ok: true,
+    timestamp: new Date().toISOString(),
+    location: {
+      place,
+      address,
+      lat: location.coords.latitude,
+      lng: location.coords.longitude,
+      type: locationType,
+    },
+  };
+}
+
+// ─── Plugin-facing position API ───
+// `collectCurrent` above answers the device-context question ("where am I, in
+// words") and reverse-geocodes. A plugin tool usually wants the raw fix and
+// nothing else, so these stay separate: no geocoding round trip, no address.
+
+export interface Position {
+  latitude: number;
+  longitude: number;
+  altitude?: number;
+  accuracy?: number;
+  timestamp: number;
+  /**
+   * Metres per second. `undefined` = the OS gave no estimate.
+   *
+   * iOS reports -1 rather than omitting it, and -1 m/s passed through as a
+   * speed would read as "moving backwards"; it is normalised away here so no
+   * caller has to know the platform's sentinel.
+   */
+  speed?: number;
+  /**
+   * COURSE OVER GROUND in degrees — the direction the user is TRAVELLING.
+   *
+   * Deliberately not called `heading`: this and the compass answer different
+   * questions and disagree constantly. Walking backwards down a corridor gives
+   * a course of south and a compass heading of north; a phone held sideways
+   * while walking forward gives the same course and a heading 90° off.
+   * "Turn right" needs the compass. "You are heading north on Main Street"
+   * needs this. The old code assigned one to the other, which is only ever
+   * right by accident.
+   *
+   * `undefined` when not moving or not estimated — iOS reports -1 for both.
+   */
+  course?: number;
+}
+
+/** Ensure foreground permission, asking once if we do not have it yet. */
+async function ensurePermission(): Promise<void> {
+  if (await hasPermission()) return;
+  const granted = await requestPermission();
+  if (!granted) {
+    // Callers surface this verbatim to the user (a voice assistant reads it
+    // out), so it has to say what the user can do about it.
+    throw new Error(
+      'Location permission was not granted. Enable it for this app in iOS Settings > Privacy > Location Services.',
+    );
+  }
+}
+
+/** One position fix. `accuracy: "high"` costs battery and time — default low. */
+export async function getPosition(
+  opts: { accuracy?: 'low' | 'high' } = {},
+): Promise<Position> {
+  await ensurePermission();
+  const fix = await ExpoLocation.getCurrentPositionAsync({
+    accuracy:
+      opts.accuracy === 'high'
+        ? ExpoLocation.Accuracy.High
+        : ExpoLocation.Accuracy.Balanced,
+  });
+  return toPosition(fix);
+}
+
+/**
+ * One place that turns an expo fix into a `Position`.
+ *
+ * It exists because the sentinel handling has to be identical on the one-shot
+ * and the streamed path. It was not: `watchPosition` passed lat/lon only, so
+ * the semantic Spatial domain could never report speed or course no matter
+ * what the OS supplied, and reported `null` as if the phone had no GPS.
+ */
+function toPosition(fix: any): Position {
+  return {
+    latitude: fix.coords.latitude,
+    longitude: fix.coords.longitude,
+    altitude: fix.coords.altitude ?? undefined,
+    accuracy: nonNegative(fix.coords.accuracy),
+    timestamp: fix.timestamp ?? Date.now(),
+    speed: nonNegative(fix.coords.speed),
+    course: nonNegative(fix.coords.heading),
+  };
+}
+
+/**
+ * iOS uses -1 for "no estimate" on accuracy, speed and course alike. Dropping
+ * the field says "not measured"; passing -1 through says "measured, and the
+ * answer is minus one", which a model will happily repeat.
+ */
+function nonNegative(v: unknown): number | undefined {
+  return typeof v === 'number' && v >= 0 ? v : undefined;
+}
+
+/**
+ * Stream position updates. Returns an unsubscribe function — call it, or the
+ * GPS keeps running and drains the battery.
+ */
+export function watchPosition(cb: (pos: Position) => void): () => void {
+  let subscription: { remove(): void } | null = null;
+  let cancelled = false;
+
+  (async () => {
+    try {
+      await ensurePermission();
+      if (cancelled) return;
+      subscription = await ExpoLocation.watchPositionAsync(
+        { accuracy: ExpoLocation.Accuracy.Balanced },
+        fix => cb(toPosition(fix)),
+      );
+      // Unsubscribed while we were still asking for permission.
+      if (cancelled) { subscription?.remove(); subscription = null; }
+    } catch (err: any) {
+      console.warn('[location] watchPosition failed:', err?.message || String(err));
+    }
+  })();
+
+  return () => {
+    cancelled = true;
+    subscription?.remove();
+    subscription = null;
+  };
+}
+
+// ─── Helpers ───
+
+function classifyLocation(geocoded: LocationGeocodedAddress): string {
+  // Simple heuristic — can be enhanced with user-labeled places from memory
+  const name = (geocoded.name || '').toLowerCase();
+  const street = (geocoded.street || '').toLowerCase();
+
+  if (name.includes('home') || name.includes('residence')) return 'home';
+  if (name.includes('office') || name.includes('workplace') || name.includes('tech park')) return 'work';
+  if (name.includes('school') || name.includes('elementary') || name.includes('university')) return 'school';
+  if (name.includes('gym') || name.includes('fitness')) return 'fitness';
+  if (name.includes('hospital') || name.includes('clinic') || name.includes('dental')) return 'medical';
+
+  return 'other';
+}

package/src/device-bridge/collectors/mood.ts

@@ -0,0 +1,141 @@
+/**
+ * Mood Signals Collector — assembles the daily behavioral-signal summary the
+ * Mood Intelligence Kit's backend expects (MoodSignalToday), and emits it as
+ * a compact daily object. It does NOT call the kit's HTTP client; transport is
+ * the existing device-bridge relay path (pushed as the `mood` domain), same as
+ * health/location/etc. The backend reads the relay domain and runs analysis.
+ *
+ * Philosophy (from the kit's DESIGN): send a concise daily SUMMARY, never raw
+ * event logs. We fill the fields we can source today from existing collectors
+ * and leave the rest null — the backend's baseline/fallback tolerates nulls.
+ *
+ * EXACT per-field contract + where each value comes from on THIS platform
+ * (iOS). "blocked" = Apple does not expose it to third-party apps, so it is
+ * permanently null on iOS; "addable" = we have a source but haven't wired it.
+ *
+ *   steps                 ← health (HealthKit)            ✅ sourced now
+ *   distance_km           ← health (HealthKit)            ✅ sourced now
+ *   sleep_min             ← health (HealthKit sleep)      ✅ sourced now
+ *   app_sessions          ← our own app analytics         ✅ sourced now
+ *   app_active_min        ← our own app analytics         ✅ sourced now
+ *   resting_hr (extra)    ← health (HealthKit)            ✅ sourced now
+ *   active_energy_kcal(x) ← health (HealthKit)            ✅ sourced now
+ *   exercise_min (extra)  ← health (HealthKit)            ✅ sourced now
+ *   places_count          ← location collector (distinct) ⏳ addable (not wired)
+ *   checkin_mood          ← user self-report UI           ⏳ addable (no UI yet)
+ *   screen_min            ← iOS Screen Time               ❌ blocked by iOS
+ *   night_screen_min      ← iOS Screen Time               ❌ blocked by iOS
+ *   social_app_min        ← other apps' usage             ❌ blocked by iOS
+ *   video_app_min         ← other apps' usage             ❌ blocked by iOS
+ *   productivity_app_min  ← other apps' usage             ❌ blocked by iOS
+ *   messages_sent         ← Messages content/metadata     ❌ blocked by iOS
+ *   calls_count           ← call log                      ❌ blocked by iOS
+ *
+ * (extra) = not in the kit's MoodSignalToday but sent alongside; the backend
+ * tolerates extra fields and these are strong mood proxies.
+ *
+ * The kit's spec listed many sources because several exist on Android
+ * (UsageStatsManager etc.); on iOS most are sandbox-blocked. We send what we
+ * truly have and leave the rest null — the backend baseline/fallback tolerates
+ * nulls and weights only present fields.
+ */
+import * as health from './health';
+import * as appEngagement from './appEngagement';
+
+// Mirrors the kit's MoodSignalToday (packages/mood-client-rn/src/types.ts).
+export interface MoodSignalToday {
+  steps: number | null;
+  sleep_min: number | null;
+  screen_min: number | null;
+  night_screen_min: number | null;
+  places_count: number | null;
+  distance_km: number | null;
+  social_app_min: number | null;
+  video_app_min: number | null;
+  productivity_app_min: number | null;
+  messages_sent: number | null;
+  calls_count: number | null;
+  app_sessions: number | null;
+  app_active_min: number | null;
+  checkin_mood?: 'great' | 'ok' | 'low' | 'bad' | null;
+}
+
+function emptySignals(): MoodSignalToday {
+  return {
+    steps: null,
+    sleep_min: null,
+    screen_min: null,
+    night_screen_min: null,
+    places_count: null,
+    distance_km: null,
+    social_app_min: null,
+    video_app_min: null,
+    productivity_app_min: null,
+    messages_sent: null,
+    calls_count: null,
+    app_sessions: null,
+    app_active_min: null,
+    checkin_mood: null,
+  };
+}
+
+/**
+ * Build today's mood signal summary from available collectors. Returns the
+ * full MoodSignalToday plus collection metadata the backend wants
+ * (window, timezone, collected_at) so it can run analyze without guessing.
+ */
+export async function collectToday(): Promise<{
+  window: 'today';
+  timezone: string;
+  collected_at: string;
+  today: MoodSignalToday;
+}> {
+  const today = emptySignals();
+
+  // Health-sourced fields (best-effort; collector returns zeros if HK denied).
+  try {
+    const h = await health.collectToday();
+    if (h) {
+      today.steps = typeof h.steps === 'number' ? h.steps : null;
+      today.distance_km = typeof h.distance_km === 'number' ? h.distance_km : null;
+    }
+  } catch {
+    // leave nulls — backend baseline handles missing fields
+  }
+
+  // HealthKit mood extras: sleep, resting HR, active energy, exercise minutes.
+  try {
+    const x = await health.collectMoodExtras();
+    today.sleep_min = x.sleep_min;
+    // resting_hr / active_energy_kcal / exercise_min aren't in the kit's
+    // MoodSignalToday contract, but the backend tolerates extra fields and
+    // they're strong mood proxies — include them alongside.
+    (today as any).resting_hr = x.resting_hr;
+    (today as any).active_energy_kcal = x.active_energy_kcal;
+    (today as any).exercise_min = x.exercise_min;
+  } catch {
+    // leave nulls
+  }
+
+  // Our own app-engagement analytics (no OS permission; the only on-iOS source
+  // for app_sessions / app_active_min).
+  try {
+    const e = await appEngagement.getToday();
+    today.app_sessions = e.app_sessions;
+    today.app_active_min = e.app_active_min;
+  } catch {
+    // leave nulls
+  }
+
+  let timezone = 'UTC';
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+  } catch { /* RN without full ICU — fall back to UTC */ }
+
+  return {
+    window: 'today',
+    timezone,
+    collected_at: new Date().toISOString(),
+    today,
+  };
+}