@elizaos/agent 2.0.0-alpha.441 → 2.0.0-alpha.501

package/apps/app-lifeops/src/lifeops/repository.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { logger } from "@elizaos/core";
 import { browserBridgeSchema, } from "@elizaos/plugin-browser-bridge";
+import { LIFEOPS_INBOX_CHANNELS, } from "../contracts/index.js";
 import { refreshLifeOpsRelativeTime } from "./relative-time.js";
 import { lifeOpsSchema } from "./schema.js";
 import { executeRawSql, parseJsonArray, parseJsonRecord, sqlBoolean, sqlInteger, sqlJson, sqlNumber, sqlQuote, sqlText, toBoolean, toNumber, toText, } from "./sql.js";
@@ -16,6 +17,15 @@ function deriveConnectorIdentityEmail(identity) {
         normalizeConnectorIdentityEmail(identity.emailAddress) ??
         normalizeConnectorIdentityEmail(identity.primaryEmail));
 }
+function requireScopedGmailGrantId(grantId) {
+    if (typeof grantId !== "string" || grantId.trim().length === 0) {
+        throw new Error("Gmail message persistence requires grantId.");
+    }
+    return grantId.trim();
+}
+const LIFEOPS_INBOX_CHANNEL_SET = new Set(LIFEOPS_INBOX_CHANNELS);
+const LIFEOPS_INBOX_CHAT_TYPES = new Set(["dm", "group", "channel"]);
+const LIFEOPS_INBOX_PRIORITY_CATEGORIES = new Set(["important", "planning", "casual"]);
 function isoNow() {
     return new Date().toISOString();
 }
