forge-openclaw-plugin 0.2.67 → 0.2.69

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

@@ -0,0 +1,412 @@
+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) {
+        return syncInFlight;
+    }
+    syncInFlight = syncDevrageMetricHistoryInternal(options).finally(() => {
+        syncInFlight = null;
+    });
+    return syncInFlight;
+}
+export async function syncDevrageMetricHistoryIfNeeded() {
+    const state = getDevrageSyncState();
+    if (!state?.full_sync_completed_at) {
+        await syncDevrageMetricHistory({ forceFull: true });
+        return;
+    }
+    const today = todayDateKey();
+    if (state.last_synced_date_key !== today) {
+        await syncDevrageMetricHistory({ dateKey: today });
+    }
+}
+export function getDevrageMetricPayload() {
+    const generatedAt = nowIso();
+    const state = getDevrageSyncState();
+    const history = getDevrageDailyHistory(90);
+    const latest = history[0] ?? null;
+    const dailyAverages = getMetricAverages();
+    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,
+        conversationsScanned: latest?.conversationsScanned ?? 0,
+        messagesScanned: latest?.messagesScanned ?? 0,
+        messagesWithSwears: latest?.messagesWithSwears ?? 0,
+        dailyAverage: {
+            rawSwearCount: dailyAverages.rawSwearCount,
+            swearingMessagePercent: dailyAverages.swearingMessagePercent
+        },
+        weeklyAverage: {
+            rawSwearCount: weeklyAverages.rawSwearCount,
+            swearingMessagePercent: weeklyAverages.swearingMessagePercent
+        },
+        history,
+        sync: {
+            fullSyncCompletedAt: state?.full_sync_completed_at ?? null,
+            lastDailySyncAt: state?.last_daily_sync_at ?? null,
+            lastSyncedDateKey: state?.last_synced_date_key ?? null
+        }
+    };
+}
+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({
+        roles: DEFAULT_ROLE_FILTER,
+        date: dateKey,
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    });
+    storeDevrageReport(report, {
+        fullSync: Boolean(options.forceFull),
+        syncedDateKey: dateKey ?? null
+    });
+}
+export function storeDevrageReport(report, options) {
+    const scannedAt = nowIso();
+    const affectedDateKeys = new Set(report.conversations.map((conversation) => conversation.dateKey));
+    runInTransaction(() => {
+        const database = getDatabase();
+        const deleteDate = database.prepare(`DELETE FROM psyche_devrage_conversation_measures WHERE date_key = ?`);
+        const insertConversation = database.prepare(`INSERT INTO psyche_devrage_conversation_measures (
+         id, source, conversation_id, date_key, updated_at, messages,
+         messages_with_swears, swear_count, scanned_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(source, conversation_id, date_key) DO UPDATE SET
+         updated_at = excluded.updated_at,
+         messages = excluded.messages,
+         messages_with_swears = excluded.messages_with_swears,
+         swear_count = excluded.swear_count,
+         scanned_at = excluded.scanned_at`);
+        for (const dateKey of affectedDateKeys) {
+            deleteDate.run(dateKey);
+        }
+        for (const conversation of report.conversations) {
+            insertConversation.run(stableId("devrage_conversation", conversation.source, conversation.conversationId, conversation.dateKey), conversation.source, conversation.conversationId, conversation.dateKey, conversation.updatedAt, conversation.messages, conversation.messagesWithSwears, conversation.swears, scannedAt);
+        }
+        for (const dateKey of affectedDateKeys) {
+            recomputeMetricMeasuresForDate(dateKey, scannedAt);
+        }
+        upsertSyncState({
+            fullSyncCompletedAt: options.fullSync ? scannedAt : undefined,
+            lastDailySyncAt: options.fullSync ? undefined : scannedAt,
+            lastSyncedDateKey: options.syncedDateKey ?? [...affectedDateKeys].sort().at(-1) ?? null,
+            updatedAt: scannedAt
+        });
+    });
+}
+function recomputeMetricMeasuresForDate(dateKey, computedAt) {
+    const aggregate = getDatabase()
+        .prepare(`SELECT
+         COUNT(*) AS conversations,
+         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
+       WHERE date_key = ?`)
+        .get(dateKey);
+    const messages = Number(aggregate.messages) || 0;
+    const messagesWithSwears = Number(aggregate.messages_with_swears) || 0;
+    const swearCount = Number(aggregate.swear_count) || 0;
+    const percent = messages > 0 ? (messagesWithSwears / messages) * 100 : 0;
+    upsertMetricMeasure(dateKey, SWEAR_COUNT_KEY, swearCount, "count", Number(aggregate.conversations) || 0, computedAt);
+    upsertMetricMeasure(dateKey, SWEARING_MESSAGE_PERCENT_KEY, percent, "percent", messages, computedAt);
+}
+function upsertMetricMeasure(dateKey, metricKey, value, unit, sampleCount, computedAt) {
+    getDatabase()
+        .prepare(`INSERT INTO psyche_devrage_metric_measures (
+         id, date_key, metric_key, value, unit, sample_count, computed_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(date_key, metric_key) DO UPDATE SET
+         value = excluded.value,
+         unit = excluded.unit,
+         sample_count = excluded.sample_count,
+         computed_at = excluded.computed_at`)
+        .run(stableId("devrage_metric", dateKey, metricKey), dateKey, metricKey, value, unit, sampleCount, computedAt);
+}
+function upsertSyncState(input) {
+    const current = getDevrageSyncState();
+    getDatabase()
+        .prepare(`INSERT INTO psyche_devrage_sync_state (
+         id, full_sync_completed_at, last_daily_sync_at, last_synced_date_key, updated_at
+       )
+       VALUES ('default', ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         full_sync_completed_at = excluded.full_sync_completed_at,
+         last_daily_sync_at = excluded.last_daily_sync_at,
+         last_synced_date_key = excluded.last_synced_date_key,
+         updated_at = excluded.updated_at`)
+        .run(input.fullSyncCompletedAt ?? current?.full_sync_completed_at ?? null, input.lastDailySyncAt ?? current?.last_daily_sync_at ?? null, input.lastSyncedDateKey ?? current?.last_synced_date_key ?? null, input.updatedAt);
+}
+function getDevrageSyncState() {
+    return (getDatabase()
+        .prepare(`SELECT full_sync_completed_at, last_daily_sync_at, last_synced_date_key, updated_at
+         FROM psyche_devrage_sync_state
+         WHERE id = 'default'`)
+        .get() ?? null);
+}
+function getDevrageDailyHistory(limit) {
+    const rows = getDatabase()
+        .prepare(`SELECT
+         date_key,
+         COUNT(*) AS conversations,
+         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
+       GROUP BY date_key
+       ORDER BY date_key DESC
+       LIMIT ?`)
+        .all(limit);
+    return rows.map((row) => {
+        const messages = Number(row.messages) || 0;
+        const messagesWithSwears = Number(row.messages_with_swears) || 0;
+        return {
+            dateKey: row.date_key,
+            rawSwearCount: Number(row.swear_count) || 0,
+            swearingMessagePercent: messages > 0 ? (messagesWithSwears / messages) * 100 : 0,
+            conversationsScanned: Number(row.conversations) || 0,
+            messagesScanned: messages,
+            messagesWithSwears
+        };
+    });
+}
+function getMetricAverages(days) {
+    const where = days
+        ? `WHERE date_key IN (
+         SELECT date_key FROM psyche_devrage_metric_measures
+         GROUP BY date_key
+         ORDER BY date_key DESC
+         LIMIT ?
+       )`
+        : "";
+    const rows = getDatabase()
+        .prepare(`SELECT metric_key, AVG(value) AS value
+       FROM psyche_devrage_metric_measures
+       ${where}
+       GROUP BY metric_key`)
+        .all(...(days ? [days] : []));
+    const swearAverage = rows.find((row) => row.metric_key === SWEAR_COUNT_KEY)?.value ?? 0;
+    const percentAverage = rows.find((row) => row.metric_key === SWEARING_MESSAGE_PERCENT_KEY)?.value ?? 0;
+    return {
+        rawSwearCount: round(Number(swearAverage) || 0, 1),
+        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}`;
+}
+function todayDateKey() {
+    return new Intl.DateTimeFormat("en-CA", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+    }).format(new Date());
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function round(value, digits) {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
+}

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

@@ -3,6 +3,7 @@ import { listInsights } from "../repositories/collaboration.js";
 import { listNotes } from "../repositories/notes.js";
 import { filterOwnedEntities } from "../repositories/entity-ownership.js";
 import { listBehaviorPatterns, listBehaviors, listBeliefEntries, listModeProfiles, listPsycheValues, listSchemaCatalog, listTriggerReports } from "../repositories/psyche.js";
+import { getDevrageMetricPayload } from "./devrage.js";
 import { psycheOverviewPayloadSchema } from "../psyche-types.js";
 const PSYCHE_ENTITY_TYPE_SET = new Set([
     "psyche_value",
@@ -32,6 +33,7 @@ export function getPsycheOverview(userIds) {
         ...behaviors.filter((behavior) => behavior.kind === "committed").map((behavior) => behavior.title),
         ...reports.flatMap((report) => report.nextMoves)
     ];
+    const devrageMetric = getDevrageMetricPayload();
     const schemaPressure = schemaCatalog
         .filter((schema) => schema.schemaType === "maladaptive")
         .map((schema) => {
@@ -57,6 +59,7 @@ export function getPsycheOverview(userIds) {
         modes,
         reports,
         schemaPressure,
+        devrageMetric,
         openInsights,
         openNotes,
         committedActions

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.67",
+  "version": "0.2.69",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.67",
+  "version": "0.2.69",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "Apache-2.0",

package/server/migrations/060_psyche_devrage_metrics.sql

@@ -0,0 +1,40 @@
+CREATE TABLE IF NOT EXISTS psyche_devrage_conversation_measures (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  conversation_id TEXT NOT NULL,
+  date_key TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  messages INTEGER NOT NULL DEFAULT 0,
+  messages_with_swears INTEGER NOT NULL DEFAULT 0,
+  swear_count INTEGER NOT NULL DEFAULT 0,
+  scanned_at TEXT NOT NULL,
+  UNIQUE (source, conversation_id, date_key)
+);
+
+CREATE INDEX IF NOT EXISTS psyche_devrage_conversation_measures_date_idx
+  ON psyche_devrage_conversation_measures (date_key DESC);
+
+CREATE INDEX IF NOT EXISTS psyche_devrage_conversation_measures_updated_idx
+  ON psyche_devrage_conversation_measures (updated_at DESC);
+
+CREATE TABLE IF NOT EXISTS psyche_devrage_metric_measures (
+  id TEXT PRIMARY KEY,
+  date_key TEXT NOT NULL,
+  metric_key TEXT NOT NULL,
+  value REAL NOT NULL,
+  unit TEXT NOT NULL DEFAULT '',
+  sample_count INTEGER NOT NULL DEFAULT 0,
+  computed_at TEXT NOT NULL,
+  UNIQUE (date_key, metric_key)
+);
+
+CREATE INDEX IF NOT EXISTS psyche_devrage_metric_measures_metric_date_idx
+  ON psyche_devrage_metric_measures (metric_key, date_key DESC);
+
+CREATE TABLE IF NOT EXISTS psyche_devrage_sync_state (
+  id TEXT PRIMARY KEY CHECK (id = 'default'),
+  full_sync_completed_at TEXT,
+  last_daily_sync_at TEXT,
+  last_synced_date_key TEXT,
+  updated_at TEXT NOT NULL
+);

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);