forge-openclaw-plugin 0.2.25 → 0.2.27

package/dist/server/src/lib/workbench/runtime.js

@@ -0,0 +1,397 @@
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readTextValue(...values) {
+    for (const value of values) {
+        if (typeof value === "string") {
+            return value;
+        }
+    }
+    return "";
+}
+function readNumberValue(...values) {
+    for (const value of values) {
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string") {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return null;
+}
+function readStringArrayValue(...values) {
+    for (const value of values) {
+        if (Array.isArray(value)) {
+            const normalized = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+            if (normalized.length > 0) {
+                return normalized;
+            }
+            continue;
+        }
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (Array.isArray(parsed)) {
+                    const normalized = parsed.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+                    if (normalized.length > 0) {
+                        return normalized;
+                    }
+                }
+            }
+            catch {
+                const normalized = trimmed
+                    .split(",")
+                    .map((entry) => entry.trim())
+                    .filter((entry) => entry.length > 0);
+                if (normalized.length > 0) {
+                    return normalized;
+                }
+            }
+        }
+    }
+    return [];
+}
+export function buildWorkbenchOutputMap(text, json, outputs) {
+    const outputMap = {};
+    const declaredOutputs = outputs.length > 0 ? outputs : [{ key: "summary" }];
+    declaredOutputs.forEach((output, index) => {
+        const rawValue = json && output.key in json
+            ? json[output.key]
+            : index === 0 || output.key === "summary"
+                ? text
+                : null;
+        outputMap[output.key] = {
+            text: typeof rawValue === "string"
+                ? rawValue
+                : Array.isArray(rawValue) || asRecord(rawValue)
+                    ? JSON.stringify(rawValue, null, 2)
+                    : String(rawValue ?? ""),
+            json: asRecord(rawValue)
+        };
+    });
+    return outputMap;
+}
+function normalizeWorkbenchOutputPayload(definition, output, primaryText) {
+    const declaredOutputs = definition.output ?? [];
+    if (!output && declaredOutputs.length === 0) {
+        return null;
+    }
+    const normalized = output ? { ...output } : {};
+    if (declaredOutputs.length > 0) {
+        const leadKey = declaredOutputs[0]?.key;
+        if (leadKey && !(leadKey in normalized)) {
+            normalized[leadKey] = primaryText;
+        }
+        if (declaredOutputs.some((entry) => entry.key === "summary") &&
+            !("summary" in normalized)) {
+            normalized.summary = primaryText;
+        }
+    }
+    return normalized;
+}
+export function buildWorkbenchExecutionEnvelope(input, value) {
+    const payload = normalizeWorkbenchOutputPayload(input.definition, value.output, value.primaryText);
+    return {
+        primaryText: value.primaryText,
+        payload,
+        logs: value.logs ?? [],
+        outputMap: buildWorkbenchOutputMap(value.primaryText, payload, input.definition.output)
+    };
+}
+export function buildStaticWorkbenchExecution(input, output, primaryText, logs) {
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: primaryText ??
+            `${input.definition.title}\n${input.definition.description}\nRoute: ${input.definition.routePath ?? "n/a"}`,
+        output,
+        logs
+    });
+}
+export function searchWorkbenchEntities(context, definition, input) {
+    const limit = Math.max(1, Math.min(50, Math.round(input.limit ?? 12)));
+    const result = context.services.entities.search({
+        searches: [
+            {
+                query: input.query,
+                entityTypes: input.entityTypes,
+                limit
+            }
+        ]
+    }).results[0];
+    const matches = result?.ok ? result.matches ?? [] : [];
+    const summaryLines = matches
+        .slice(0, limit)
+        .map((match) => {
+        const title = typeof match.title === "string"
+            ? match.title
+            : typeof match.name === "string"
+                ? match.name
+                : typeof match.id === "string"
+                    ? match.id
+                    : "Untitled";
+        const entityType = typeof match.entityType === "string" ? match.entityType : "entity";
+        return `${entityType}: ${title}`;
+    });
+    return {
+        title: definition.title,
+        matches,
+        summaryText: summaryLines.length > 0
+            ? summaryLines.join("\n")
+            : `No ${definition.title.toLowerCase()} matches found.`,
+        limit,
+        query: input.query
+    };
+}
+export function buildSearchWorkbenchExecution(input, config) {
+    const query = readTextValue(input.inputs.query, input.params.query, config.query).trim();
+    const entityTypes = readStringArrayValue(input.inputs.entityTypes, input.params.entityTypes, config.entityTypes);
+    const limit = readNumberValue(input.inputs.limit, input.params.limit, config.limit) ?? config.limit ?? 12;
+    const summary = searchWorkbenchEntities(input.context, input.definition, {
+        query,
+        entityTypes,
+        limit
+    });
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary.summaryText,
+        output: {
+            summary: summary.summaryText,
+            matches: summary.matches,
+            matchCount: summary.matches.length
+        }
+    });
+}
+export function buildMovementPlacesExecution(input) {
+    const places = input.context.services.movement.listPlaces?.() ?? [];
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: places.length > 0
+            ? places
+                .slice(0, 24)
+                .map((place) => typeof place.label === "string"
+                ? place.label
+                : typeof place.name === "string"
+                    ? place.name
+                    : typeof place.id === "string"
+                        ? place.id
+                        : "Place")
+                .join("\n")
+            : "No known places are stored yet.",
+        output: {
+            summary: places.length > 0
+                ? `${places.length} place${places.length === 1 ? "" : "s"} available.`
+                : "No known places are stored yet.",
+            places
+        }
+    });
+}
+export function buildSleepWorkbenchExecution(input) {
+    const payload = input.context.services.health.getSleepViewData?.() ?? null;
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: payload && typeof payload === "object"
+            ? "Sleep history and derived patterns are available."
+            : "No sleep data is available.",
+        output: payload && typeof payload === "object"
+            ? {
+                summary: "Sleep history and derived patterns are available.",
+                sleepView: payload
+            }
+            : {
+                summary: "No sleep data is available."
+            }
+    });
+}
+export function buildSportsWorkbenchExecution(input) {
+    const payload = input.context.services.health.getFitnessViewData?.() ?? null;
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: payload && typeof payload === "object"
+            ? "Workout history and composition are available."
+            : "No sports data is available.",
+        output: payload && typeof payload === "object"
+            ? {
+                summary: "Workout history and composition are available.",
+                sportsView: payload
+            }
+            : {
+                summary: "No sports data is available."
+            }
+    });
+}
+export function buildOverviewWorkbenchExecution(input) {
+    const payload = input.context.services.overview.getContext?.() ?? null;
+    const record = asRecord(payload);
+    const summary = record
+        ? [
+            `Projects: ${Array.isArray(record.projects) ? record.projects.length : 0}`,
+            `Goals: ${Array.isArray(record.activeGoals) ? record.activeGoals.length : 0}`,
+            `Top tasks: ${Array.isArray(record.topTasks) ? record.topTasks.length : 0}`,
+            `Due habits: ${Array.isArray(record.dueHabits) ? record.dueHabits.length : 0}`
+        ].join("\n")
+        : "No overview context is available.";
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary,
+        output: record
+            ? {
+                summary,
+                context: record
+            }
+            : {
+                summary
+            }
+    });
+}
+export function buildInsightsWorkbenchExecution(input) {
+    const payload = input.context.services.overview.getInsights?.() ?? null;
+    const record = asRecord(payload);
+    const status = asRecord(record?.status);
+    const coaching = asRecord(record?.coaching);
+    const summary = record
+        ? [
+            typeof status?.systemStatus === "string" ? status.systemStatus : "Insights ready",
+            typeof coaching?.title === "string" ? coaching.title : null,
+            typeof coaching?.summary === "string" ? coaching.summary : null
+        ]
+            .filter(Boolean)
+            .join("\n")
+        : "No insights payload is available.";
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary,
+        output: record
+            ? {
+                summary,
+                insights: record
+            }
+            : {
+                summary
+            }
+    });
+}
+export function buildWeeklyReviewWorkbenchExecution(input) {
+    const payload = input.context.services.overview.getWeeklyReview?.() ?? null;
+    const record = asRecord(payload);
+    const momentum = asRecord(record?.momentumSummary);
+    const summary = record
+        ? [
+            typeof record.windowLabel === "string" ? record.windowLabel : "Weekly review",
+            typeof momentum?.totalXp === "number" ? `${momentum.totalXp} XP` : null,
+            typeof momentum?.focusHours === "number"
+                ? `${momentum.focusHours} focus hours`
+                : null
+        ]
+            .filter(Boolean)
+            .join("\n")
+        : "No weekly review payload is available.";
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary,
+        output: record
+            ? {
+                summary,
+                weeklyReview: record
+            }
+            : {
+                summary
+            }
+    });
+}
+export function buildWikiPagesWorkbenchExecution(input) {
+    const pages = input.context.services.wiki.listPages?.() ?? [];
+    const summary = pages.length > 0
+        ? pages
+            .slice(0, 12)
+            .map((page) => typeof page.title === "string"
+            ? page.title
+            : typeof page.slug === "string"
+                ? page.slug
+                : typeof page.id === "string"
+                    ? page.id
+                    : "Wiki page")
+            .join("\n")
+        : "No wiki pages are available.";
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary,
+        output: {
+            summary,
+            pages
+        }
+    });
+}
+export function buildWikiHealthWorkbenchExecution(input) {
+    const payload = input.context.services.wiki.getHealth?.() ?? null;
+    const record = asRecord(payload);
+    const unresolvedLinks = Array.isArray(record?.unresolvedLinks)
+        ? record.unresolvedLinks.length
+        : null;
+    const orphanPages = Array.isArray(record?.orphanPages)
+        ? record.orphanPages.length
+        : null;
+    const summary = record
+        ? [
+            "Wiki health summary",
+            unresolvedLinks !== null ? `${unresolvedLinks} unresolved links` : null,
+            orphanPages !== null ? `${orphanPages} orphan pages` : null
+        ]
+            .filter(Boolean)
+            .join("\n")
+        : "No wiki health payload is available.";
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary,
+        output: record
+            ? {
+                summary,
+                health: record
+            }
+            : {
+                summary
+            }
+    });
+}
+export function mapWorkbenchTools(tools) {
+    return tools.map((tool) => tool);
+}
+export function executeCommonWorkbenchTool(context, definition, toolKey, args) {
+    if (toolKey === "forge.search_entities") {
+        const query = typeof args.query === "string" ? args.query.trim() : "";
+        const entityTypes = Array.isArray(args.entityTypes)
+            ? args.entityTypes.filter((entry) => typeof entry === "string" && entry.length > 0)
+            : [];
+        const limit = typeof args.limit === "number" && Number.isFinite(args.limit)
+            ? args.limit
+            : 12;
+        return searchWorkbenchEntities(context, definition, {
+            query,
+            entityTypes,
+            limit
+        });
+    }
+    if (toolKey === "forge.update_task_status") {
+        const taskId = typeof args.taskId === "string" ? args.taskId : "";
+        const status = typeof args.status === "string" ? args.status : "";
+        if (!context.services.tasks.update) {
+            throw new Error("Task update service is not available.");
+        }
+        return context.services.tasks.update(taskId, { status });
+    }
+    if (toolKey === "forge.create_note") {
+        if (!context.services.notes.create) {
+            throw new Error("Note creation service is not available.");
+        }
+        return context.services.notes.create({
+            kind: "evidence",
+            title: typeof args.title === "string" ? args.title : "Workbench note",
+            contentMarkdown: typeof args.markdown === "string" ? args.markdown : "",
+            summary: typeof args.summary === "string" ? args.summary : "",
+            links: [],
+            tags: [],
+            sourcePath: "workbench",
+            author: "Workbench"
+        });
+    }
+    throw new Error(`Unsupported Workbench tool: ${toolKey}`);
+}

