forge-openclaw-plugin 0.2.67 → 0.2.69

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

@@ -3,6 +3,7 @@ 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({})
     }))
@@ -788,6 +793,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 +839,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 +1359,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 +2101,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 +2135,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 = [];
@@ -2920,6 +2985,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 +3041,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 +3058,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 +3594,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 +3612,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);

package/dist/server/server/src/openapi.js

@@ -4645,6 +4645,224 @@ export function buildOpenApiDocument() {
             updatedAt: { type: "string", format: "date-time" }
         }
     };
+    const devrageMetricPayload = {
+        type: "object",
+        additionalProperties: false,
+        required: [
+            "generatedAt",
+            "hasData",
+            "latestDateKey",
+            "rawSwearCount",
+            "swearingMessagePercent",
+            "conversationsScanned",
+            "messagesScanned",
+            "messagesWithSwears",
+            "dailyAverage",
+            "weeklyAverage",
+            "history",
+            "sync"
+        ],
+        properties: {
+            generatedAt: { type: "string", format: "date-time" },
+            hasData: { type: "boolean" },
+            latestDateKey: nullable({ type: "string" }),
+            rawSwearCount: { type: "number" },
+            swearingMessagePercent: { type: "number" },
+            conversationsScanned: { type: "integer" },
+            messagesScanned: { type: "integer" },
+            messagesWithSwears: { type: "integer" },
+            dailyAverage: {
+                type: "object",
+                additionalProperties: false,
+                required: ["rawSwearCount", "swearingMessagePercent"],
+                properties: {
+                    rawSwearCount: { type: "number" },
+                    swearingMessagePercent: { type: "number" }
+                }
+            },
+            weeklyAverage: {
+                type: "object",
+                additionalProperties: false,
+                required: ["rawSwearCount", "swearingMessagePercent"],
+                properties: {
+                    rawSwearCount: { type: "number" },
+                    swearingMessagePercent: { type: "number" }
+                }
+            },
+            history: arrayOf({
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "dateKey",
+                    "rawSwearCount",
+                    "swearingMessagePercent",
+                    "conversationsScanned",
+                    "messagesScanned",
+                    "messagesWithSwears"
+                ],
+                properties: {
+                    dateKey: { type: "string" },
+                    rawSwearCount: { type: "number" },
+                    swearingMessagePercent: { type: "number" },
+                    conversationsScanned: { type: "integer" },
+                    messagesScanned: { type: "integer" },
+                    messagesWithSwears: { type: "integer" }
+                }
+            }),
+            sync: {
+                type: "object",
+                additionalProperties: false,
+                required: ["fullSyncCompletedAt", "lastDailySyncAt", "lastSyncedDateKey"],
+                properties: {
+                    fullSyncCompletedAt: nullable({ type: "string", format: "date-time" }),
+                    lastDailySyncAt: nullable({ type: "string", format: "date-time" }),
+                    lastSyncedDateKey: nullable({ type: "string" })
+                }
+            }
+        }
+    };
+    const dailyMetricDayRecord = {
+        type: "object",
+        additionalProperties: false,
+        required: [
+            "dateKey",
+            "average",
+            "minimum",
+            "maximum",
+            "latest",
+            "total",
+            "sampleCount",
+            "latestSampleAt"
+        ],
+        properties: {
+            dateKey: { type: "string" },
+            average: nullable({ type: "number" }),
+            minimum: nullable({ type: "number" }),
+            maximum: nullable({ type: "number" }),
+            latest: nullable({ type: "number" }),
+            total: nullable({ type: "number" }),
+            sampleCount: { type: "integer" },
+            latestSampleAt: nullable({ type: "string", format: "date-time" })
+        }
+    };
+    const dailyMetricRecord = {
+        type: "object",
+        additionalProperties: false,
+        required: [
+            "metric",
+            "label",
+            "category",
+            "unit",
+            "aggregation",
+            "latestValue",
+            "latestDateKey",
+            "baselineValue",
+            "deltaValue",
+            "coverageDays",
+            "days"
+        ],
+        properties: {
+            metric: { type: "string" },
+            label: { type: "string" },
+            category: { type: "string" },
+            unit: { type: "string" },
+            aggregation: { type: "string", enum: ["discrete", "cumulative"] },
+            latestValue: nullable({ type: "number" }),
+            latestDateKey: nullable({ type: "string" }),
+            baselineValue: nullable({ type: "number" }),
+            deltaValue: nullable({ type: "number" }),
+            coverageDays: { type: "integer" },
+            days: arrayOf(dailyMetricDayRecord)
+        }
+    };
+    const psycheMetricsViewData = {
+        type: "object",
+        additionalProperties: false,
+        required: ["summary", "context", "metrics"],
+        properties: {
+            summary: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "hasData",
+                    "trackedDays",
+                    "metricCount",
+                    "latestDateKey",
+                    "latestMetricCount",
+                    "categoryBreakdown"
+                ],
+                properties: {
+                    hasData: { type: "boolean" },
+                    trackedDays: { type: "integer" },
+                    metricCount: { type: "integer" },
+                    latestDateKey: nullable({ type: "string" }),
+                    latestMetricCount: { type: "integer" },
+                    categoryBreakdown: arrayOf({
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["category", "metricCount", "coverageDays"],
+                        properties: {
+                            category: { type: "string" },
+                            metricCount: { type: "integer" },
+                            coverageDays: { type: "integer" }
+                        }
+                    })
+                }
+            },
+            context: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "generatedAt",
+                    "conversationsScanned",
+                    "sourceCount",
+                    "messagesScanned",
+                    "messagesWithSwears",
+                    "totalSwears",
+                    "dailyAverage",
+                    "weeklyAverage",
+                    "sync"
+                ],
+                properties: {
+                    generatedAt: { type: "string", format: "date-time" },
+                    conversationsScanned: { type: "integer" },
+                    sourceCount: { type: "integer" },
+                    messagesScanned: { type: "integer" },
+                    messagesWithSwears: { type: "integer" },
+                    totalSwears: { type: "number" },
+                    dailyAverage: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["rawSwearCount", "swearingMessagePercent"],
+                        properties: {
+                            rawSwearCount: { type: "number" },
+                            swearingMessagePercent: { type: "number" }
+                        }
+                    },
+                    weeklyAverage: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["rawSwearCount", "swearingMessagePercent"],
+                        properties: {
+                            rawSwearCount: { type: "number" },
+                            swearingMessagePercent: { type: "number" }
+                        }
+                    },
+                    sync: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["fullSyncCompletedAt", "lastDailySyncAt", "lastSyncedDateKey"],
+                        properties: {
+                            fullSyncCompletedAt: nullable({ type: "string", format: "date-time" }),
+                            lastDailySyncAt: nullable({ type: "string", format: "date-time" }),
+                            lastSyncedDateKey: nullable({ type: "string" })
+                        }
+                    }
+                }
+            },
+            metrics: arrayOf(dailyMetricRecord)
+        }
+    };
     const psycheOverviewPayload = {
         type: "object",
         additionalProperties: false,
@@ -4657,6 +4875,7 @@ export function buildOpenApiDocument() {
             "beliefs",
             "modes",
             "schemaPressure",
+            "devrageMetric",
             "reports",
             "openInsights",
             "openNotes",
@@ -4680,6 +4899,7 @@ export function buildOpenApiDocument() {
                     activationCount: { type: "integer" }
                 }
             }),
