forge-openclaw-plugin 0.2.68 → 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

@@ -4650,6 +4650,7 @@ export function buildOpenApiDocument() {
         additionalProperties: false,
         required: [
             "generatedAt",
+            "hasData",
             "latestDateKey",
             "rawSwearCount",
             "swearingMessagePercent",
@@ -4663,6 +4664,7 @@ export function buildOpenApiDocument() {
         ],
         properties: {
             generatedAt: { type: "string", format: "date-time" },
+            hasData: { type: "boolean" },
             latestDateKey: nullable({ type: "string" }),
             rawSwearCount: { type: "number" },
             swearingMessagePercent: { type: "number" },
@@ -4719,6 +4721,148 @@ export function buildOpenApiDocument() {
             }
         }
     };
+    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,
@@ -5068,6 +5212,7 @@ export function buildOpenApiDocument() {
                 WorkoutSession: workoutSession,
                 SleepViewData: sleepViewData,
                 FitnessViewData: fitnessViewData,
+                PsycheMetricsViewData: psycheMetricsViewData,
                 PsycheOverviewPayload: psycheOverviewPayload,
                 Insight: insight,
                 InsightFeedback: insightFeedback,
@@ -7120,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

@@ -246,6 +246,7 @@ export const schemaPressureEntrySchema = z.object({
 });
 export const devrageMetricPayloadSchema = z.object({
     generatedAt: z.string(),
+    hasData: z.boolean(),
     latestDateKey: z.string().nullable(),
     rawSwearCount: z.number().nonnegative(),
     swearingMessagePercent: z.number().nonnegative(),
@@ -274,6 +275,64 @@ export const devrageMetricPayloadSchema = z.object({
         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,

package/dist/server/server/src/services/devrage.js

@@ -1,9 +1,26 @@
 import { createHash } from "node:crypto";
 import { scanConversations } from "forge-devrage";
 import { getDatabase, runInTransaction } from "../db.js";
+import { psycheMetricsViewDataSchema } from "../psyche-types.js";
 const SWEAR_COUNT_KEY = "swear_count";
 const SWEARING_MESSAGE_PERCENT_KEY = "swearing_message_percent";
 const DEFAULT_ROLE_FILTER = new Set(["user"]);
+const PSYCHE_METRIC_DEFINITIONS = {
+    [SWEAR_COUNT_KEY]: {
+        metric: "devrageSwearCount",
+        label: "Devrage swears",
+        category: "conversationTone",
+        unit: "swears",
+        aggregation: "cumulative"
+    },
+    [SWEARING_MESSAGE_PERCENT_KEY]: {
+        metric: "swearingMessagePercent",
+        label: "Swearing messages",
+        category: "conversationTone",
+        unit: "%",
+        aggregation: "discrete"
+    }
+};
 let syncInFlight = null;
 export async function syncDevrageMetricHistory(options = {}) {
     if (syncInFlight) {
@@ -34,6 +51,7 @@ export function getDevrageMetricPayload() {
     const weeklyAverages = getMetricAverages(7);
     return {
         generatedAt,
+        hasData: history.some((day) => day.conversationsScanned > 0),
         latestDateKey: latest?.dateKey ?? null,
         rawSwearCount: latest?.rawSwearCount ?? 0,
         swearingMessagePercent: latest?.swearingMessagePercent ?? 0,
@@ -56,6 +74,153 @@ export function getDevrageMetricPayload() {
         }
     };
 }
+export function getPsycheMetricsViewData() {
+    const rows = getDatabase()
+        .prepare(`SELECT date_key, metric_key, value, unit, sample_count, computed_at
+       FROM psyche_devrage_metric_measures
+       ORDER BY date_key ASC, metric_key ASC`)
+        .all();
+    const metricBuckets = new Map();
+    for (const row of rows) {
+        const definition = PSYCHE_METRIC_DEFINITIONS[row.metric_key];
+        if (!definition) {
+            continue;
+        }
+        const bucket = metricBuckets.get(definition.metric) ?? {
+            label: definition.label,
+            category: definition.category,
+            unit: definition.unit,
+            aggregation: definition.aggregation,
+            days: new Map()
+        };
+        const dayRows = bucket.days.get(row.date_key) ?? [];
+        dayRows.push(row);
+        bucket.days.set(row.date_key, dayRows);
+        metricBuckets.set(definition.metric, bucket);
+    }
+    const metrics = [...metricBuckets.entries()]
+        .map(([metric, bucket]) => {
+        const days = [...bucket.days.entries()]
+            .sort((left, right) => left[0].localeCompare(right[0]))
+            .map(([dateKey, entries]) => {
+            const values = entries.map((entry) => Number(entry.value) || 0);
+            const value = average(values);
+            return {
+                dateKey,
+                average: round(value, bucket.aggregation === "cumulative" ? 0 : 1),
+                minimum: round(Math.min(...values), bucket.aggregation === "cumulative" ? 0 : 1),
+                maximum: round(Math.max(...values), bucket.aggregation === "cumulative" ? 0 : 1),
+                latest: round(values.at(-1) ?? value, bucket.aggregation === "cumulative" ? 0 : 1),
+                total: bucket.aggregation === "cumulative"
+                    ? round(sumNullable(values), 0)
+                    : null,
+                sampleCount: entries.reduce((sum, entry) => sum + Number(entry.sample_count || 0), 0),
+                latestSampleAt: entries
+                    .map((entry) => entry.computed_at)
+                    .filter(Boolean)
+                    .sort()
+                    .at(-1) ?? null
+            };
+        });
+        const latestDay = [...days].reverse().find((day) => psycheMetricPrimaryValue({
+            aggregation: bucket.aggregation,
+            latest: day.latest,
+            average: day.average,
+            total: day.total,
+            maximum: day.maximum
+        }) !== null) ?? null;
+        const recentValues = days
+            .map((day) => psycheMetricPrimaryValue({
+            aggregation: bucket.aggregation,
+            latest: day.latest,
+            average: day.average,
+            total: day.total,
+            maximum: day.maximum
+        }))
+            .filter((value) => value != null);
+        const baselineValues = recentValues.slice(Math.max(0, recentValues.length - 8), recentValues.length - 1);
+        const baselineValue = baselineValues.length > 0 ? average(baselineValues) : recentValues.at(-2) ?? null;
+        const latestValue = latestDay
+            ? psycheMetricPrimaryValue({
+                aggregation: bucket.aggregation,
+                latest: latestDay.latest,
+                average: latestDay.average,
+                total: latestDay.total,
+                maximum: latestDay.maximum
+            })
+            : null;
+        const digits = bucket.aggregation === "cumulative" ? 0 : 1;
+        return {
+            metric,
+            label: bucket.label,
+            category: bucket.category,
+            unit: bucket.unit,
+            aggregation: bucket.aggregation,
+            latestValue: latestValue == null ? null : round(latestValue, digits),
+            latestDateKey: latestDay?.dateKey ?? null,
+            baselineValue: baselineValue == null ? null : round(baselineValue, digits),
+            deltaValue: latestValue != null && baselineValue != null
+                ? round(latestValue - baselineValue, digits)
+                : null,
+            coverageDays: days.filter((day) => day.sampleCount > 0).length,
+            days
+        };
+    })
+        .sort((left, right) => {
+        if (left.category === right.category) {
+            return left.label.localeCompare(right.label);
+        }
+        return left.category.localeCompare(right.category);
+    });
+    const latestDateKey = rows.map((row) => row.date_key).sort().at(-1) ?? null;
+    const trackedDays = new Set(rows.map((row) => row.date_key)).size;
+    const categoryBreakdown = [...new Set(metrics.map((metric) => metric.category))]
+        .map((category) => {
+        const categoryMetrics = metrics.filter((metric) => metric.category === category);
+        return {
+            category,
+            metricCount: categoryMetrics.length,
+            coverageDays: Math.max(...categoryMetrics.map((metric) => metric.coverageDays), 0)
+        };
+    })
+        .sort((left, right) => right.metricCount - left.metricCount);
+    const context = getDevrageConversationTotals();
+    const dailyAverages = getMetricAverages();
+    const weeklyAverages = getMetricAverages(7);
+    const state = getDevrageSyncState();
+    return psycheMetricsViewDataSchema.parse({
+        summary: {
+            hasData: metrics.length > 0 && context.conversations > 0,
+            trackedDays,
+            metricCount: metrics.length,
+            latestDateKey,
+            latestMetricCount: metrics.filter((metric) => metric.latestDateKey === latestDateKey).length,
+            categoryBreakdown
+        },
+        context: {
+            generatedAt: nowIso(),
+            conversationsScanned: Number(context.conversations) || 0,
+            sourceCount: Number(context.sources) || 0,
+            messagesScanned: Number(context.messages) || 0,
+            messagesWithSwears: Number(context.messages_with_swears) || 0,
+            totalSwears: Number(context.swear_count) || 0,
+            dailyAverage: {
+                rawSwearCount: dailyAverages.rawSwearCount,
+                swearingMessagePercent: dailyAverages.swearingMessagePercent
+            },
+            weeklyAverage: {
+                rawSwearCount: weeklyAverages.rawSwearCount,
+                swearingMessagePercent: weeklyAverages.swearingMessagePercent
+            },
+            sync: {
+                fullSyncCompletedAt: state?.full_sync_completed_at ?? null,
+                lastDailySyncAt: state?.last_daily_sync_at ?? null,
+                lastSyncedDateKey: state?.last_synced_date_key ?? null
+            }
+        },
+        metrics
+    });
+}
 async function syncDevrageMetricHistoryInternal(options) {
     const dateKey = options.forceFull ? undefined : options.dateKey ?? todayDateKey();
     const report = await scanConversations({
@@ -201,6 +366,32 @@ function getMetricAverages(days) {
         swearingMessagePercent: round(Number(percentAverage) || 0, 1)
     };
 }
+function getDevrageConversationTotals() {
+    return getDatabase()
+        .prepare(`SELECT
+         COUNT(*) AS conversations,
+         COUNT(DISTINCT source) AS sources,
+         COALESCE(SUM(messages), 0) AS messages,
+         COALESCE(SUM(messages_with_swears), 0) AS messages_with_swears,
+         COALESCE(SUM(swear_count), 0) AS swear_count
+       FROM psyche_devrage_conversation_measures`)
+        .get();
+}
+function psycheMetricPrimaryValue(metric) {
+    if (metric.aggregation === "cumulative") {
+        return metric.total ?? metric.latest;
+    }
+    return metric.latest ?? metric.average ?? metric.maximum;
+}
+function average(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function sumNullable(values) {
+    return values.reduce((sum, value) => sum + value, 0);
+}
 function stableId(prefix, ...parts) {
     const digest = createHash("sha256").update(parts.join("\u0000")).digest("hex").slice(0, 20);
     return `${prefix}_${digest}`;