forge-openclaw-plugin 0.2.68 → 0.2.70

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}`;

package/dist/server/src/lib/api.js

@@ -500,6 +500,9 @@ export function getPsycheOverview(userIds) {
     const suffix = search.size > 0 ? `?${search.toString()}` : "";
     return request(`/api/v1/psyche/overview${suffix}`);
 }
+export function getPsycheMetricsView() {
+    return request("/api/v1/psyche/metrics");
+}
 export function listQuestionnaires(userIds) {
     const search = new URLSearchParams();
     appendUserIds(search, coerceUserIds(userIds));
@@ -1688,6 +1691,16 @@ export function getFitnessView(userIds) {
     const suffix = search.size > 0 ? `?${search.toString()}` : "";
     return request(`/api/v1/health/fitness${suffix}`);
 }
+export function getWorkoutDetail(workoutId, resolution = "adaptive") {
+    const search = new URLSearchParams({ resolution });
+    return request(`/api/v1/health/workouts/${workoutId}/detail?${search.toString()}`);
+}
+export function getHealthZoneProfile(userIds) {
+    const search = new URLSearchParams();
+    appendUserIds(search, coerceUserIds(userIds));
+    const suffix = search.size > 0 ? `?${search.toString()}` : "";
+    return request(`/api/v1/health/zone-profile${suffix}`);
+}
 export function getVitalsView(userIds) {
     const search = new URLSearchParams();
     appendUserIds(search, coerceUserIds(userIds));

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "Apache-2.0",
@@ -105,6 +105,7 @@
     "follow-redirects": "^1.16.0",
     "hono": "^4.12.18",
     "ip-address": "^10.2.0",
+    "ws": "^8.20.1",
     "uuid": "^14.0.0"
   },
   "scripts": {

package/server/migrations/061_health_workout_raw_evidence.sql

@@ -0,0 +1,95 @@
+CREATE TABLE IF NOT EXISTS health_workout_time_series (
+  id TEXT PRIMARY KEY,
+  workout_id TEXT NOT NULL REFERENCES health_workout_sessions(id) ON DELETE CASCADE,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  source_sample_uid TEXT NOT NULL,
+  series_index INTEGER NOT NULL DEFAULT 0,
+  metric_key TEXT NOT NULL,
+  label TEXT NOT NULL DEFAULT '',
+  category TEXT NOT NULL DEFAULT '',
+  unit TEXT NOT NULL DEFAULT '',
+  value REAL NOT NULL,
+  started_at TEXT NOT NULL,
+  ended_at TEXT NOT NULL,
+  source_device TEXT NOT NULL DEFAULT '',
+  source_bundle_identifier TEXT,
+  source_product_type TEXT,
+  capture_method TEXT NOT NULL DEFAULT 'associated_workout',
+  quality_flags_json TEXT NOT NULL DEFAULT '[]',
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  provenance_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (workout_id, metric_key, source_sample_uid, series_index)
+);
+
+CREATE INDEX IF NOT EXISTS idx_health_workout_time_series_workout_metric
+  ON health_workout_time_series(workout_id, metric_key, started_at);
+
+CREATE INDEX IF NOT EXISTS idx_health_workout_time_series_user_metric
+  ON health_workout_time_series(user_id, metric_key, started_at DESC);
+
+CREATE TABLE IF NOT EXISTS health_workout_routes (
+  id TEXT PRIMARY KEY,
+  workout_id TEXT NOT NULL REFERENCES health_workout_sessions(id) ON DELETE CASCADE,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  source_route_uid TEXT NOT NULL,
+  point_index INTEGER NOT NULL,
+  recorded_at TEXT NOT NULL,
+  latitude REAL NOT NULL,
+  longitude REAL NOT NULL,
+  altitude_meters REAL,
+  horizontal_accuracy_meters REAL,
+  vertical_accuracy_meters REAL,
+  speed_mps REAL,
+  course_degrees REAL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  provenance_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (workout_id, source_route_uid, point_index)
+);
+
+CREATE INDEX IF NOT EXISTS idx_health_workout_routes_workout
+  ON health_workout_routes(workout_id, point_index);
+
+CREATE TABLE IF NOT EXISTS health_zone_profiles (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  model_version TEXT NOT NULL DEFAULT 'forge-hrr-v1',
+  birth_year INTEGER,
+  sex_at_birth TEXT,
+  known_max_hr REAL,
+  threshold_hr REAL,
+  resting_hr_override REAL,
+  custom_zones_json TEXT NOT NULL DEFAULT '[]',
+  inferred_max_hr REAL,
+  inferred_resting_hr REAL,
+  confidence TEXT NOT NULL DEFAULT 'medium',
+  thresholds_json TEXT NOT NULL DEFAULT '[]',
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(user_id, model_version)
+);
+
+CREATE TABLE IF NOT EXISTS health_workout_analytics (
+  id TEXT PRIMARY KEY,
+  workout_id TEXT NOT NULL REFERENCES health_workout_sessions(id) ON DELETE CASCADE,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  zone_profile_id TEXT REFERENCES health_zone_profiles(id) ON DELETE SET NULL,
+  model_version TEXT NOT NULL DEFAULT 'forge-hrr-v1',
+  confidence TEXT NOT NULL DEFAULT 'unavailable',
+  data_quality_json TEXT NOT NULL DEFAULT '{}',
+  zone_durations_json TEXT NOT NULL DEFAULT '[]',
+  hr_summary_json TEXT NOT NULL DEFAULT '{}',
+  load_json TEXT NOT NULL DEFAULT '{}',
+  route_summary_json TEXT NOT NULL DEFAULT '{}',
+  computed_at TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(workout_id, model_version)
+);
+
+CREATE INDEX IF NOT EXISTS idx_health_workout_analytics_user
+  ON health_workout_analytics(user_id, computed_at DESC);