forge-openclaw-plugin 0.2.68 → 0.2.70

package/dist/server/server/src/health.js

@@ -1,8 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { getDatabase, runInTransaction } from "./db.js";
 import { HttpError } from "./errors.js";
 import { buildWorkoutSessionPersistenceSeed, buildWorkoutSessionPresentation, workoutActivityDescriptorSchema, workoutDetailsSchema } from "./health-workout-adapters.js";
+import { getHealthZoneProfile, getStoredWorkoutAnalytics, getWorkoutRawEvidence, healthZoneProfilePatchSchema, recomputeAndStoreWorkoutAnalytics, upsertWorkoutRoutePoints, upsertWorkoutTimeSeries, workoutCaptureQualitySchema, workoutRoutePointSchema, workoutTimeSeriesSampleSchema, patchHealthZoneProfile } from "./health-workout-analytics.js";
 import { getMovementMobileBootstrap, ingestMovementSync, movementSyncPayloadSchema } from "./movement.js";
 import { ingestScreenTimeSync, screenTimeSyncPayloadSchema } from "./screen-time.js";
 import { recordActivityEvent } from "./repositories/activity-events.js";
@@ -245,6 +246,10 @@ export const mobileHealthSyncSchema = z.object({
         sourceProductType: z.string().trim().optional(),
         activity: workoutActivityDescriptorSchema.optional(),
         details: workoutDetailsSchema.optional(),
+        timeSeriesSamples: z.array(workoutTimeSeriesSampleSchema).default([]),
+        routePoints: z.array(workoutRoutePointSchema).default([]),
+        captureQuality: workoutCaptureQualitySchema.optional(),
+        syncCursor: z.record(z.string(), z.unknown()).default({}),
         links: z.array(healthLinkSchema).default([]),
         annotations: workoutAnnotationSchema.partial().default({})
     }))
@@ -254,6 +259,92 @@ export const mobileHealthSyncSchema = z.object({
     movement: movementSyncPayloadSchema.default({}),
     screenTime: screenTimeSyncPayloadSchema.default({})
 });