+            devrageMetric: devrageMetricPayload,
             reports: arrayOf({ $ref: "#/components/schemas/TriggerReport" }),
             openInsights: { type: "integer" },
             openNotes: { type: "integer" },
@@ -4992,6 +5212,7 @@ export function buildOpenApiDocument() {
                 WorkoutSession: workoutSession,
                 SleepViewData: sleepViewData,
                 FitnessViewData: fitnessViewData,
+                PsycheMetricsViewData: psycheMetricsViewData,
                 PsycheOverviewPayload: psycheOverviewPayload,
                 Insight: insight,
                 InsightFeedback: insightFeedback,
@@ -7044,6 +7265,23 @@ export function buildOpenApiDocument() {
                     }
                 }
             },
+            "/api/v1/psyche/metrics": {
+                get: {
+                    summary: "Get daily Psyche metric history",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["metrics"],
+                            properties: {
+                                metrics: {
+                                    $ref: "#/components/schemas/PsycheMetricsViewData"
+                                }
+                            }
+                        }, "Psyche metrics view"),
+                        default: { $ref: "#/components/responses/Error" }
+                    }
+                }
+            },
             "/api/v1/psyche/values": {
                 get: {
                     summary: "List ACT-style values",

package/dist/server/server/src/psyche-types.js

@@ -244,6 +244,95 @@ export const schemaPressureEntrySchema = z.object({
     title: nonEmptyTrimmedString,
     activationCount: z.number().int().nonnegative()
 });
+export const devrageMetricPayloadSchema = z.object({
+    generatedAt: z.string(),
+    hasData: z.boolean(),
+    latestDateKey: z.string().nullable(),
+    rawSwearCount: z.number().nonnegative(),
+    swearingMessagePercent: z.number().nonnegative(),
+    conversationsScanned: z.number().int().nonnegative(),
+    messagesScanned: z.number().int().nonnegative(),
+    messagesWithSwears: z.number().int().nonnegative(),
+    dailyAverage: z.object({
+        rawSwearCount: z.number().nonnegative(),
+        swearingMessagePercent: z.number().nonnegative()
+    }),
+    weeklyAverage: z.object({
+        rawSwearCount: z.number().nonnegative(),
+        swearingMessagePercent: z.number().nonnegative()
+    }),
+    history: z.array(z.object({
+        dateKey: z.string(),
+        rawSwearCount: z.number().nonnegative(),
+        swearingMessagePercent: z.number().nonnegative(),
+        conversationsScanned: z.number().int().nonnegative(),
+        messagesScanned: z.number().int().nonnegative(),
+        messagesWithSwears: z.number().int().nonnegative()
+    })),
+    sync: z.object({
+        fullSyncCompletedAt: z.string().nullable(),
+        lastDailySyncAt: z.string().nullable(),
+        lastSyncedDateKey: z.string().nullable()
+    })
+});
+export const psycheMetricDayRecordSchema = z.object({
+    dateKey: z.string(),
+    average: z.number().nullable(),
+    minimum: z.number().nullable(),
+    maximum: z.number().nullable(),
+    latest: z.number().nullable(),
+    total: z.number().nullable(),
+    sampleCount: z.number().int().nonnegative(),
+    latestSampleAt: z.string().nullable()
+});
+export const psycheMetricsViewDataSchema = z.object({
+    summary: z.object({
+        hasData: z.boolean(),
+        trackedDays: z.number().int().nonnegative(),
+        metricCount: z.number().int().nonnegative(),
+        latestDateKey: z.string().nullable(),
+        latestMetricCount: z.number().int().nonnegative(),
+        categoryBreakdown: z.array(z.object({
+            category: z.string(),
+            metricCount: z.number().int().nonnegative(),
+            coverageDays: z.number().int().nonnegative()
+        }))
+    }),
+    context: z.object({
+        generatedAt: z.string(),
+        conversationsScanned: z.number().int().nonnegative(),
+        sourceCount: z.number().int().nonnegative(),
+        messagesScanned: z.number().int().nonnegative(),
+        messagesWithSwears: z.number().int().nonnegative(),
+        totalSwears: z.number().nonnegative(),
+        dailyAverage: z.object({
+            rawSwearCount: z.number().nonnegative(),
+            swearingMessagePercent: z.number().nonnegative()
+        }),
+        weeklyAverage: z.object({
+            rawSwearCount: z.number().nonnegative(),
+            swearingMessagePercent: z.number().nonnegative()
+        }),
+        sync: z.object({
+            fullSyncCompletedAt: z.string().nullable(),
+            lastDailySyncAt: z.string().nullable(),
+            lastSyncedDateKey: z.string().nullable()
+        })
+    }),
+    metrics: z.array(z.object({
+        metric: z.string(),
+        label: z.string(),
+        category: z.string(),
+        unit: z.string(),
+        aggregation: z.enum(["discrete", "cumulative"]),
+        latestValue: z.number().nullable(),
+        latestDateKey: z.string().nullable(),
+        baselineValue: z.number().nullable(),
+        deltaValue: z.number().nullable(),
+        coverageDays: z.number().int().nonnegative(),
+        days: z.array(psycheMetricDayRecordSchema)
+    }))
+});
 export const psycheOverviewPayloadSchema = z.object({
     generatedAt: z.string(),
     domain: domainSchema,
@@ -254,6 +343,7 @@ export const psycheOverviewPayloadSchema = z.object({
     modes: z.array(modeProfileSchema),
     reports: z.array(triggerReportSchema),
     schemaPressure: z.array(schemaPressureEntrySchema),
+    devrageMetric: devrageMetricPayloadSchema,
     openInsights: z.number().int().nonnegative(),
     openNotes: z.number().int().nonnegative(),
     committedActions: z.array(trimmedString)