package/dist/server/src/lib/workbench/tool-catalog.js

@@ -0,0 +1,68 @@
+function rankAccessMode(mode) {
+    switch (mode) {
+        case "exec":
+            return 4;
+        case "read_write":
+            return 3;
+        case "write":
+            return 2;
+        case "read":
+        default:
+            return 1;
+    }
+}
+function preferAccessMode(left, right) {
+    return rankAccessMode(left) >= rankAccessMode(right) ? left : right;
+}
+function normalizeToolDescription(toolKey, descriptions) {
+    if (toolKey === "forge.search_entities") {
+        return "Search across Forge entities. You can optionally narrow the search to specific entity types.";
+    }
+    if (toolKey === "forge.create_note") {
+        return "Create a Forge note from generated content or captured markdown.";
+    }
+    if (toolKey === "forge.update_task_status") {
+        return "Move a task between execution states such as backlog, focus, in progress, blocked, and done.";
+    }
+    return descriptions.sort((left, right) => right.length - left.length)[0] ?? "Workbench tool";
+}
+export function buildWorkbenchToolCatalog(boxes) {
+    const byKey = new Map();
+    for (const box of boxes) {
+        for (const tool of box.tools) {
+            const current = byKey.get(tool.key);
+            if (!current) {
+                byKey.set(tool.key, {
+                    key: tool.key,
+                    label: tool.label,
+                    description: normalizeToolDescription(tool.key, [tool.description]),
+                    accessMode: tool.accessMode,
+                    argsSchema: tool.argsSchema,
+                    sources: [box.title],
+                    sourceSurfaceIds: box.surfaceId ? [box.surfaceId] : []
+                });
+                continue;
+            }
+            current.accessMode = preferAccessMode(current.accessMode, tool.accessMode);
+            current.label = current.label.length >= tool.label.length ? current.label : tool.label;
+            current.description = normalizeToolDescription(tool.key, [
+                current.description,
+                tool.description
+            ]);
+            current.argsSchema = current.argsSchema ?? tool.argsSchema;
+            if (!current.sources.includes(box.title)) {
+                current.sources.push(box.title);
+            }
+            if (box.surfaceId && !current.sourceSurfaceIds.includes(box.surfaceId)) {
+                current.sourceSurfaceIds.push(box.surfaceId);
+            }
+        }
+    }
+    return [...byKey.values()].sort((left, right) => {
+        const accessDelta = rankAccessMode(right.accessMode) - rankAccessMode(left.accessMode);
+        if (accessDelta !== 0) {
+            return accessDelta;
+        }
+        return left.label.localeCompare(right.label);
+    });
+}

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.25",
+  "version": "0.2.27",
   "skills": [
     "./skills"
   ],