+const HEALTH_MOBILE_SYNC_SCHEMA_VERSION = "healthkit-sync-v2";
+const HEALTH_MOBILE_SYNC_CHUNK_TARGET_BYTES = 512_000;
+const HEALTH_MOBILE_SYNC_CHUNK_MAX_BYTES = 1_000_000;
+const HEALTH_MOBILE_SYNC_SESSION_TTL_MS = 1000 * 60 * 60 * 24;
+const mobileHealthSyncFamilySchema = z.enum([
+    "sleep_nights",
+    "sleep_segments",
+    "sleep_raw_records",
+    "workout_summaries",
+    "workout_time_series",
+    "workout_routes",
+    "workout_tombstones",
+    "vitals",
+    "movement",
+    "screen_time"
+]);
+const defaultMobileHealthSyncFamilies = mobileHealthSyncFamilySchema.options;
+export const mobileHealthSyncSessionStartSchema = mobileHealthSyncSchema
+    .pick({
+    sessionId: true,
+    pairingToken: true,
+    device: true,
+    permissions: true,
+    sourceStates: true
+})
+    .extend({
+    schemaVersion: z
+        .string()
+        .trim()
+        .default(HEALTH_MOBILE_SYNC_SCHEMA_VERSION),
+    requestedFamilies: z
+        .array(mobileHealthSyncFamilySchema)
+        .default(defaultMobileHealthSyncFamilies),
+    expectedCounts: z.record(z.string(), z.number().int().nonnegative()).default({}),
+    metadata: z.record(z.string(), z.unknown()).default({})
+});
+const workoutTimeSeriesChunkPayloadSchema = z.object({
+    workouts: z
+        .array(z.object({
+        externalUid: z.string().trim().min(1),
+        samples: z.array(workoutTimeSeriesSampleSchema).default([])
+    }))
+        .default([])
+});
+const workoutRouteChunkPayloadSchema = z.object({
+    workouts: z
+        .array(z.object({
+        externalUid: z.string().trim().min(1),
+        routePoints: z.array(workoutRoutePointSchema).default([])
+    }))
+        .default([])
+});
+const workoutTombstoneChunkPayloadSchema = z.object({
+    workouts: z
+        .array(z.object({
+        externalUid: z.string().trim().min(1),
+        deletedAt: z.string().datetime().nullable().optional(),
+        reason: z.string().trim().default("healthkit_deleted")
+    }))
+        .default([])
+});
+const mobileHealthSyncChunkPayloadSchema = z.object({
+    sleepNights: mobileHealthSyncSchema.shape.sleepNights.optional(),
+    sleepSegments: mobileHealthSyncSchema.shape.sleepSegments.optional(),
+    sleepRawRecords: mobileHealthSyncSchema.shape.sleepRawRecords.optional(),
+    workouts: mobileHealthSyncSchema.shape.workouts.optional(),
+    workoutTimeSeries: workoutTimeSeriesChunkPayloadSchema.shape.workouts.optional(),
+    workoutRoutes: workoutRouteChunkPayloadSchema.shape.workouts.optional(),
+    workoutTombstones: workoutTombstoneChunkPayloadSchema.shape.workouts.optional(),
+    vitals: vitalsSyncPayloadSchema.optional(),
+    movement: movementSyncPayloadSchema.optional(),
+    screenTime: screenTimeSyncPayloadSchema.optional()
+});
+export const mobileHealthSyncChunkSchema = z.object({
+    chunkId: z.string().trim().min(1),
+    sequence: z.number().int().nonnegative(),
+    family: mobileHealthSyncFamilySchema,
+    recordCount: z.number().int().nonnegative().default(0),
+    byteCount: z.number().int().nonnegative().default(0),
+    checksumSha256: z.string().trim().min(1),
+    payload: mobileHealthSyncChunkPayloadSchema.default({})
+});
+export const mobileHealthSyncSessionCompleteSchema = z.object({
+    finalCursor: z.record(z.string(), z.unknown()).default({}),
+    expectedCounts: z.record(z.string(), z.number().int().nonnegative()).default({})
+});
 export const verifyCompanionPairingSchema = z.object({
     sessionId: z.string().trim().min(1),
     pairingToken: z.string().trim().min(1),
@@ -788,6 +879,7 @@ function mapSleepRawLog(row) {
 function mapWorkoutSession(row) {
     const provenance = safeJsonParse(row.provenance_json, {});
     const derived = safeJsonParse(row.derived_json, {});
+    const analytics = getStoredWorkoutAnalytics(row);
     const presentation = buildWorkoutSessionPresentation({
         source: row.source,
         sourceType: row.source_type,
@@ -833,6 +925,7 @@ function mapWorkoutSession(row) {
         annotations: safeJsonParse(row.annotations_json, {}),
         provenance,
         derived,
+        analytics,
         generatedFromHabitId: row.generated_from_habit_id,
         generatedFromCheckInId: row.generated_from_check_in_id,
         reconciliationStatus: row.reconciliation_status,
@@ -1352,6 +1445,28 @@ export function getWorkoutSessionById(workoutId) {
         .get(workoutId);
     return row ? mapWorkoutSession(row) : undefined;
 }
+export function getWorkoutSessionDetailById(workoutId, resolution = "adaptive") {
+    const row = getDatabase()
+        .prepare(`SELECT * FROM health_workout_sessions WHERE id = ?`)
+        .get(workoutId);
+    if (!row) {
+        return undefined;
+    }
+    const workout = mapWorkoutSession(row);
+    return {
+        workout,
+        analytics: getStoredWorkoutAnalytics(row),
+        evidence: getWorkoutRawEvidence(row, resolution),
+        zoneProfile: getHealthZoneProfile(row.user_id)
+    };
+}
+export { healthZoneProfilePatchSchema };
+export function getHealthZoneProfileForUser(userId) {
+    return getHealthZoneProfile(userId);
+}
+export function patchHealthZoneProfileForUser(userId, patch) {
+    return patchHealthZoneProfile(userId, patch);
+}
 function listPairingRows(userIds) {
     const params = [];
     const where = userIds && userIds.length > 0
@@ -2072,6 +2187,7 @@ function insertOrUpdateWorkoutSession(pairing, input) {
                 ? Number((input.distanceMeters / input.exerciseMinutes).toFixed(2))
                 : null
         }), matchedGenerated.generated_from_habit_id ? "merged" : "standalone", now, matchedGenerated.id);
+        persistWorkoutEvidenceForInput(matchedGenerated.id, pairing.user_id, input);
         return {
             mode: matchedGenerated.generated_from_habit_id || matchedGenerated.source !== "apple_health"
                 ? "merged"
@@ -2105,8 +2221,43 @@ function insertOrUpdateWorkoutSession(pairing, input) {
             ? Number((input.distanceMeters / input.exerciseMinutes).toFixed(2))
             : null
     }), now, now);
+    persistWorkoutEvidenceForInput(id, pairing.user_id, input);
     return { mode: "created", id };
 }
+function persistWorkoutEvidenceForInput(workoutId, userId, input) {
+    if (input.timeSeriesSamples.length > 0) {
+        upsertWorkoutTimeSeries({
+            workoutId,
+            userId,
+            samples: input.timeSeriesSamples
+        });
+    }
+    if (input.routePoints.length > 0) {
+        upsertWorkoutRoutePoints({
+            workoutId,
+            userId,
+            points: input.routePoints
+        });
+    }
+    const row = getDatabase()
+        .prepare(`SELECT * FROM health_workout_sessions WHERE id = ?`)
+        .get(workoutId);
+    if (row) {
+        recomputeAndStoreWorkoutAnalytics(row);
+        if (input.captureQuality) {
+            const derived = safeJsonParse(row.derived_json, {});
+            getDatabase()
+                .prepare(`UPDATE health_workout_sessions
+           SET derived_json = ?, updated_at = ?
+           WHERE id = ?`)
+                .run(JSON.stringify({
+                ...derived,
+                captureQuality: input.captureQuality,
+                syncCursor: input.syncCursor
+            }), nowIso(), workoutId);
+        }
+    }
+}
 function clusterSleepRowsByGap(rows) {
     const clusters = [];
     let currentCluster = [];
@@ -2497,6 +2648,415 @@ function replaceHistoricalSleepSessionsForDate(userId, localDateKey, providerBac
             .run(historical.id);
     }
 }
+function mobileSyncSessionId() {
+    return `hms_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+}
+function mobileSyncChunkRecordId() {
+    return `hmsc_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+}
+function expireStaleMobileSyncSessions() {
+    const cutoff = new Date(Date.now() - HEALTH_MOBILE_SYNC_SESSION_TTL_MS).toISOString();
+    const now = nowIso();
+    getDatabase()
+        .prepare(`UPDATE health_mobile_sync_sessions
+       SET status = 'expired', expired_at = ?, updated_at = ?
+       WHERE status = 'running' AND started_at < ?`)
+        .run(now, now, cutoff);
+}
+function readMobileSyncSession(syncSessionId) {
+    return getDatabase()
+        .prepare(`SELECT * FROM health_mobile_sync_sessions WHERE id = ?`)
+        .get(syncSessionId);
+}
+function ensureRunningMobileSyncSession(syncSessionId) {
+    expireStaleMobileSyncSessions();
+    const session = readMobileSyncSession(syncSessionId);
+    if (!session) {
+        throw new HttpError(404, "sync_session_not_found", "The HealthKit sync session does not exist.");
+    }
+    if (session.status !== "running") {
+        throw new HttpError(409, "sync_session_closed", "The HealthKit sync session is no longer accepting chunks.", { status: session.status });
+    }
+    return session;
+}
+function chunkPayloadJson(payload) {
+    return JSON.stringify(payload);
+}
+function chunkPayloadChecksum(payloadJson) {
+    return createHash("sha256").update(payloadJson).digest("hex");
+}
+function summarizeChunkPayload(family, payload) {
+    switch (family) {
+        case "sleep_nights":
+            return { sleepNights: payload.sleepNights?.length ?? 0 };
+        case "sleep_segments":
+            return { sleepSegments: payload.sleepSegments?.length ?? 0 };
+        case "sleep_raw_records":
+            return { sleepRawRecords: payload.sleepRawRecords?.length ?? 0 };
+        case "workout_summaries":
+            return { workouts: payload.workouts?.length ?? 0 };
+        case "workout_time_series":
+            return {
+                workouts: payload.workoutTimeSeries?.length ?? 0,
+                samples: payload.workoutTimeSeries?.reduce((sum, entry) => sum + entry.samples.length, 0) ?? 0
+            };
+        case "workout_routes":
+            return {
+                workouts: payload.workoutRoutes?.length ?? 0,
+                routePoints: payload.workoutRoutes?.reduce((sum, entry) => sum + entry.routePoints.length, 0) ?? 0
+            };
+        case "workout_tombstones":
+            return { workouts: payload.workoutTombstones?.length ?? 0 };
+        case "vitals":
+            return { daySummaries: payload.vitals?.daySummaries.length ?? 0 };
+        case "movement":
+            return {
+                stays: payload.movement?.stays.length ?? 0,
+                trips: payload.movement?.trips.length ?? 0
+            };
+        case "screen_time":
+            return {
+                daySummaries: payload.screenTime?.daySummaries.length ?? 0,
+                hourlySegments: payload.screenTime?.hourlySegments.length ?? 0
+            };
+    }
+}
+function updateMobileSyncSessionProgress(syncSessionId) {
+    const chunks = getDatabase()
+        .prepare(`SELECT family, record_count, byte_count
+       FROM health_mobile_sync_chunks
+       WHERE sync_session_id = ?`)
+        .all(syncSessionId);
+    const receivedCounts = {};
+    const byteTotals = {};
+    for (const chunk of chunks) {
+        receivedCounts[chunk.family] =
+            (receivedCounts[chunk.family] ?? 0) + chunk.record_count;
+        byteTotals[chunk.family] =
+            (byteTotals[chunk.family] ?? 0) + chunk.byte_count;
+    }
+    getDatabase()
+        .prepare(`UPDATE health_mobile_sync_sessions
+       SET received_counts_json = ?, byte_totals_json = ?, updated_at = ?
+       WHERE id = ?`)
+        .run(JSON.stringify(receivedCounts), JSON.stringify(byteTotals), nowIso(), syncSessionId);
+    return {
+        receivedCounts,
+        byteTotals,
+        chunkCount: chunks.length,
+        receivedBytes: chunks.reduce((sum, chunk) => sum + chunk.byte_count, 0)
+    };
+}
+export function startMobileHealthSyncSession(payload) {
+    const parsed = mobileHealthSyncSessionStartSchema.parse(payload);
+    if (parsed.schemaVersion !== HEALTH_MOBILE_SYNC_SCHEMA_VERSION) {
+        throw new HttpError(409, "schema_version_unsupported", "The companion HealthKit sync protocol is not supported by this Forge runtime.", {
+            schemaVersion: HEALTH_MOBILE_SYNC_SCHEMA_VERSION,
+            requestedSchemaVersion: parsed.schemaVersion
+        });
+    }
+    expireStaleMobileSyncSessions();
+    const pairing = requireValidPairing(parsed.sessionId, parsed.pairingToken);
+    const resumeSyncSessionId = typeof parsed.metadata.resumeSyncSessionId === "string"
+        ? parsed.metadata.resumeSyncSessionId.trim()
+        : "";
+    if (resumeSyncSessionId.length > 0) {
+        const existing = readMobileSyncSession(resumeSyncSessionId);
+        if (existing &&
+            existing.pairing_session_id === pairing.id &&
+            existing.status === "running") {
+            const receivedChunkIds = getDatabase()
+                .prepare(`SELECT chunk_id
+           FROM health_mobile_sync_chunks
+           WHERE sync_session_id = ?
+           ORDER BY sequence ASC`)
+                .all(resumeSyncSessionId)
+                .map((row) => row.chunk_id);
+            return {
+                syncSessionId: resumeSyncSessionId,
+                schemaVersion: HEALTH_MOBILE_SYNC_SCHEMA_VERSION,
+                chunkTargetBytes: HEALTH_MOBILE_SYNC_CHUNK_TARGET_BYTES,
+                chunkMaxBytes: HEALTH_MOBILE_SYNC_CHUNK_MAX_BYTES,
+                supportsCompression: false,
+                acceptedFamilies: safeJsonParse(existing.requested_families_json, parsed.requestedFamilies),
+                receivedChunkIds
+            };
+        }
+    }
+    const now = nowIso();
+    const syncSessionId = mobileSyncSessionId();
+    getDatabase()
+        .prepare(`INSERT INTO health_mobile_sync_sessions (
+         id, pairing_session_id, user_id, status, schema_version,
+         requested_families_json, source_metadata_json, expected_counts_json,
+         received_counts_json, byte_totals_json, started_at, created_at, updated_at
+       )
+       VALUES (?, ?, ?, 'running', ?, ?, ?, ?, '{}', '{}', ?, ?, ?)`)
+        .run(syncSessionId, pairing.id, pairing.user_id, HEALTH_MOBILE_SYNC_SCHEMA_VERSION, JSON.stringify(parsed.requestedFamilies), JSON.stringify({
+        sessionId: parsed.sessionId,
+        device: parsed.device,
+        permissions: parsed.permissions,
+        sourceStates: parsed.sourceStates,
+        metadata: parsed.metadata
+    }), JSON.stringify(parsed.expectedCounts), now, now, now);
+    return {
+        syncSessionId,
+        schemaVersion: HEALTH_MOBILE_SYNC_SCHEMA_VERSION,
+        chunkTargetBytes: HEALTH_MOBILE_SYNC_CHUNK_TARGET_BYTES,
+        chunkMaxBytes: HEALTH_MOBILE_SYNC_CHUNK_MAX_BYTES,
+        supportsCompression: false,
+        acceptedFamilies: parsed.requestedFamilies,
+        receivedChunkIds: []
+    };
+}
+export function ingestMobileHealthSyncChunk(syncSessionId, payload, rawPayloadJson) {
+    const parsed = mobileHealthSyncChunkSchema.parse(payload);
+    const session = ensureRunningMobileSyncSession(syncSessionId);
+    const requestedFamilies = safeJsonParse(session.requested_families_json, []);
+    if (requestedFamilies.length > 0 &&
+        !requestedFamilies.includes(parsed.family)) {
+        throw new HttpError(400, "unsupported_family", "This sync session did not request that HealthKit family.", { family: parsed.family });
+    }
+    const existing = getDatabase()
+        .prepare(`SELECT * FROM health_mobile_sync_chunks
+       WHERE sync_session_id = ? AND chunk_id = ?`)
+        .get(syncSessionId, parsed.chunkId);
+    if (existing) {
+        if (existing.checksum_sha256 !== parsed.checksumSha256) {
+            throw new HttpError(409, "chunk_checksum_mismatch", "A chunk with the same id was already accepted with different content.");
+        }
+        const progress = updateMobileSyncSessionProgress(syncSessionId);
+        return {
+            accepted: true,
+            duplicate: true,
+            receivedCount: progress.chunkCount,
+            receivedBytes: progress.receivedBytes,
+            progress
+        };
+    }
+    const payloadJson = chunkPayloadJson(parsed.payload);
+    const checksumPayloadJson = rawPayloadJson ?? payloadJson;
+    const actualByteCount = Buffer.byteLength(checksumPayloadJson, "utf8");
+    if (actualByteCount > HEALTH_MOBILE_SYNC_CHUNK_MAX_BYTES) {
+        throw new HttpError(413, "chunk_too_large", "The HealthKit sync chunk is too large.", {
+            maxBytes: HEALTH_MOBILE_SYNC_CHUNK_MAX_BYTES,
+            actualBytes: actualByteCount
+        });
+    }
+    const serverChecksum = chunkPayloadChecksum(checksumPayloadJson);
+    if (parsed.checksumSha256 !== serverChecksum) {
+        throw new HttpError(409, "chunk_checksum_mismatch", "The HealthKit sync chunk checksum does not match its payload.", { actualBytes: actualByteCount });
+    }
+    const now = nowIso();
+    getDatabase()
+        .prepare(`INSERT INTO health_mobile_sync_chunks (
+         id, sync_session_id, chunk_id, sequence, family, checksum_sha256,
+         record_count, byte_count, payload_json, payload_summary_json,
+         received_at, applied_at, created_at, updated_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(mobileSyncChunkRecordId(), syncSessionId, parsed.chunkId, parsed.sequence, parsed.family, serverChecksum, parsed.recordCount, parsed.byteCount || actualByteCount, payloadJson, JSON.stringify({
+        ...summarizeChunkPayload(parsed.family, parsed.payload),
+        clientByteCount: parsed.byteCount,
+        actualByteCount,
+        serverChecksum
+    }), now, now, now, now);
+    const progress = updateMobileSyncSessionProgress(syncSessionId);
+    return {
+        accepted: true,
+        duplicate: false,
+        receivedCount: progress.chunkCount,
+        receivedBytes: progress.receivedBytes,
+        progress
+    };
+}
+function mergeMobileHealthSyncChunks(session, chunks) {
+    const pairing = getDatabase()
+        .prepare(`SELECT * FROM companion_pairing_sessions WHERE id = ?`)
+        .get(session.pairing_session_id);
+    if (!pairing) {
+        throw new HttpError(404, "pairing_invalid", "The sync pairing no longer exists.");
+    }
+    const metadata = safeJsonParse(session.source_metadata_json, {});
+    const assembled = mobileHealthSyncSchema.parse({
+        sessionId: metadata.sessionId ?? pairing.id,
+        pairingToken: pairing.pairing_token,
+        device: metadata.device ??
+            {
+                name: pairing.device_name ?? "iPhone",
+                platform: pairing.platform ?? "ios",
+                appVersion: pairing.app_version ?? "",
+                sourceDevice: pairing.device_name ?? "iPhone"
+            },
+        permissions: metadata.permissions ??
+            {
+                healthKitAuthorized: false,
+                backgroundRefreshEnabled: false,
+                motionReady: false,
+                locationReady: false,
+                screenTimeReady: false
+            },
+        sourceStates: metadata.sourceStates,
+        sleepSessions: [],
+        sleepNights: [],
+        sleepSegments: [],
+        sleepRawRecords: [],
+        workouts: [],
+        vitals: { daySummaries: [] },
+        movement: {},
+        screenTime: {}
+    });
+    const workoutsByExternalUid = new Map();
+    const tombstones = [];
+    for (const chunk of chunks.sort((left, right) => left.sequence - right.sequence)) {
+        const payload = mobileHealthSyncChunkPayloadSchema.parse(safeJsonParse(chunk.payload_json, {}));
+        if (payload.sleepNights) {
+            assembled.sleepNights.push(...payload.sleepNights);
+        }
+        if (payload.sleepSegments) {
+            assembled.sleepSegments.push(...payload.sleepSegments);
+        }
+        if (payload.sleepRawRecords) {
+            assembled.sleepRawRecords.push(...payload.sleepRawRecords);
+        }
+        if (payload.workouts) {
+            for (const workout of payload.workouts) {
+                const previous = workoutsByExternalUid.get(workout.externalUid);
+                workoutsByExternalUid.set(workout.externalUid, {
+                    ...(previous ?? workout),
+                    ...workout,
+                    timeSeriesSamples: [
+                        ...(previous?.timeSeriesSamples ?? []),
+                        ...workout.timeSeriesSamples
+                    ],
+                    routePoints: [
+                        ...(previous?.routePoints ?? []),
+                        ...workout.routePoints
+                    ]
+                });
+            }
+        }
+        if (payload.workoutTimeSeries) {
+            for (const entry of payload.workoutTimeSeries) {
+                const workout = workoutsByExternalUid.get(entry.externalUid);
+                if (!workout) {
+                    throw new HttpError(409, "missing_required_chunks", "A workout time-series chunk arrived without a matching workout summary.", { workoutExternalUid: entry.externalUid });
+                }
+                workout.timeSeriesSamples.push(...entry.samples);
+            }
+        }
+        if (payload.workoutRoutes) {
+            for (const entry of payload.workoutRoutes) {
+                const workout = workoutsByExternalUid.get(entry.externalUid);
+                if (!workout) {
+                    throw new HttpError(409, "missing_required_chunks", "A workout route chunk arrived without a matching workout summary.", { workoutExternalUid: entry.externalUid });
+                }
+                workout.routePoints.push(...entry.routePoints);
+            }
+        }
+        if (payload.workoutTombstones) {
+            tombstones.push(...payload.workoutTombstones);
+        }
+        if (payload.vitals) {
+            assembled.vitals.daySummaries.push(...payload.vitals.daySummaries);
+        }
+        if (payload.movement) {
+            assembled.movement.settings = payload.movement.settings;
+            assembled.movement.knownPlaces.push(...payload.movement.knownPlaces);
+            assembled.movement.stays.push(...payload.movement.stays);
+            assembled.movement.trips.push(...payload.movement.trips);
+        }
+        if (payload.screenTime) {
+            assembled.screenTime.settings = payload.screenTime.settings;
+            assembled.screenTime.daySummaries.push(...payload.screenTime.daySummaries);
+            assembled.screenTime.hourlySegments.push(...payload.screenTime.hourlySegments);
+        }
+    }
+    assembled.workouts = [...workoutsByExternalUid.values()].sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+    return { assembled, tombstones };
+}
+function applyWorkoutTombstones(pairing, tombstones) {
+    if (tombstones.length === 0) {
+        return 0;
+    }
+    const deleteStmt = getDatabase().prepare(`DELETE FROM health_workout_sessions
+     WHERE user_id = ? AND source = 'apple_health' AND external_uid = ?`);
+    let deleted = 0;
+    for (const tombstone of tombstones) {
+        const result = deleteStmt.run(pairing.user_id, tombstone.externalUid);
+        deleted += Number(result.changes ?? 0);
+    }
+    return deleted;
+}
+function upsertMobileSyncFamilyCursors(pairing, finalCursor) {
+    const now = nowIso();
+    const stmt = getDatabase().prepare(`INSERT INTO health_mobile_sync_family_cursors (
+       id, pairing_session_id, user_id, family, cursor_json, updated_at
+     )
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(pairing_session_id, family)
+     DO UPDATE SET cursor_json = excluded.cursor_json, updated_at = excluded.updated_at`);
+    for (const [family, cursor] of Object.entries(finalCursor)) {
+        stmt.run(`hmscur_${randomUUID().replaceAll("-", "").slice(0, 10)}`, pairing.id, pairing.user_id, family, JSON.stringify(cursor), now);
+    }
+}
+export function completeMobileHealthSyncSession(syncSessionId, payload) {
+    const parsed = mobileHealthSyncSessionCompleteSchema.parse(payload);
+    const session = ensureRunningMobileSyncSession(syncSessionId);
+    const chunks = getDatabase()
+        .prepare(`SELECT * FROM health_mobile_sync_chunks
+       WHERE sync_session_id = ?
+       ORDER BY sequence ASC`)
+        .all(syncSessionId);
+    if (chunks.length === 0) {
+        throw new HttpError(409, "missing_required_chunks", "The HealthKit sync session has no accepted chunks.");
+    }
+    const pairing = getDatabase()
+        .prepare(`SELECT * FROM companion_pairing_sessions WHERE id = ?`)
+        .get(session.pairing_session_id);
+    try {
+        const { assembled, tombstones } = mergeMobileHealthSyncChunks(session, chunks);
+        const sync = ingestMobileHealthSync(assembled);
+        const deletedWorkoutCount = applyWorkoutTombstones(pairing, tombstones);
+        upsertMobileSyncFamilyCursors(pairing, parsed.finalCursor);
+        const now = nowIso();
+        getDatabase()
+            .prepare(`UPDATE health_mobile_sync_sessions
+         SET status = 'completed', expected_counts_json = ?, completed_at = ?,
+             updated_at = ?
+         WHERE id = ?`)
+            .run(JSON.stringify(parsed.expectedCounts), now, now, syncSessionId);
+        return {
+            ...sync,
+            upload: {
+                syncSessionId,
+                chunks: chunks.length,
+                deletedWorkoutCount
+            }
+        };
+    }
+    catch (error) {
+        const now = nowIso();
+        getDatabase()
+            .prepare(`UPDATE health_mobile_sync_sessions
+         SET status = 'failed', failed_at = ?, error_json = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(now, JSON.stringify({
+            message: error instanceof Error ? error.message : String(error)
+        }), now, syncSessionId);
+        throw error;
+    }
+}
+export function abortMobileHealthSyncSession(syncSessionId) {
+    const session = ensureRunningMobileSyncSession(syncSessionId);
+    const now = nowIso();
+    getDatabase()
+        .prepare(`UPDATE health_mobile_sync_sessions
+       SET status = 'aborted', aborted_at = ?, updated_at = ?
+       WHERE id = ?`)
+        .run(now, now, session.id);
+    return { syncSessionId, status: "aborted" };
+}
 export function ingestMobileHealthSync(payload) {
     const parsed = mobileHealthSyncSchema.parse(payload);
     ensureLegacyAppleSleepHistoryRepaired();
@@ -2920,6 +3480,42 @@ export function getFitnessViewData(userIds) {
         workoutTypeBreakdown.set(session.workoutType, current);
     }
     const orderedWorkoutTypes = [...workoutTypeBreakdown.entries()].sort((left, right) => right[1].totalMinutes - left[1].totalMinutes);
+    const zoneTotals = new Map();
+    let totalZoneSeconds = 0;
+    let heartRateCoverageSum = 0;
+    let heartRateCoverageCount = 0;
+    let totalTrainingLoad = 0;
+    let routeWorkoutCount = 0;
+    for (const session of recent) {
+        const analytics = session.analytics;
+        for (const zone of analytics?.zoneDurations ?? []) {
+            const current = zoneTotals.get(zone.key) ?? {
+                label: zone.label,
+                seconds: 0
+            };
+            current.seconds += zone.seconds;
+            totalZoneSeconds += zone.seconds;
+            zoneTotals.set(zone.key, current);
+        }
+        if (typeof analytics?.dataQuality?.sampleCoverage === "number") {
+            heartRateCoverageSum += analytics.dataQuality.sampleCoverage;
+            heartRateCoverageCount += 1;
+        }
+        if (typeof analytics?.load?.trimp === "number") {
+            totalTrainingLoad += analytics.load.trimp;
+        }
+        if (analytics?.routeSummary?.hasRoute) {
+            routeWorkoutCount += 1;
+        }
+    }
+    const zoneMix = [...zoneTotals.entries()].map(([key, value]) => ({
+        key,
+        label: value.label,
+        seconds: Math.round(value.seconds),
+        percentage: totalZoneSeconds > 0
+            ? Number((value.seconds / totalZoneSeconds).toFixed(4))
+            : 0
+    }));
     return {
         summary: {
             workoutCount: weekly.length,
@@ -2940,7 +3536,13 @@ export function getFitnessViewData(userIds) {
             topWorkoutType: orderedWorkoutTypes[0]?.[0] ?? null,
             topWorkoutTypeLabel: recent.find((session) => session.workoutType === orderedWorkoutTypes[0]?.[0])
                 ?.workoutTypeLabel ?? null,
-            streakDays: Array.from(new Set(weekly.map((session) => dayKey(session.startedAt)))).length
+            streakDays: Array.from(new Set(weekly.map((session) => dayKey(session.startedAt)))).length,
+            averageHeartRateCoverage: heartRateCoverageCount > 0
+                ? Number((heartRateCoverageSum / heartRateCoverageCount).toFixed(3))
+                : 0,
+            totalTrainingLoad: Number(totalTrainingLoad.toFixed(1)),
+            routeWorkoutCount,
+            zoneMix
         },
         weeklyTrend: weekly
             .map((session) => ({
@@ -2951,7 +3553,12 @@ export function getFitnessViewData(userIds) {
             activityFamily: session.activityFamily,
             activityFamilyLabel: session.activityFamilyLabel,
             durationMinutes: Math.round(session.durationSeconds / 60),
-            energyKcal: Math.round(session.totalEnergyKcal ?? session.activeEnergyKcal ?? 0)
+            energyKcal: Math.round(session.totalEnergyKcal ?? session.activeEnergyKcal ?? 0),
+            zoneDurations: session.analytics
+                ?.zoneDurations ?? [],
+            trainingLoad: (session.analytics
+                ?.load?.trimp ?? null),
+            heartRateCoverage: (session.analytics?.dataQuality?.sampleCoverage ?? 0)
         }))
             .reverse(),
         typeBreakdown: orderedWorkoutTypes.map(([workoutType, metrics]) => ({
@@ -3482,6 +4089,7 @@ export function deleteWorkoutSession(workoutId, activity) {
     if (!current) {
         return undefined;
     }
+    const deletedWorkout = mapWorkoutSession(current);
     getDatabase()
         .prepare(`DELETE FROM health_workout_sessions WHERE id = ?`)
         .run(workoutId);
@@ -3499,7 +4107,7 @@ export function deleteWorkoutSession(workoutId, activity) {
             startedAt: current.started_at
         }
     });
-    return mapWorkoutSession(current);
+    return deletedWorkout;
 }
 export function updateWorkoutMetadata(workoutId, patch, activity) {
     const parsed = updateWorkoutMetadataSchema.parse(patch);