@@ -27,11 +37,14 @@ function parseOwnershipFields(row) {
             : "user_lifeops",
         subjectType,
         subjectId: toText(row.subject_id, toText(row.agent_id)),
-        visibilityScope: toText(row.visibility_scope, subjectType === "agent" ? "agent_and_admin" : "owner_agent_admin") === "owner_only"
+        visibilityScope: subjectType === "owner"
             ? "owner_only"
-            : toText(row.visibility_scope, subjectType === "agent" ? "agent_and_admin" : "owner_agent_admin") === "agent_and_admin"
-                ? "agent_and_admin"
-                : "owner_agent_admin",
+            : toText(row.visibility_scope, "agent_and_admin") === "owner_only"
+                ? "owner_only"
+                : toText(row.visibility_scope, "agent_and_admin") ===
+                    "agent_and_admin"
+                    ? "agent_and_admin"
+                    : "owner_agent_admin",
         contextPolicy: toText(row.context_policy, subjectType === "agent" ? "never" : "explicit_only") === "never"
             ? "never"
             : toText(row.context_policy, subjectType === "agent" ? "never" : "explicit_only") === "sidebar_only"
@@ -242,6 +255,7 @@ function parseConnectorGrant(row) {
         provider: toText(row.provider),
         side: toText(row.side, "owner"),
         identity,
+        identityEmail: row.identity_email ? toText(row.identity_email) : null,
         grantedScopes: parseJsonArray(row.granted_scopes_json),
         capabilities: parseJsonArray(row.capabilities_json),
         tokenRef: row.token_ref ? toText(row.token_ref) : null,
@@ -428,10 +442,16 @@ function parseHealthSignal(value) {
         !Array.isArray(record.permissions)
         ? record.permissions
         : null;
+    const source = toText(record.source, "healthkit");
+    const normalizedSource = source === "health_connect" ||
+        source === "strava" ||
+        source === "fitbit" ||
+        source === "withings" ||
+        source === "oura"
+        ? source
+        : "healthkit";
     return {
-        source: toText(record.source, "healthkit") === "health_connect"
-            ? "health_connect"
-            : "healthkit",
+        source: normalizedSource,
         permissions: {
             sleep: toBoolean(permissionsRecord?.sleep ?? false),
             biometrics: toBoolean(permissionsRecord?.biometrics ?? false),
@@ -484,6 +504,118 @@ function parseActivitySignal(row) {
         createdAt: toText(row.created_at),
     };
 }
+function parseHealthMetricSample(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        provider: toText(row.provider),
+        grantId: toText(row.grant_id),
+        metric: toText(row.metric),
+        value: toNumber(row.value, 0),
+        unit: toText(row.unit),
+        startAt: toText(row.start_at),
+        endAt: toText(row.end_at),
+        localDate: toText(row.local_date),
+        sourceExternalId: toText(row.source_external_id),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseHealthWorkout(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        provider: toText(row.provider),
+        grantId: toText(row.grant_id),
+        sourceExternalId: toText(row.source_external_id),
+        workoutType: toText(row.workout_type),
+        title: toText(row.title),
+        startAt: toText(row.start_at),
+        endAt: row.end_at ? toText(row.end_at) : null,
+        durationSeconds: toNumber(row.duration_seconds, 0),
+        distanceMeters: row.distance_meters === null || row.distance_meters === undefined
+            ? null
+            : toNumber(row.distance_meters, 0),
+        calories: row.calories === null || row.calories === undefined
+            ? null
+            : toNumber(row.calories, 0),
+        averageHeartRate: row.average_heart_rate === null || row.average_heart_rate === undefined
+            ? null
+            : toNumber(row.average_heart_rate, 0),
+        maxHeartRate: row.max_heart_rate === null || row.max_heart_rate === undefined
+            ? null
+            : toNumber(row.max_heart_rate, 0),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseHealthSyncState(row) {
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        provider: toText(row.provider),
+        grantId: toText(row.grant_id),
+        cursor: row.cursor ? toText(row.cursor) : null,
+        lastSyncedAt: row.last_synced_at ? toText(row.last_synced_at) : null,
+        lastSyncStartedAt: row.last_sync_started_at
+            ? toText(row.last_sync_started_at)
+            : null,
+        lastSyncError: row.last_sync_error ? toText(row.last_sync_error) : null,
+        metadata: parseJsonRecord(row.metadata_json),
+        updatedAt: toText(row.updated_at),
+    };
+}
+function parseHealthSleepStageSamples(value) {
+    return parseJsonArray(value).filter((candidate) => {
+        if (!candidate || typeof candidate !== "object") {
+            return false;
+        }
+        const record = candidate;
+        return (typeof record.stage === "string" &&
+            typeof record.startAt === "string" &&
+            typeof record.endAt === "string" &&
+            (record.confidence === null || typeof record.confidence === "number") &&
+            (record.providerCode === null ||
+                typeof record.providerCode === "string"));
+    });
+}
+function parseHealthSleepEpisode(row) {
+    const nullableNumber = (value) => value === null || value === undefined ? null : toNumber(value, 0);
+    return {
+        id: toText(row.id),
+        agentId: toText(row.agent_id),
+        provider: toText(row.provider),
+        grantId: toText(row.grant_id),
+        sourceExternalId: toText(row.source_external_id),
+        localDate: toText(row.local_date),
+        timezone: row.timezone ? toText(row.timezone) : null,
+        startAt: toText(row.start_at),
+        endAt: toText(row.end_at),
+        isMainSleep: toBoolean(row.is_main_sleep, false),
+        sleepType: row.sleep_type ? toText(row.sleep_type) : null,
+        durationSeconds: toNumber(row.duration_seconds, 0),
+        timeInBedSeconds: nullableNumber(row.time_in_bed_seconds),
+        efficiency: nullableNumber(row.efficiency),
+        latencySeconds: nullableNumber(row.latency_seconds),
+        awakeSeconds: nullableNumber(row.awake_seconds),
+        lightSleepSeconds: nullableNumber(row.light_sleep_seconds),
+        deepSleepSeconds: nullableNumber(row.deep_sleep_seconds),
+        remSleepSeconds: nullableNumber(row.rem_sleep_seconds),
+        sleepScore: nullableNumber(row.sleep_score),
+        readinessScore: nullableNumber(row.readiness_score),
+        averageHeartRate: nullableNumber(row.average_heart_rate),
+        lowestHeartRate: nullableNumber(row.lowest_heart_rate),
+        averageHrvMs: nullableNumber(row.average_hrv_ms),
+        respiratoryRate: nullableNumber(row.respiratory_rate),
+        bloodOxygenPercent: nullableNumber(row.blood_oxygen_percent),
+        stageSamples: parseHealthSleepStageSamples(row.stage_samples_json),
+        metadata: parseJsonRecord(row.metadata_json),
+        createdAt: toText(row.created_at),
+        updatedAt: toText(row.updated_at),
+    };
+}
 function parseCalendarEvent(row) {
     return {
         id: toText(row.id),
@@ -516,6 +648,7 @@ function parseGmailMessageSummary(row) {
         agentId: toText(row.agent_id),
         provider: "google",
         side: toText(row.side, "owner"),
+        grantId: row.grant_id ? toText(row.grant_id) : undefined,
         threadId: toText(row.thread_id),
         subject: toText(row.subject),
         from: toText(row.from_display),
@@ -537,9 +670,94 @@ function parseGmailMessageSummary(row) {
         updatedAt: toText(row.updated_at),
     };
 }
+function normalizeInboxChatType(channel, value, participantCount) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        const normalized = value.trim().toLowerCase();
+        if (LIFEOPS_INBOX_CHAT_TYPES.has(normalized)) {
+            return normalized;
+        }
+        throw new Error(`[LifeOpsRepository] invalid inbox chat type: ${value}`);
+    }
+    if (channel === "gmail")
+        return "dm";
+    if (typeof participantCount === "number") {
+        return participantCount > 2 ? "group" : "dm";
+    }
+    return "channel";
+}
+function normalizeInboxChannelValue(value, label = "inbox channel") {
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (LIFEOPS_INBOX_CHANNEL_SET.has(normalized)) {
+            return normalized;
+        }
+    }
+    throw new Error(`[LifeOpsRepository] invalid ${label}: ${String(value)}`);
+}
+function requireInboxExternalId(value, label) {
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value;
+    }
+    throw new Error(`[LifeOpsRepository] missing ${label}`);
+}
+function parseCachedInboxSourceRef(value, channel, externalId) {
+    const sourceRef = parseJsonRecord(value);
+    const sourceRefChannel = sourceRef.channel === undefined || sourceRef.channel === null
+        ? channel
+        : normalizeInboxChannelValue(sourceRef.channel, "inbox sourceRef channel");
+    if (sourceRefChannel !== channel) {
+        throw new Error(`[LifeOpsRepository] inbox sourceRef channel ${sourceRefChannel} does not match row channel ${channel}`);
+    }
+    return {
+        channel: sourceRefChannel,
+        externalId: sourceRef.externalId === undefined || sourceRef.externalId === null
+            ? externalId
+            : requireInboxExternalId(sourceRef.externalId, "inbox sourceRef externalId"),
+    };
+}
+function normalizeInboxWriteSourceRef(sourceRef, channel) {
+    const sourceRefChannel = normalizeInboxChannelValue(sourceRef.channel, "inbox sourceRef channel");
+    if (sourceRefChannel !== channel) {
+        throw new Error(`[LifeOpsRepository] inbox sourceRef channel ${sourceRefChannel} does not match message channel ${channel}`);
+    }
+    return {
+        channel: sourceRefChannel,
+        externalId: requireInboxExternalId(sourceRef.externalId, "inbox sourceRef externalId"),
+    };
+}
+function normalizeInboxPriorityCategory(value) {
+    if (value === null || value === undefined || value === "") {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error("[LifeOpsRepository] invalid inbox priority category");
+    }
+    const normalized = value.trim().toLowerCase();
+    if (LIFEOPS_INBOX_PRIORITY_CATEGORIES.has(normalized)) {
+        return normalized;
+    }
+    throw new Error(`[LifeOpsRepository] invalid inbox priority category: ${value}`);
+}
+function normalizeInboxPriorityFlags(flags) {
+    if (!flags)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const flag of flags) {
+        const normalized = flag.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+function hasOwnPriorityFlags(message) {
+    return Object.hasOwn(message, "priorityFlags");
+}
 function parseCachedInboxMessage(row) {
-    const channel = toText(row.channel);
-    const externalId = toText(row.external_id);
+    const channel = normalizeInboxChannelValue(row.channel);
+    const externalId = requireInboxExternalId(row.external_id, "inbox external_id");
     const priorityScore = row.priority_score === null || row.priority_score === undefined
         ? undefined
         : toNumber(row.priority_score);
@@ -549,7 +767,8 @@ function parseCachedInboxMessage(row) {
     const participantCount = row.participant_count === null || row.participant_count === undefined
         ? undefined
         : toNumber(row.participant_count);
-    const sourceRef = parseJsonRecord(row.source_ref_json);
+    const chatType = normalizeInboxChatType(channel, row.chat_type, participantCount);
+    const sourceRef = parseCachedInboxSourceRef(row.source_ref_json, channel, externalId);
     const flags = parseJsonArray(row.priority_flags_json).filter((flag) => typeof flag === "string");
     return {
         id: toText(row.id),
@@ -565,16 +784,9 @@ function parseCachedInboxMessage(row) {
         receivedAt: toText(row.received_at),
         unread: toBoolean(row.is_unread),
         deepLink: row.deep_link ? toText(row.deep_link) : null,
-        sourceRef: {
-            channel: typeof sourceRef.channel === "string"
-                ? sourceRef.channel
-                : channel,
-            externalId: typeof sourceRef.externalId === "string"
-                ? sourceRef.externalId
-                : externalId,
-        },
+        sourceRef,
         threadId: row.thread_id ? toText(row.thread_id) : undefined,
-        chatType: toText(row.chat_type, "dm"),
+        chatType,
         participantCount,
         gmailAccountId: row.gmail_account_id
             ? toText(row.gmail_account_id)
@@ -582,8 +794,10 @@ function parseCachedInboxMessage(row) {
         gmailAccountEmail: row.gmail_account_email
             ? toText(row.gmail_account_email)
             : undefined,
+        lastSeenAt: row.last_seen_at ? toText(row.last_seen_at) : undefined,
+        repliedAt: row.replied_at ? toText(row.replied_at) : undefined,
         priorityScore,
-        priorityCategory: priorityCategory,
+        priorityCategory: normalizeInboxPriorityCategory(priorityCategory),
         cachedAt: toText(row.cached_at),
         updatedAt: toText(row.updated_at),
         priorityFlags: flags,
@@ -829,6 +1043,7 @@ function parseGmailSyncState(row) {
         provider: toText(row.provider),
         side: toText(row.side, "owner"),
         mailbox: toText(row.mailbox),
+        grantId: toText(row.grant_id),
         maxResults: toNumber(row.max_results, 0),
         syncedAt: toText(row.synced_at),
         updatedAt: toText(row.updated_at),
@@ -1191,9 +1406,59 @@ function parseDossier(row) {
         updatedAt: toText(row.updated_at),
     };
 }
-function isMissingInboxCacheTableError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /no such table: life_inbox_messages|relation ["']?life_inbox_messages["']? does not exist|undefined table/i.test(message);
+function isMissingTableError(error, table) {
+    const message = errorMessagesWithCauses(error).join("\n");
+    const escaped = table.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`no such table: ${escaped}|relation ["']?${escaped}["']? does not exist|undefined table`, "i");
+    return pattern.test(message);
+}
+/**
+ * Probe whether a table exists by running a no-op query against it.
+ *
+ * Boot-order contract: callers MUST run after `adapter.runPluginMigrations`
+ * has completed in `bootstrapSchema`, which already early-returns when the
+ * adapter is missing or `adapter.isReady() === false`. We rely on that
+ * gating; this helper does not re-check.
+ *
+ * SECURITY: `table` is interpolated directly into the SQL. Callers MUST
+ * pass a hardcoded literal, NEVER a user-derived or runtime-derived name.
+ * The current three callers (life_scheduling_negotiations,
+ * life_activity_signals, life_inbox_messages) all pass string literals.
+ *
+ * Failure mode: any error other than the recognized "missing table"
+ * patterns (`isMissingTableError`) rethrows. We deliberately fail loud on
+ * connection / syntax / permission errors rather than silent-skip the
+ * column-repair pass.
+ */
+async function tableExists(runtime, table) {
+    try {
+        await executeRawSql(runtime, `SELECT 1 FROM ${table} WHERE 1=0`);
+        return true;
+    }
+    catch (error) {
+        if (isMissingTableError(error, table)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function errorMessagesWithCauses(error) {
+    const messages = [];
+    let current = error;
+    while (current && typeof current === "object") {
+        if (current instanceof Error) {
+            messages.push(current.message);
+        }
+        const cause = current.cause;
+        if (!cause || cause === current) {
+            break;
+        }
+        current = cause;
+    }
+    if (messages.length === 0) {
+        messages.push(String(error));
+    }
+    return messages;
 }
 export class LifeOpsRepository {
     runtime;
@@ -1237,17 +1502,29 @@ export class LifeOpsRepository {
             force: process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS === "true",
             dryRun: false,
         });
+        await LifeOpsRepository.ensureActivitySignalColumns(runtime);
+        await LifeOpsRepository.ensureSchedulingNegotiationColumns(runtime);
         await LifeOpsRepository.ensureInboxCacheIndexes(runtime);
     }
-    static async ensureInboxCacheIndexes(runtime) {
-        try {
-            await executeRawSql(runtime, "SELECT 1 FROM life_inbox_messages WHERE 1=0");
+    static async ensureSchedulingNegotiationColumns(runtime) {
+        if (!(await tableExists(runtime, "life_scheduling_negotiations"))) {
+            return;
         }
-        catch (error) {
-            if (isMissingInboxCacheTableError(error)) {
-                return;
-            }
-            throw error;
+        await executeRawSql(runtime, "ALTER TABLE life_scheduling_negotiations ADD COLUMN IF NOT EXISTS accepted_proposal_id TEXT");
+    }
+    static async ensureActivitySignalColumns(runtime) {
+        if (!(await tableExists(runtime, "life_activity_signals"))) {
+            return;
+        }
+        await executeRawSql(runtime, "ALTER TABLE life_activity_signals ADD COLUMN IF NOT EXISTS platform TEXT NOT NULL DEFAULT ''");
+        await executeRawSql(runtime, "ALTER TABLE life_activity_signals ADD COLUMN IF NOT EXISTS idle_state TEXT");
+        await executeRawSql(runtime, "ALTER TABLE life_activity_signals ADD COLUMN IF NOT EXISTS idle_time_seconds INTEGER");
+        await executeRawSql(runtime, "ALTER TABLE life_activity_signals ADD COLUMN IF NOT EXISTS on_battery BOOLEAN");
+        await executeRawSql(runtime, "CREATE INDEX IF NOT EXISTS idx_life_activity_signals_agent ON life_activity_signals (agent_id, observed_at)");
+    }
+    static async ensureInboxCacheIndexes(runtime) {
+        if (!(await tableExists(runtime, "life_inbox_messages"))) {
+            return;
         }
         await executeRawSql(runtime, `DELETE FROM life_inbox_messages
         WHERE id IN (
@@ -1264,6 +1541,25 @@ export class LifeOpsRepository {
         )`);
         await executeRawSql(runtime, `CREATE UNIQUE INDEX IF NOT EXISTS idx_life_inbox_messages_agent_channel_external
          ON life_inbox_messages (agent_id, channel, external_id)`);
+        const inboxCacheColumnRepairs = [
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS thread_id TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS sender_email TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS subject TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS deep_link TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS source_ref_json TEXT NOT NULL DEFAULT '{}'",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS chat_type TEXT NOT NULL DEFAULT 'channel'",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS participant_count INTEGER",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS gmail_account_id TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS gmail_account_email TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS last_seen_at TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS replied_at TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS priority_score INTEGER",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS priority_category TEXT",
+            "ALTER TABLE life_inbox_messages ADD COLUMN IF NOT EXISTS priority_flags_json TEXT NOT NULL DEFAULT '[]'",
+        ];
+        for (const statement of inboxCacheColumnRepairs) {
+            await executeRawSql(runtime, statement);
+        }
     }
     async createDefinition(definition) {
         await executeRawSql(this.runtime, `INSERT INTO life_task_definitions (
@@ -2149,6 +2445,242 @@ export class LifeOpsRepository {
         ${limitClause}`);
         return rows.map(parseActivitySignal);
     }
+    async upsertHealthMetricSample(sample) {
+        await executeRawSql(this.runtime, `INSERT INTO life_health_metric_samples (
+        id, agent_id, provider, grant_id, metric, value, unit, start_at, end_at,
+        local_date, source_external_id, metadata_json, created_at, updated_at
+      ) VALUES (
+        ${sqlQuote(sample.id)},
+        ${sqlQuote(sample.agentId)},
+        ${sqlQuote(sample.provider)},
+        ${sqlText(sample.grantId)},
+        ${sqlQuote(sample.metric)},
+        ${sqlNumber(sample.value)},
+        ${sqlQuote(sample.unit)},
+        ${sqlQuote(sample.startAt)},
+        ${sqlQuote(sample.endAt)},
+        ${sqlQuote(sample.localDate)},
+        ${sqlText(sample.sourceExternalId)},
+        ${sqlJson(sample.metadata)},
+        ${sqlQuote(sample.createdAt)},
+        ${sqlQuote(sample.updatedAt)}
+      )
+      ON CONFLICT(agent_id, provider, grant_id, metric, start_at, source_external_id)
+      DO UPDATE SET
+        value = excluded.value,
+        unit = excluded.unit,
+        end_at = excluded.end_at,
+        local_date = excluded.local_date,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`);
+    }
+    async listHealthMetricSamples(agentId, args = {}) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (args.provider) {
+            clauses.push(`provider = ${sqlQuote(args.provider)}`);
+        }
+        if (args.startDate) {
+            clauses.push(`local_date >= ${sqlQuote(args.startDate)}`);
+        }
+        if (args.endDate) {
+            clauses.push(`local_date <= ${sqlQuote(args.endDate)}`);
+        }
+        if (args.metrics && args.metrics.length > 0) {
+            clauses.push(`metric IN (${args.metrics.map((metric) => sqlQuote(metric)).join(", ")})`);
+        }
+        const limitClause = typeof args.limit === "number" && args.limit > 0
+            ? `LIMIT ${Math.trunc(args.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_health_metric_samples
+        WHERE ${clauses.join("\n          AND ")}
+        ORDER BY start_at DESC, metric ASC
+        ${limitClause}`);
+        return rows.map(parseHealthMetricSample);
+    }
+    async upsertHealthWorkout(workout) {
+        await executeRawSql(this.runtime, `INSERT INTO life_health_workouts (
+        id, agent_id, provider, grant_id, source_external_id, workout_type,
+        title, start_at, end_at, duration_seconds, distance_meters, calories,
+        average_heart_rate, max_heart_rate, metadata_json, created_at,
+        updated_at
+      ) VALUES (
+        ${sqlQuote(workout.id)},
+        ${sqlQuote(workout.agentId)},
+        ${sqlQuote(workout.provider)},
+        ${sqlText(workout.grantId)},
+        ${sqlQuote(workout.sourceExternalId)},
+        ${sqlQuote(workout.workoutType)},
+        ${sqlQuote(workout.title)},
+        ${sqlQuote(workout.startAt)},
+        ${sqlText(workout.endAt)},
+        ${sqlInteger(workout.durationSeconds)},
+        ${sqlNumber(workout.distanceMeters)},
+        ${sqlNumber(workout.calories)},
+        ${sqlNumber(workout.averageHeartRate)},
+        ${sqlNumber(workout.maxHeartRate)},
+        ${sqlJson(workout.metadata)},
+        ${sqlQuote(workout.createdAt)},
+        ${sqlQuote(workout.updatedAt)}
+      )
+      ON CONFLICT(agent_id, provider, grant_id, source_external_id) DO UPDATE SET
+        workout_type = excluded.workout_type,
+        title = excluded.title,
+        start_at = excluded.start_at,
+        end_at = excluded.end_at,
+        duration_seconds = excluded.duration_seconds,
+        distance_meters = excluded.distance_meters,
+        calories = excluded.calories,
+        average_heart_rate = excluded.average_heart_rate,
+        max_heart_rate = excluded.max_heart_rate,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`);
+    }
+    async listHealthWorkouts(agentId, args = {}) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (args.provider) {
+            clauses.push(`provider = ${sqlQuote(args.provider)}`);
+        }
+        if (args.startDate) {
+            clauses.push(`start_at >= ${sqlQuote(`${args.startDate}T00:00:00.000Z`)}`);
+        }
+        if (args.endDate) {
+            clauses.push(`start_at <= ${sqlQuote(`${args.endDate}T23:59:59.999Z`)}`);
+        }
+        const limitClause = typeof args.limit === "number" && args.limit > 0
+            ? `LIMIT ${Math.trunc(args.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_health_workouts
+        WHERE ${clauses.join("\n          AND ")}
+        ORDER BY start_at DESC
+        ${limitClause}`);
+        return rows.map(parseHealthWorkout);
+    }
+    async upsertHealthSleepEpisode(episode) {
+        await executeRawSql(this.runtime, `INSERT INTO life_health_sleep_episodes (
+        id, agent_id, provider, grant_id, source_external_id, local_date,
+        timezone, start_at, end_at, is_main_sleep, sleep_type,
+        duration_seconds, time_in_bed_seconds, efficiency, latency_seconds,
+        awake_seconds, light_sleep_seconds, deep_sleep_seconds,
+        rem_sleep_seconds, sleep_score, readiness_score, average_heart_rate,
+        lowest_heart_rate, average_hrv_ms, respiratory_rate,
+        blood_oxygen_percent, stage_samples_json, metadata_json, created_at,
+        updated_at
+      ) VALUES (
+        ${sqlQuote(episode.id)},
+        ${sqlQuote(episode.agentId)},
+        ${sqlQuote(episode.provider)},
+        ${sqlQuote(episode.grantId)},
+        ${sqlQuote(episode.sourceExternalId)},
+        ${sqlQuote(episode.localDate)},
+        ${sqlText(episode.timezone)},
+        ${sqlQuote(episode.startAt)},
+        ${sqlQuote(episode.endAt)},
+        ${sqlBoolean(episode.isMainSleep)},
+        ${sqlText(episode.sleepType)},
+        ${sqlInteger(episode.durationSeconds)},
+        ${sqlInteger(episode.timeInBedSeconds)},
+        ${sqlNumber(episode.efficiency)},
+        ${sqlInteger(episode.latencySeconds)},
+        ${sqlInteger(episode.awakeSeconds)},
+        ${sqlInteger(episode.lightSleepSeconds)},
+        ${sqlInteger(episode.deepSleepSeconds)},
+        ${sqlInteger(episode.remSleepSeconds)},
+        ${sqlNumber(episode.sleepScore)},
+        ${sqlNumber(episode.readinessScore)},
+        ${sqlNumber(episode.averageHeartRate)},
+        ${sqlNumber(episode.lowestHeartRate)},
+        ${sqlNumber(episode.averageHrvMs)},
+        ${sqlNumber(episode.respiratoryRate)},
+        ${sqlNumber(episode.bloodOxygenPercent)},
+        ${sqlJson(episode.stageSamples)},
+        ${sqlJson(episode.metadata)},
+        ${sqlQuote(episode.createdAt)},
+        ${sqlQuote(episode.updatedAt)}
+      )
+      ON CONFLICT(agent_id, provider, grant_id, source_external_id) DO UPDATE SET
+        local_date = excluded.local_date,
+        timezone = excluded.timezone,
+        start_at = excluded.start_at,
+        end_at = excluded.end_at,
+        is_main_sleep = excluded.is_main_sleep,
+        sleep_type = excluded.sleep_type,
+        duration_seconds = excluded.duration_seconds,
+        time_in_bed_seconds = excluded.time_in_bed_seconds,
+        efficiency = excluded.efficiency,
+        latency_seconds = excluded.latency_seconds,
+        awake_seconds = excluded.awake_seconds,
+        light_sleep_seconds = excluded.light_sleep_seconds,
+        deep_sleep_seconds = excluded.deep_sleep_seconds,
+        rem_sleep_seconds = excluded.rem_sleep_seconds,
+        sleep_score = excluded.sleep_score,
+        readiness_score = excluded.readiness_score,
+        average_heart_rate = excluded.average_heart_rate,
+        lowest_heart_rate = excluded.lowest_heart_rate,
+        average_hrv_ms = excluded.average_hrv_ms,
+        respiratory_rate = excluded.respiratory_rate,
+        blood_oxygen_percent = excluded.blood_oxygen_percent,
+        stage_samples_json = excluded.stage_samples_json,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`);
+    }
+    async listHealthSleepEpisodes(agentId, args = {}) {
+        const clauses = [`agent_id = ${sqlQuote(agentId)}`];
+        if (args.provider) {
+            clauses.push(`provider = ${sqlQuote(args.provider)}`);
+        }
+        if (args.startDate) {
+            clauses.push(`local_date >= ${sqlQuote(args.startDate)}`);
+        }
+        if (args.endDate) {
+            clauses.push(`local_date <= ${sqlQuote(args.endDate)}`);
+        }
+        const limitClause = typeof args.limit === "number" && args.limit > 0
+            ? `LIMIT ${Math.trunc(args.limit)}`
+            : "";
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_health_sleep_episodes
+        WHERE ${clauses.join("\n          AND ")}
+        ORDER BY start_at DESC
+        ${limitClause}`);
+        return rows.map(parseHealthSleepEpisode);
+    }
+    async upsertHealthSyncState(state) {
+        await executeRawSql(this.runtime, `INSERT INTO life_health_sync_states (
+        id, agent_id, provider, grant_id, cursor, last_synced_at,
+        last_sync_started_at, last_sync_error, metadata_json, updated_at
+      ) VALUES (
+        ${sqlQuote(state.id)},
+        ${sqlQuote(state.agentId)},
+        ${sqlQuote(state.provider)},
+        ${sqlQuote(state.grantId)},
+        ${sqlText(state.cursor)},
+        ${sqlText(state.lastSyncedAt)},
+        ${sqlText(state.lastSyncStartedAt)},
+        ${sqlText(state.lastSyncError)},
+        ${sqlJson(state.metadata)},
+        ${sqlQuote(state.updatedAt)}
+      )
+      ON CONFLICT(agent_id, provider, grant_id) DO UPDATE SET
+        cursor = excluded.cursor,
+        last_synced_at = excluded.last_synced_at,
+        last_sync_started_at = excluded.last_sync_started_at,
+        last_sync_error = excluded.last_sync_error,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at`);
+    }
+    async getHealthSyncState(agentId, provider, grantId) {
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_health_sync_states
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND provider = ${sqlQuote(provider)}
+          AND grant_id = ${sqlQuote(grantId)}
+        ORDER BY updated_at DESC
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseHealthSyncState(row) : null;
+    }
     async upsertChannelPolicy(policy) {
         await executeRawSql(this.runtime, `INSERT INTO life_channel_policies (
         id, agent_id, channel_type, channel_ref, privacy_class,
@@ -2336,14 +2868,16 @@ export class LifeOpsRepository {
         const row = rows[0];
         return row ? parseConnectorGrant(row) : null;
     }
-    async deleteConnectorGrant(agentId, provider, mode, side) {
+    async deleteConnectorGrant(agentId, provider, mode, side, grantId) {
         const modeClause = mode ? `AND mode = ${sqlQuote(mode)}` : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_connector_grants
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${modeClause}
-          ${sideClause}`);
+          ${sideClause}
+          ${grantClause}`);
     }
     async upsertCalendarEvent(event, side = event.side) {
         await executeRawSql(this.runtime, `INSERT INTO life_calendar_events (
@@ -2510,18 +3044,20 @@ export class LifeOpsRepository {
           ${sideClause}`);
     }
     async upsertGmailMessage(message, side = message.side) {
+        const grantId = requireScopedGmailGrantId(message.grantId);
         await executeRawSql(this.runtime, `INSERT INTO life_gmail_messages (
-        id, agent_id, provider, side, external_message_id, thread_id, subject,
-        from_display, from_email, reply_to, to_json, cc_json, snippet,
-        received_at, is_unread, is_important, likely_reply_needed,
-        triage_score, triage_reason, label_ids_json, html_link, metadata_json,
-        synced_at, updated_at
+        id, agent_id, provider, side, external_message_id, grant_id, thread_id,
+        subject, from_display, from_email, reply_to, to_json, cc_json, snippet,
+        received_at, is_unread, is_important, likely_reply_needed, triage_score,
+        triage_reason, label_ids_json, html_link, metadata_json, synced_at,
+        updated_at
       ) VALUES (
         ${sqlQuote(message.id)},
         ${sqlQuote(message.agentId)},
         ${sqlQuote(message.provider)},
         ${sqlQuote(side)},
         ${sqlQuote(message.externalId)},
+        ${sqlQuote(grantId)},
         ${sqlQuote(message.threadId)},
         ${sqlQuote(message.subject)},
         ${sqlQuote(message.from)},
@@ -2542,7 +3078,8 @@ export class LifeOpsRepository {
         ${sqlQuote(message.syncedAt)},
         ${sqlQuote(message.updatedAt)}
       )
-      ON CONFLICT(agent_id, provider, side, external_message_id) DO UPDATE SET
+      ON CONFLICT(agent_id, provider, side, grant_id, external_message_id) DO UPDATE SET
+        id = excluded.id,
         thread_id = excluded.thread_id,
         subject = excluded.subject,
         from_display = excluded.from_display,
@@ -2563,17 +3100,19 @@ export class LifeOpsRepository {
         synced_at = excluded.synced_at,
         updated_at = excluded.updated_at`);
     }
-    async pruneGmailMessages(agentId, provider, keepExternalIds, side) {
+    async pruneGmailMessages(agentId, provider, keepExternalIds, side, grantId) {
         const keepClause = keepExternalIds.length > 0
             ? `AND external_message_id NOT IN (${keepExternalIds
                 .map((externalId) => sqlQuote(externalId))
                 .join(", ")})`
             : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${sideClause}
+          ${grantClause}
           ${keepClause}`);
     }
     async listGmailMessages(agentId, provider, options, side) {
@@ -2589,24 +3128,30 @@ export class LifeOpsRepository {
             ? `AND received_at >= ${sqlQuote(options.since)}`
             : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = options?.grantId
+            ? `AND grant_id = ${sqlQuote(options.grantId)}`
+            : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${sideClause}
+          ${grantClause}
           ${threadClause}
           ${sinceClause}
         ORDER BY triage_score DESC, received_at DESC
         ${maxResultsClause}`);
         return rows.map(parseGmailMessageSummary);
     }
-    async getGmailMessage(agentId, provider, messageId, side) {
+    async getGmailMessage(agentId, provider, messageId, side, grantId) {
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${sideClause}
+          ${grantClause}
           AND id = ${sqlQuote(messageId)}
         LIMIT 1`);
         const row = rows[0];
@@ -2617,17 +3162,25 @@ export class LifeOpsRepository {
             return;
         const now = isoNow();
         for (const message of messages) {
+            const channel = normalizeInboxChannelValue(message.channel);
+            const sourceRef = normalizeInboxWriteSourceRef(message.sourceRef, channel);
+            const chatType = normalizeInboxChatType(channel, message.chatType, message.participantCount);
+            const hasPriorityFlags = hasOwnPriorityFlags(message);
+            const priorityFlags = normalizeInboxPriorityFlags(message.priorityFlags);
+            const priorityFlagsUpdate = hasPriorityFlags
+                ? "excluded.priority_flags_json"
+                : "life_inbox_messages.priority_flags_json";
             await executeRawSql(this.runtime, `INSERT INTO life_inbox_messages (
           id, agent_id, channel, external_id, thread_id, sender_id,
           sender_display, sender_email, subject, snippet, received_at,
           is_unread, deep_link, source_ref_json, chat_type, participant_count,
-          gmail_account_id, gmail_account_email, priority_score,
+          gmail_account_id, gmail_account_email, last_seen_at, replied_at, priority_score,
           priority_category, priority_flags_json, cached_at, updated_at
         ) VALUES (
           ${sqlQuote(message.id)},
           ${sqlQuote(agentId)},
-          ${sqlQuote(message.channel)},
-          ${sqlQuote(message.sourceRef.externalId)},
+          ${sqlQuote(channel)},
+          ${sqlQuote(sourceRef.externalId)},
           ${sqlText(message.threadId)},
           ${sqlQuote(message.sender.id)},
           ${sqlQuote(message.sender.displayName)},
@@ -2637,14 +3190,16 @@ export class LifeOpsRepository {
           ${sqlQuote(message.receivedAt)},
           ${sqlBoolean(message.unread)},
           ${sqlText(message.deepLink)},
-          ${sqlJson(message.sourceRef)},
-          ${sqlQuote(message.chatType ?? "dm")},
+          ${sqlJson(sourceRef)},
+          ${sqlQuote(chatType)},
           ${sqlInteger(message.participantCount)},
           ${sqlText(message.gmailAccountId)},
           ${sqlText(message.gmailAccountEmail)},
+          ${sqlText(message.lastSeenAt)},
+          ${sqlText(message.repliedAt)},
           ${sqlInteger(message.priorityScore)},
           ${sqlText(message.priorityCategory)},
-          ${sqlJson([])},
+          ${sqlJson(priorityFlags)},
           ${sqlQuote(now)},
           ${sqlQuote(now)}
         )
@@ -2664,19 +3219,19 @@ export class LifeOpsRepository {
           participant_count = excluded.participant_count,
           gmail_account_id = excluded.gmail_account_id,
           gmail_account_email = excluded.gmail_account_email,
+          last_seen_at = COALESCE(excluded.last_seen_at, life_inbox_messages.last_seen_at),
+          replied_at = COALESCE(excluded.replied_at, life_inbox_messages.replied_at),
           priority_score = COALESCE(excluded.priority_score, life_inbox_messages.priority_score),
           priority_category = COALESCE(excluded.priority_category, life_inbox_messages.priority_category),
-          priority_flags_json = CASE
-            WHEN excluded.priority_score IS NULL THEN life_inbox_messages.priority_flags_json
-            ELSE excluded.priority_flags_json
-          END,
+          priority_flags_json = ${priorityFlagsUpdate},
           cached_at = excluded.cached_at,
           updated_at = excluded.updated_at`);
         }
     }
     async listCachedInboxMessages(agentId, options) {
-        const channelClause = options?.channels && options.channels.length > 0
-            ? `AND channel IN (${options.channels
+        const channels = options?.channels?.map((channel) => normalizeInboxChannelValue(channel)) ?? [];
+        const channelClause = channels.length > 0
+            ? `AND channel IN (${channels
                 .map((channel) => sqlQuote(channel))
                 .join(", ")})`
             : "";
@@ -2695,62 +3250,89 @@ export class LifeOpsRepository {
         LIMIT ${sqlInteger(limit)}`);
         return rows.map(parseCachedInboxMessage);
     }
-    async deleteGmailMessages(agentId, provider, messageIds, side) {
+    async markCachedInboxMessageRead(agentId, messageId, readAt = isoNow()) {
+        await executeRawSql(this.runtime, `UPDATE life_inbox_messages
+          SET is_unread = ${sqlBoolean(false)},
+              last_seen_at = ${sqlQuote(readAt)},
+              updated_at = ${sqlQuote(readAt)}
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(messageId)}`);
+        const rows = await executeRawSql(this.runtime, `SELECT *
+         FROM life_inbox_messages
+        WHERE agent_id = ${sqlQuote(agentId)}
+          AND id = ${sqlQuote(messageId)}
+        LIMIT 1`);
+        const row = rows[0];
+        return row ? parseCachedInboxMessage(row) : null;
+    }
+    async deleteGmailMessages(agentId, provider, messageIds, side, grantId) {
         if (messageIds.length === 0) {
             return;
         }
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${sideClause}
+          ${grantClause}
           AND id IN (${messageIds.map((messageId) => sqlQuote(messageId)).join(", ")})`);
     }
-    async deleteGmailMessagesForProvider(agentId, provider, side) {
+    async deleteGmailMessagesForProvider(agentId, provider, side, grantId) {
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_messages
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
-          ${sideClause}`);
+          ${sideClause}
+          ${grantClause}`);
     }
     async upsertGmailSyncState(state) {
+        const grantId = requireScopedGmailGrantId(state.grantId);
         await executeRawSql(this.runtime, `INSERT INTO life_gmail_sync_states (
-        id, agent_id, provider, side, mailbox, max_results, synced_at, updated_at
+        id, agent_id, provider, side, mailbox, grant_id, max_results, synced_at,
+        updated_at
       ) VALUES (
         ${sqlQuote(state.id)},
         ${sqlQuote(state.agentId)},
         ${sqlQuote(state.provider)},
         ${sqlQuote(state.side)},
         ${sqlQuote(state.mailbox)},
+        ${sqlQuote(grantId)},
         ${sqlInteger(state.maxResults)},
         ${sqlQuote(state.syncedAt)},
         ${sqlQuote(state.updatedAt)}
       )
-      ON CONFLICT(agent_id, provider, side, mailbox) DO UPDATE SET
+      ON CONFLICT(agent_id, provider, side, grant_id, mailbox) DO UPDATE SET
+        id = excluded.id,
         max_results = excluded.max_results,
         synced_at = excluded.synced_at,
         updated_at = excluded.updated_at`);
     }
-    async getGmailSyncState(agentId, provider, mailbox, side) {
+    async getGmailSyncState(agentId, provider, mailbox, side, grantId) {
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         const rows = await executeRawSql(this.runtime, `SELECT *
          FROM life_gmail_sync_states
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           AND mailbox = ${sqlQuote(mailbox)}
           ${sideClause}
+          ${grantClause}
         LIMIT 1`);
         const row = rows[0];
         return row ? parseGmailSyncState(row) : null;
     }
-    async deleteGmailSyncState(agentId, provider, mailbox, side) {
+    async deleteGmailSyncState(agentId, provider, mailbox, side, grantId) {
         const mailboxClause = mailbox ? `AND mailbox = ${sqlQuote(mailbox)}` : "";
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_sync_states
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
           ${mailboxClause}
-          ${sideClause}`);
+          ${sideClause}
+          ${grantClause}`);
     }
     async upsertGmailSpamReviewItem(item) {
         await executeRawSql(this.runtime, `INSERT INTO life_gmail_spam_review_items (
@@ -2840,12 +3422,14 @@ export class LifeOpsRepository {
           ${sideClause}
           AND id = ${sqlQuote(itemId)}`);
     }
-    async deleteGmailSpamReviewItemsForProvider(agentId, provider, side) {
+    async deleteGmailSpamReviewItemsForProvider(agentId, provider, side, grantId) {
         const sideClause = side ? `AND side = ${sqlQuote(side)}` : "";
+        const grantClause = grantId ? `AND grant_id = ${sqlQuote(grantId)}` : "";
         await executeRawSql(this.runtime, `DELETE FROM life_gmail_spam_review_items
         WHERE agent_id = ${sqlQuote(agentId)}
           AND provider = ${sqlQuote(provider)}
-          ${sideClause}`);
+          ${sideClause}
+          ${grantClause}`);
     }
     async createWorkflow(definition) {
         await executeRawSql(this.runtime, `INSERT INTO life_workflow_definitions (
@@ -3581,8 +4165,8 @@ export class LifeOpsRepository {
         is_inbound = excluded.is_inbound,
         text = excluded.text,
         received_at = excluded.received_at,
-        read_at = excluded.read_at,
-        replied_at = excluded.replied_at,
+        read_at = COALESCE(excluded.read_at, life_x_dms.read_at),
+        replied_at = COALESCE(excluded.replied_at, life_x_dms.replied_at),
         metadata_json = excluded.metadata_json,
         synced_at = excluded.synced_at,
         updated_at = excluded.updated_at`);
@@ -4515,6 +5099,40 @@ export function createLifeOpsConnectorGrant(params) {
         updatedAt: timestamp,
     };
 }
+export function createLifeOpsHealthMetricSample(params) {
+    const timestamp = isoNow();
+    return {
+        ...params,
+        id: crypto.randomUUID(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    };
+}
+export function createLifeOpsHealthWorkout(params) {
+    const timestamp = isoNow();
+    return {
+        ...params,
+        id: crypto.randomUUID(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    };
+}
+export function createLifeOpsHealthSleepEpisode(params) {
+    const timestamp = isoNow();
+    return {
+        ...params,
+        id: crypto.randomUUID(),
+        createdAt: timestamp,
+        updatedAt: timestamp,
+    };
+}
+export function createLifeOpsHealthSyncState(params) {
+    return {
+        ...params,
+        id: crypto.randomUUID(),
+        updatedAt: isoNow(),
+    };
+}
 export function createLifeOpsCalendarSyncState(params) {
     return {
         ...params,