package/package.json

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

package/server/index.js

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = path.resolve(packageRoot, "..");
+const builtRuntimeEntry = path.join(packageRoot, "dist", "server", "server", "src", "index.js");
+const devRuntimeEntry = path.join(repoRoot, "server", "src", "index.ts");
+const devDataRootWrapper = path.join(repoRoot, "scripts", "with-openclaw-plugin-data-root.mjs");
+const tsxCliEntry = path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs");
+const devModeFlag = (process.env.FORGE_OPENCLAW_DEV ?? "").trim().toLowerCase();
+const useDevRuntime = devModeFlag === "1" || devModeFlag === "true" || devModeFlag === "yes";
+
+if (!useDevRuntime) {
+  await import(pathToFileURL(builtRuntimeEntry).href);
+} else {
+  if (!existsSync(devRuntimeEntry) || !existsSync(devDataRootWrapper) || !existsSync(tsxCliEntry)) {
+    throw new Error(
+      "FORGE_OPENCLAW_DEV is enabled, but the Forge repo dev runtime was not found. " +
+        "Run this from the Forge repository checkout or disable FORGE_OPENCLAW_DEV."
+    );
+  }
+
+  console.log("[forge-openclaw-plugin] starting source-backed dev runtime on port", process.env.PORT ?? "4317");
+
+  const child = spawn(
+    process.execPath,
+    [devDataRootWrapper, process.execPath, tsxCliEntry, "watch", devRuntimeEntry],
+    {
+      cwd: repoRoot,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        FORGE_DEV_WEB_ORIGIN:
+          process.env.FORGE_DEV_WEB_ORIGIN ?? "http://127.0.0.1:3027/forge/",
+        HOST: process.env.HOST ?? "0.0.0.0",
+        PORT: process.env.PORT ?? "4317"
+      }
+    }
+  );
+
+  const forwardSignal = (signal) => {
+    if (!child.killed) {
+      child.kill(signal);
+    }
+  };
+
+  process.on("SIGINT", forwardSignal);
+  process.on("SIGTERM", forwardSignal);
+
+  await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        process.exitCode = signal === "SIGINT" || signal === "SIGTERM" ? 0 : 1;
+        resolve();
+        return;
+      }
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Forge OpenClaw dev runtime exited with code ${code ?? "unknown"}.`));
+    });
+  });
+}
+

package/server/migrations/035_google_local_auth_settings.sql

@@ -0,0 +1,2 @@
+ALTER TABLE app_settings
+  ADD COLUMN google_client_id TEXT NOT NULL DEFAULT '';

package/server/migrations/036_google_local_auth_client_secret.sql

@@ -0,0 +1,2 @@
+ALTER TABLE app_settings
+  ADD COLUMN google_client_secret TEXT NOT NULL DEFAULT '';

package/server/migrations/037_workbench_public_inputs_and_run_inputs.sql

@@ -0,0 +1,5 @@
+ALTER TABLE ai_connectors
+ADD COLUMN public_inputs_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE ai_connector_runs
+ADD COLUMN inputs_json TEXT NOT NULL DEFAULT '{}';

package/server/migrations/038_data_management_settings.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS data_management_settings (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  preferred_data_root TEXT NOT NULL DEFAULT '',
+  backup_directory TEXT NOT NULL DEFAULT '',
+  backup_frequency_hours INTEGER,
+  auto_repair_enabled INTEGER NOT NULL DEFAULT 1,
+  last_auto_backup_at TEXT,
+  last_manual_backup_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);

package/server/migrations/039_life_force_and_action_points.sql

@@ -0,0 +1,114 @@
+ALTER TABLE tasks
+  ADD COLUMN resolution_kind TEXT;
+
+ALTER TABLE tasks
+  ADD COLUMN split_parent_task_id TEXT;
+
+CREATE TABLE IF NOT EXISTS life_force_profiles (
+  user_id TEXT PRIMARY KEY,
+  base_daily_ap INTEGER NOT NULL DEFAULT 200,
+  readiness_multiplier REAL NOT NULL DEFAULT 1.0,
+  life_force_level INTEGER NOT NULL DEFAULT 1,
+  activation_level INTEGER NOT NULL DEFAULT 1,
+  focus_level INTEGER NOT NULL DEFAULT 1,
+  vigor_level INTEGER NOT NULL DEFAULT 1,
+  composure_level INTEGER NOT NULL DEFAULT 1,
+  flow_level INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS life_force_weekday_templates (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  weekday INTEGER NOT NULL,
+  baseline_daily_ap INTEGER NOT NULL DEFAULT 200,
+  points_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(user_id, weekday)
+);
+
+CREATE TABLE IF NOT EXISTS life_force_day_snapshots (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  date_key TEXT NOT NULL,
+  daily_budget_ap REAL NOT NULL,
+  sleep_recovery_multiplier REAL NOT NULL DEFAULT 1.0,
+  readiness_multiplier REAL NOT NULL DEFAULT 1.0,
+  fatigue_debt_carry REAL NOT NULL DEFAULT 0,
+  points_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(user_id, date_key)
+);
+
+CREATE TABLE IF NOT EXISTS action_profile_templates (
+  id TEXT PRIMARY KEY,
+  profile_key TEXT NOT NULL UNIQUE,
+  entity_type TEXT,
+  title TEXT NOT NULL,
+  profile_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS entity_action_profiles (
+  id TEXT PRIMARY KEY,
+  entity_type TEXT NOT NULL,
+  entity_id TEXT NOT NULL,
+  profile_json TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(entity_type, entity_id)
+);
+
+CREATE TABLE IF NOT EXISTS ap_ledger_events (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  date_key TEXT NOT NULL,
+  entity_type TEXT NOT NULL,
+  entity_id TEXT NOT NULL,
+  event_kind TEXT NOT NULL,
+  source_kind TEXT NOT NULL,
+  starts_at TEXT,
+  ends_at TEXT,
+  total_ap REAL NOT NULL,
+  rate_ap_per_hour REAL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_ap_ledger_user_date
+  ON ap_ledger_events(user_id, date_key, created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_ap_ledger_entity
+  ON ap_ledger_events(entity_type, entity_id, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS stat_xp_events (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  stat_key TEXT NOT NULL,
+  delta_xp REAL NOT NULL,
+  entity_type TEXT,
+  entity_id TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_stat_xp_user_stat
+  ON stat_xp_events(user_id, stat_key, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS fatigue_signals (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL,
+  date_key TEXT NOT NULL,
+  signal_type TEXT NOT NULL,
+  observed_at TEXT NOT NULL,
+  note TEXT NOT NULL DEFAULT '',
+  delta REAL NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_fatigue_signals_user_date
+  ON fatigue_signals(user_id, date_key, observed_at DESC);