forge-openclaw-plugin 0.2.99 → 0.2.100

package/dist/openclaw/tools.js

@@ -269,6 +269,62 @@ const healthLinkInputSchema = () => Type.Object({
     entityId: Type.String({ minLength: 1 }),
     relationshipType: Type.Optional(Type.String({ minLength: 1 }))
 });
+const nutritionMealItemInputSchema = () => Type.Object({
+    name: Type.String({ minLength: 1 }),
+    brand: optionalNullableString(),
+    quantity: Type.Number({ minimum: 0 }),
+    unit: optionalNullableString(),
+    caloriesKcal: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    proteinG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    carbsG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    fatG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    fiberG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    sugarG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    sodiumMg: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    potassiumMg: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    caffeineMg: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    alcoholG: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    glycemicIndex: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    novaGroup: Type.Optional(Type.Union([Type.Integer(), Type.Null()])),
+    fermented: Type.Optional(Type.Union([Type.Boolean(), Type.Null()])),
+    probiotic: Type.Optional(Type.Union([Type.Boolean(), Type.Null()])),
+    fodmapLevel: Type.Optional(Type.Union([
+        Type.Literal("low"),
+        Type.Literal("medium"),
+        Type.Literal("high"),
+        Type.Null()
+    ])),
+    tags: Type.Optional(Type.Array(Type.String())),
+    confidence: Type.Optional(Type.Union([Type.Number(), Type.Null()]))
+});
+const nutritionUserScopeSchema = () => Type.Optional(Type.Array(Type.String({ minLength: 1 })));
+const nutritionFoodLogSchema = () => Type.Object({
+    userIds: nutritionUserScopeSchema(),
+    loggedAt: optionalString(),
+    mealLabel: optionalNullableString(),
+    source: Type.Optional(Type.Union([
+        Type.Literal("manual"),
+        Type.Literal("barcode"),
+        Type.Literal("chatgpt"),
+        Type.Literal("photo"),
+        Type.Literal("import")
+    ])),
+    confirmationState: Type.Optional(Type.Union([
+        Type.Literal("candidate"),
+        Type.Literal("confirmed"),
+        Type.Literal("corrected"),
+        Type.Literal("rejected")
+    ])),
+    satietyScore: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    hungerBefore: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    hungerAfter: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    cravingScore: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    enjoymentScore: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+    socialContext: optionalNullableString(),
+    locationContext: optionalNullableString(),
+    notes: optionalNullableString(),
+    items: Type.Array(nutritionMealItemInputSchema(), { minItems: 1 })
+});
 const noteInputSchema = () => Type.Object({
     contentMarkdown: Type.String({ minLength: 1 }),
     author: optionalNullableString(),
@@ -759,6 +815,290 @@ export function registerForgePluginTools(api, config) {
         parameters: scopedReadSchema,
         path: (params) => withUserIds("/api/v1/health/training-load", params.userIds)
     });
+    registerReadTool(api, config, {
+        name: "forge_get_weight_loss_overview",
+        label: "Forge Weight Loss Overview",
+        description: "Read the weight-loss and nutrition insight surface with calorie ledger, protein/fiber targets, energy balance, body trend, subjective energy, gut comfort, aesthetic check-ins, hypotheses, experiments, and data-quality flags.",
+        parameters: scopedReadSchema,
+        path: (params) => withUserIds("/api/v1/health/weight-loss", params.userIds)
+    });
+    api.registerTool({
+        name: "forge_search_nutrition_foods",
+        label: "Forge Search Nutrition Foods",
+        description: "Search local, Open Food Facts, and USDA-backed nutrition foods before logging a concrete food item.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            query: Type.String({ minLength: 1 }),
+            limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 30 }))
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/foods/search", typed.userIds),
+                body: { query: typed.query, limit: typed.limit }
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_search_foods",
+        label: "Forge Search Foods",
+        description: "Search local, Open Food Facts, and USDA-backed nutrition foods before logging a concrete food item. This is the short alias for forge_search_nutrition_foods.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            query: Type.String({ minLength: 1 }),
+            limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 30 }))
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/foods/search", typed.userIds),
+                body: { query: typed.query, limit: typed.limit }
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_lookup_nutrition_barcode",
+        label: "Forge Lookup Nutrition Barcode",
+        description: "Lookup a packaged food by barcode through Forge's nutrition catalog adapters.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            barcode: Type.String({ minLength: 1 })
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/foods/barcode", typed.userIds),
+                body: { barcode: typed.barcode }
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_log_food",
+        label: "Forge Log Food",
+        description: "Create a confirmed or candidate food log with explicit meal items, calories, macros, quality tags, hunger, satiety, cravings, and context.",
+        parameters: nutritionFoodLogSchema(),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/food-logs", typed.userIds),
+                body
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_parse_food_log_with_chatgpt",
+        label: "Forge Parse Food Log With ChatGPT",
+        description: "Use Forge's openai-codex ChatGPT subscription connection to parse natural-language food text or a photo description into a candidate nutrition log. This must not use the metered OpenAI API.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            text: optionalString(),
+            imageDescription: optionalString(),
+            loggedAt: optionalString(),
+            mealLabel: optionalString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/parse", typed.userIds),
+                body: {
+                    text: typed.text,
+                    imageDescription: typed.imageDescription,
+                    loggedAt: typed.loggedAt,
+                    mealLabel: typed.mealLabel
+                }
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_log_body_checkin",
+        label: "Forge Log Body Check-In",
+        description: "Record body-composition check-ins such as weight, waist, hip, neck, body-fat estimate, and notes for trend calculations.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            checkedAt: optionalString(),
+            weightKg: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            waistCm: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            hipCm: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            neckCm: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            bodyFatPercent: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            photoAssetId: optionalNullableString(),
+            notes: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/body-checkins", typed.userIds),
+                body
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_log_appearance_checkin",
+        label: "Forge Log Appearance Check-In",
+        description: "Record aesthetic-look metrics such as muscle fullness, leanness, vascularity, face puffiness, visual bloat, posture confidence, outfit fit, and overall aesthetic score.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            checkedAt: optionalString(),
+            muscleFullness: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            leanness: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            vascularity: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            facePuffiness: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            abdomenBloatLook: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            postureConfidence: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            outfitFit: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            aestheticScore: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            notes: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/appearance-checkins", typed.userIds),
+                body
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_log_subjective_food_effect",
+        label: "Forge Log Subjective Food Effect",
+        description: "Record subjective food-effect metrics such as energy, mood, focus, libido, sleepiness, soreness, stress, hunger, cravings, and workout performance.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            checkedAt: optionalString(),
+            energy: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            mood: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            focus: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            libido: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            sleepiness: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            soreness: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            stress: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            hunger: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            cravings: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            workoutPerformance: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            timeRelation: optionalNullableString(),
+            linkedFoodLogId: optionalNullableString(),
+            notes: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/subjective-checkins", typed.userIds),
+                body
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_log_gut_checkin",
+        label: "Forge Log Gut Check-In",
+        description: "Record gut-health food-effect metrics such as bloating, abdominal pain, gas, reflux, nausea, stool type, stool frequency, and suspected triggers.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            checkedAt: optionalString(),
+            bloating: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            abdominalPain: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            gas: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            reflux: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            nausea: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            stoolType: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            stoolFrequency: Type.Optional(Type.Union([Type.Number(), Type.Null()])),
+            suspectedTrigger: optionalNullableString(),
+            linkedFoodLogId: optionalNullableString(),
+            notes: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/gut-checkins", typed.userIds),
+                body
+            }));
+        }
+    });
+    registerReadTool(api, config, {
+        name: "forge_get_nutrition_patterns",
+        label: "Forge Nutrition Patterns",
+        description: "Read current food-effect hypotheses and nutrition experiments, including links between meals, sport fueling, energy, gut comfort, cravings, and aesthetic look.",
+        parameters: scopedReadSchema,
+        path: (params) => withUserIds("/api/v1/health/weight-loss/patterns", params.userIds)
+    });
+    api.registerTool({
+        name: "forge_start_nutrition_experiment",
+        label: "Forge Start Nutrition Experiment",
+        description: "Create a structured N-of-1 nutrition experiment, such as carb timing, caffeine timing, low-FODMAP trial, sodium/puffiness test, fiber ramp, or pre-training fueling.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            title: Type.String({ minLength: 1 }),
+            hypothesis: Type.String({ minLength: 1 }),
+            metricKey: Type.String({ minLength: 1 }),
+            intervention: Type.String({ minLength: 1 }),
+            baselineStart: optionalNullableString(),
+            baselineEnd: optionalNullableString(),
+            experimentStart: optionalNullableString(),
+            experimentEnd: optionalNullableString(),
+            status: Type.Optional(Type.Union([
+                Type.Literal("planned"),
+                Type.Literal("running"),
+                Type.Literal("completed"),
+                Type.Literal("abandoned")
+            ])),
+            successCriteria: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "POST",
+                path: withUserIds("/api/v1/health/weight-loss/experiments", typed.userIds),
+                body
+            }));
+        }
+    });
+    api.registerTool({
+        name: "forge_update_nutrition_experiment",
+        label: "Forge Update Nutrition Experiment",
+        description: "Patch a nutrition experiment's status, dates, success criteria, intervention, hypothesis, or conclusion after new evidence arrives.",
+        parameters: Type.Object({
+            userIds: nutritionUserScopeSchema(),
+            experimentId: Type.String({ minLength: 1 }),
+            title: optionalString(),
+            hypothesis: optionalString(),
+            metricKey: optionalString(),
+            intervention: optionalString(),
+            baselineStart: optionalNullableString(),
+            baselineEnd: optionalNullableString(),
+            experimentStart: optionalNullableString(),
+            experimentEnd: optionalNullableString(),
+            status: Type.Optional(Type.Union([
+                Type.Literal("planned"),
+                Type.Literal("running"),
+                Type.Literal("completed"),
+                Type.Literal("abandoned")
+            ])),
+            successCriteria: optionalNullableString(),
+            conclusion: optionalNullableString()
+        }),
+        async execute(_toolCallId, params) {
+            const typed = params;
+            const { userIds: _userIds, experimentId: _experimentId, ...body } = typed;
+            return jsonResult(await runWrite(config, {
+                method: "PATCH",
+                path: withUserIds(`/api/v1/health/weight-loss/experiments/${typed.experimentId}`, typed.userIds),
+                body
+            }));
+        }
+    });
     api.registerTool({
         name: "forge_update_sleep_session",
         label: "Forge Update Sleep Session",

package/dist/server/server/migrations/065_weight_loss_nutrition_insights.sql

@@ -0,0 +1,236 @@
+CREATE TABLE IF NOT EXISTS nutrition_targets (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  calorie_target REAL,
+  protein_grams_target REAL,
+  fiber_grams_target REAL,
+  carbohydrate_grams_target REAL,
+  fat_grams_target REAL,
+  weight_goal_kg REAL,
+  weekly_rate_goal_kg REAL,
+  diet_style TEXT NOT NULL DEFAULT '',
+  body_goal TEXT NOT NULL DEFAULT '',
+  notes TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_nutrition_targets_user
+  ON nutrition_targets(user_id);
+
+CREATE TABLE IF NOT EXISTS nutrition_food_catalog (
+  id TEXT PRIMARY KEY,
+  source TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  barcode TEXT,
+  name TEXT NOT NULL,
+  brand TEXT NOT NULL DEFAULT '',
+  serving_label TEXT NOT NULL DEFAULT '',
+  serving_grams REAL,
+  calories REAL,
+  protein_grams REAL,
+  carbohydrate_grams REAL,
+  fat_grams REAL,
+  fiber_grams REAL,
+  sugar_grams REAL,
+  sodium_mg REAL,
+  potassium_mg REAL,
+  caffeine_mg REAL,
+  alcohol_grams REAL,
+  nova_group INTEGER,
+  nutri_score TEXT,
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  nutrients_json TEXT NOT NULL DEFAULT '{}',
+  confidence REAL NOT NULL DEFAULT 0.65,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_nutrition_food_catalog_source
+  ON nutrition_food_catalog(source, source_id);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_food_catalog_barcode
+  ON nutrition_food_catalog(barcode);
+
+CREATE TABLE IF NOT EXISTS nutrition_food_logs (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  logged_at TEXT NOT NULL,
+  meal_label TEXT NOT NULL DEFAULT '',
+  source TEXT NOT NULL DEFAULT 'manual',
+  confirmation_state TEXT NOT NULL DEFAULT 'confirmed',
+  notes TEXT NOT NULL DEFAULT '',
+  place_id TEXT,
+  stay_id TEXT,
+  workout_id TEXT,
+  sleep_id TEXT,
+  day_key TEXT NOT NULL,
+  image_refs_json TEXT NOT NULL DEFAULT '[]',
+  parser_provenance_json TEXT NOT NULL DEFAULT '{}',
+  links_json TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_food_logs_user_time
+  ON nutrition_food_logs(user_id, logged_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_food_logs_day
+  ON nutrition_food_logs(user_id, day_key);
+
+CREATE TABLE IF NOT EXISTS nutrition_meal_items (
+  id TEXT PRIMARY KEY,
+  log_id TEXT NOT NULL REFERENCES nutrition_food_logs(id) ON DELETE CASCADE,
+  food_id TEXT REFERENCES nutrition_food_catalog(id) ON DELETE SET NULL,
+  name TEXT NOT NULL,
+  quantity REAL NOT NULL DEFAULT 1,
+  unit TEXT NOT NULL DEFAULT 'serving',
+  grams REAL,
+  calories REAL,
+  protein_grams REAL,
+  carbohydrate_grams REAL,
+  fat_grams REAL,
+  fiber_grams REAL,
+  sugar_grams REAL,
+  sodium_mg REAL,
+  potassium_mg REAL,
+  caffeine_mg REAL,
+  alcohol_grams REAL,
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  nutrients_json TEXT NOT NULL DEFAULT '{}',
+  confidence REAL NOT NULL DEFAULT 0.65,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_meal_items_log
+  ON nutrition_meal_items(log_id);
+
+CREATE TABLE IF NOT EXISTS nutrition_body_checkins (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  checked_at TEXT NOT NULL,
+  weight_kg REAL,
+  waist_cm REAL,
+  hip_cm REAL,
+  neck_cm REAL,
+  chest_cm REAL,
+  arm_cm REAL,
+  thigh_cm REAL,
+  body_fat_percent REAL,
+  clothing_fit_score INTEGER,
+  notes TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_body_checkins_user_time
+  ON nutrition_body_checkins(user_id, checked_at DESC);
+
+CREATE TABLE IF NOT EXISTS nutrition_appearance_checkins (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  checked_at TEXT NOT NULL,
+  photo_refs_json TEXT NOT NULL DEFAULT '[]',
+  face_puffiness INTEGER,
+  leanness INTEGER,
+  muscularity INTEGER,
+  posture INTEGER,
+  bloating_look INTEGER,
+  confidence_score INTEGER,
+  notes TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_appearance_checkins_user_time
+  ON nutrition_appearance_checkins(user_id, checked_at DESC);
+
+CREATE TABLE IF NOT EXISTS nutrition_subjective_checkins (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  checked_at TEXT NOT NULL,
+  meal_log_id TEXT REFERENCES nutrition_food_logs(id) ON DELETE SET NULL,
+  time_relation TEXT NOT NULL DEFAULT 'unspecified',
+  hunger INTEGER,
+  fullness INTEGER,
+  cravings INTEGER,
+  mood INTEGER,
+  energy INTEGER,
+  focus INTEGER,
+  stress INTEGER,
+  sleepiness INTEGER,
+  crash_score INTEGER,
+  notes TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_subjective_checkins_user_time
+  ON nutrition_subjective_checkins(user_id, checked_at DESC);
+
+CREATE TABLE IF NOT EXISTS nutrition_gut_checkins (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  checked_at TEXT NOT NULL,
+  meal_log_id TEXT REFERENCES nutrition_food_logs(id) ON DELETE SET NULL,
+  bristol_stool_type INTEGER,
+  stool_frequency INTEGER,
+  bloating INTEGER,
+  gas INTEGER,
+  reflux INTEGER,
+  abdominal_pain INTEGER,
+  urgency INTEGER,
+  nausea INTEGER,
+  constipation INTEGER,
+  diarrhea INTEGER,
+  trigger_tags_json TEXT NOT NULL DEFAULT '[]',
+  notes TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_gut_checkins_user_time
+  ON nutrition_gut_checkins(user_id, checked_at DESC);
+
+CREATE TABLE IF NOT EXISTS nutrition_hypotheses (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'candidate',
+  confidence REAL NOT NULL DEFAULT 0.25,
+  evidence_count INTEGER NOT NULL DEFAULT 0,
+  signal_key TEXT NOT NULL DEFAULT '',
+  outcome_key TEXT NOT NULL DEFAULT '',
+  lag_window TEXT NOT NULL DEFAULT '',
+  evidence_json TEXT NOT NULL DEFAULT '{}',
+  confounders_json TEXT NOT NULL DEFAULT '[]',
+  suggested_action TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_hypotheses_user_status
+  ON nutrition_hypotheses(user_id, status, updated_at DESC);
+
+CREATE TABLE IF NOT EXISTS nutrition_experiments (
+  id TEXT PRIMARY KEY,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  hypothesis_id TEXT REFERENCES nutrition_hypotheses(id) ON DELETE SET NULL,
+  title TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'planned',
+  baseline_start TEXT,
+  baseline_end TEXT,
+  intervention_start TEXT,
+  intervention_end TEXT,
+  tracked_outcomes_json TEXT NOT NULL DEFAULT '[]',
+  protocol_json TEXT NOT NULL DEFAULT '{}',
+  adherence_json TEXT NOT NULL DEFAULT '{}',
+  result_summary TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_nutrition_experiments_user_status
+  ON nutrition_experiments(user_id, status, updated_at DESC);

package/dist/server/server/migrations/066_watch_action_receipts.sql

@@ -0,0 +1,20 @@
+CREATE TABLE IF NOT EXISTS watch_action_receipts (
+  id TEXT PRIMARY KEY,
+  pairing_session_id TEXT REFERENCES companion_pairing_sessions(id) ON DELETE SET NULL,
+  user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  action_id TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  received_at TEXT NOT NULL,
+  processed_at TEXT NOT NULL,
+  status TEXT NOT NULL,
+  result_json TEXT NOT NULL DEFAULT '{}',
+  error_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  UNIQUE (user_id, action_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_watch_action_receipts_user_processed
+  ON watch_action_receipts(user_id, processed_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_watch_action_receipts_kind
+  ON watch_action_receipts(user_id, kind, processed_at DESC);