forge-openclaw-plugin 0.2.98 → 0.2.100

package/dist/server/server/src/openapi.js

@@ -4101,6 +4101,10 @@ export function buildOpenApiDocument() {
                     "reviewShortcutRule",
                     "readModelWriteRule",
                     "psycheOpeningQuestionRule",
+                    "psycheHypothesisRule",
+                    "mixedIntentSequencingRule",
+                    "duplicateDisambiguationRule",
+                    "destructiveActionRule",
                     "followUpQuestionRule",
                     "antiDriftRule",
                     "duplicateCheckRoute",
@@ -4118,6 +4122,10 @@ export function buildOpenApiDocument() {
                     reviewShortcutRule: { type: "string" },
                     readModelWriteRule: { type: "string" },
                     psycheOpeningQuestionRule: { type: "string" },
+                    psycheHypothesisRule: { type: "string" },
+                    mixedIntentSequencingRule: { type: "string" },
+                    duplicateDisambiguationRule: { type: "string" },
+                    destructiveActionRule: { type: "string" },
                     followUpQuestionRule: { type: "string" },
                     antiDriftRule: { type: "string" },
                     duplicateCheckRoute: { type: "string" },
@@ -5216,6 +5224,139 @@ export function buildOpenApiDocument() {
             targetModel: { type: "object", additionalProperties: true }
         }
     };
+    const nutritionMealItemInput = {
+        type: "object",
+        additionalProperties: false,
+        required: ["name", "quantity"],
+        properties: {
+            name: { type: "string" },
+            brand: nullable({ type: "string" }),
+            quantity: { type: "number" },
+            unit: nullable({ type: "string" }),
+            calories: nullable({ type: "number" }),
+            proteinGrams: nullable({ type: "number" }),
+            carbohydrateGrams: nullable({ type: "number" }),
+            fatGrams: nullable({ type: "number" }),
+            fiberGrams: nullable({ type: "number" }),
+            sugarGrams: nullable({ type: "number" }),
+            sodiumMg: nullable({ type: "number" }),
+            potassiumMg: nullable({ type: "number" }),
+            caffeineMg: nullable({ type: "number" }),
+            alcoholGrams: nullable({ type: "number" }),
+            tags: arrayOf({ type: "string" }),
+            confidence: nullable({ type: "number" })
+        }
+    };
+    const nutritionFoodLogInput = {
+        type: "object",
+        additionalProperties: false,
+        required: ["items"],
+        properties: {
+            loggedAt: { type: "string", format: "date-time" },
+            mealLabel: nullable({ type: "string" }),
+            source: {
+                type: "string",
+                enum: ["manual", "search", "barcode", "chatgpt", "photo", "saved_meal"]
+            },
+            confirmationState: {
+                type: "string",
+                enum: ["candidate", "confirmed", "needs_review", "discarded"]
+            },
+            userId: { type: "string" },
+            placeId: nullable({ type: "string" }),
+            stayId: nullable({ type: "string" }),
+            workoutId: nullable({ type: "string" }),
+            sleepId: nullable({ type: "string" }),
+            dayKey: nullable({ type: "string" }),
+            imageRefs: arrayOf({ type: "string" }),
+            parserProvenance: { type: "object", additionalProperties: true },
+            satietyScore: nullable({ type: "number" }),
+            hungerBefore: nullable({ type: "number" }),
+            hungerAfter: nullable({ type: "number" }),
+            cravingScore: nullable({ type: "number" }),
+            enjoymentScore: nullable({ type: "number" }),
+            socialContext: nullable({ type: "string" }),
+            locationContext: nullable({ type: "string" }),
+            notes: nullable({ type: "string" }),
+            items: arrayOf(nutritionMealItemInput)
+        }
+    };
+    const nutritionFoodLog = {
+        type: "object",
+        additionalProperties: true,
+        required: ["id", "loggedAt", "items", "totals"],
+        properties: {
+            id: { type: "string" },
+            userId: { type: "string" },
+            loggedAt: { type: "string", format: "date-time" },
+            mealLabel: nullable({ type: "string" }),
+            source: { type: "string" },
+            confirmationState: { type: "string" },
+            totals: { type: "object", additionalProperties: { type: "number" } },
+            items: arrayOf({ type: "object", additionalProperties: true })
+        }
+    };
+    const nutritionFoodSearchResult = {
+        type: "object",
+        additionalProperties: true,
+        required: ["id", "source", "name"],
+        properties: {
+            id: { type: "string" },
+            source: { type: "string" },
+            sourceId: nullable({ type: "string" }),
+            name: { type: "string" },
+            brand: nullable({ type: "string" }),
+            barcode: nullable({ type: "string" }),
+            servingLabel: nullable({ type: "string" }),
+            servingGrams: nullable({ type: "number" }),
+            calories: nullable({ type: "number" }),
+            proteinGrams: nullable({ type: "number" }),
+            carbohydrateGrams: nullable({ type: "number" }),
+            fatGrams: nullable({ type: "number" }),
+            fiberGrams: nullable({ type: "number" }),
+            tags: arrayOf({ type: "string" })
+        }
+    };
+    const weightLossViewData = {
+        type: "object",
+        additionalProperties: false,
+        required: [
+            "userId",
+            "generatedAt",
+            "target",
+            "summary",
+            "todayLedger",
+            "recentMeals",
+            "energyModel",
+            "weightTrend",
+            "foodQuality",
+            "trainingFuel",
+            "subjective",
+            "gut",
+            "hypotheses",
+            "experiments",
+            "dataQuality"
+        ],
+        properties: {
+            userId: { type: "string" },
+            generatedAt: { type: "string", format: "date-time" },
+            target: { type: "object", additionalProperties: true },
+            summary: { type: "object", additionalProperties: true },
+            todayLedger: { type: "object", additionalProperties: true },
+            recentMeals: arrayOf(nutritionFoodLog),
+            bodyCheckins: arrayOf({ type: "object", additionalProperties: true }),
+            appearanceCheckins: arrayOf({ type: "object", additionalProperties: true }),
+            energyModel: { type: "object", additionalProperties: true },
+            weightTrend: { type: "object", additionalProperties: true },
+            foodQuality: { type: "object", additionalProperties: true },
+            trainingFuel: { type: "object", additionalProperties: true },
+            subjective: { type: "object", additionalProperties: true },
+            gut: { type: "object", additionalProperties: true },
+            hypotheses: arrayOf({ type: "object", additionalProperties: true }),
+            experiments: arrayOf({ type: "object", additionalProperties: true }),
+            dataQuality: { type: "object", additionalProperties: true }
+        }
+    };
     const document = {
         openapi: "3.1.0",
         info: {
@@ -5328,6 +5469,11 @@ export function buildOpenApiDocument() {
                 SleepViewData: sleepViewData,
                 FitnessViewData: fitnessViewData,
                 TrainingLoadViewData: trainingLoadViewData,
+                NutritionMealItemInput: nutritionMealItemInput,
+                NutritionFoodLogInput: nutritionFoodLogInput,
+                NutritionFoodLog: nutritionFoodLog,
+                NutritionFoodSearchResult: nutritionFoodSearchResult,
+                WeightLossViewData: weightLossViewData,
                 PsycheMetricsViewData: psycheMetricsViewData,
                 PsycheOverviewPayload: psycheOverviewPayload,
                 Insight: insight,
@@ -5635,6 +5781,309 @@ export function buildOpenApiDocument() {
                     }
                 }
             },
+            "/api/v1/health/weight-loss": {
+                get: {
+                    tags: ["Health"],
+                    summary: "Read the Forge nutrition, weight-loss, food-effect, and body insight surface",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["weightLoss"],
+                            properties: {
+                                weightLoss: {
+                                    $ref: "#/components/schemas/WeightLossViewData"
+                                }
+                            }
+                        }, "Weight loss overview")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/target": {
+                patch: {
+                    tags: ["Health"],
+                    summary: "Update nutrition and weight-loss targets",
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: { type: "object", additionalProperties: true }
+                            }
+                        }
+                    },
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["target"],
+                            properties: {
+                                target: { type: "object", additionalProperties: true }
+                            }
+                        }, "Updated nutrition target")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/foods/search": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Search nutrition foods across local and public catalogs",
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    required: ["query"],
+                                    properties: {
+                                        query: { type: "string" },
+                                        limit: { type: "integer", minimum: 1, maximum: 30 }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["foods"],
+                            properties: {
+                                foods: arrayOf({
+                                    $ref: "#/components/schemas/NutritionFoodSearchResult"
+                                })
+                            }
+                        }, "Nutrition food search results")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/foods/barcode": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Lookup one nutrition food by barcode",
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    required: ["barcode"],
+                                    properties: { barcode: { type: "string" } }
+                                }
+                            }
+                        }
+                    },
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["food"],
+                            properties: {
+                                food: nullable({
+                                    $ref: "#/components/schemas/NutritionFoodSearchResult"
+                                })
+                            }
+                        }, "Nutrition barcode lookup result")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/food-logs": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create a nutrition food log",
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/NutritionFoodLogInput" }
+                            }
+                        }
+                    },
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["log"],
+                            properties: {
+                                log: { $ref: "#/components/schemas/NutritionFoodLog" }
+                            }
+                        }, "Created nutrition food log")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/food-logs/{id}": {
+                patch: {
+                    tags: ["Health"],
+                    summary: "Patch a nutrition food log",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["log"],
+                            properties: {
+                                log: { $ref: "#/components/schemas/NutritionFoodLog" }
+                            }
+                        }, "Updated nutrition food log")
+                    }
+                },
+                delete: {
+                    tags: ["Health"],
+                    summary: "Delete a nutrition food log",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["deleted"],
+                            properties: { deleted: { type: "boolean" } }
+                        }, "Deleted nutrition food log")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/parse": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Parse a food log through Forge's openai-codex ChatGPT subscription connection",
+                    requestBody: {
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    properties: {
+                                        text: { type: "string" },
+                                        imageDescription: { type: "string" },
+                                        loggedAt: { type: "string", format: "date-time" },
+                                        mealLabel: { type: "string" }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: [
+                                "candidate",
+                                "log",
+                                "clarificationQuestions",
+                                "uncertaintyReasons"
+                            ],
+                            properties: {
+                                candidate: {
+                                    $ref: "#/components/schemas/NutritionFoodLogInput"
+                                },
+                                log: nullable({
+                                    $ref: "#/components/schemas/NutritionFoodLog"
+                                }),
+                                clarificationQuestions: arrayOf({ type: "string" }),
+                                uncertaintyReasons: arrayOf({ type: "string" })
+                            }
+                        }, "Parsed candidate nutrition food log")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/body-checkins": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create a body-composition check-in",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["checkin"],
+                            properties: {
+                                checkin: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created body check-in")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/appearance-checkins": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create an aesthetic appearance check-in",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["checkin"],
+                            properties: {
+                                checkin: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created appearance check-in")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/subjective-checkins": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create a subjective food-effect check-in",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["checkin"],
+                            properties: {
+                                checkin: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created subjective check-in")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/gut-checkins": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create a gut-health food-effect check-in",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["checkin"],
+                            properties: {
+                                checkin: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created gut check-in")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/patterns": {
+                get: {
+                    tags: ["Health"],
+                    summary: "Read current nutrition hypotheses and experiments",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["hypotheses", "experiments"],
+                            properties: {
+                                hypotheses: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                }),
+                                experiments: arrayOf({
+                                    type: "object",
+                                    additionalProperties: true
+                                })
+                            }
+                        }, "Nutrition pattern candidates")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/experiments": {
+                post: {
+                    tags: ["Health"],
+                    summary: "Create a nutrition N-of-1 experiment",
+                    responses: {
+                        "201": jsonResponse({
+                            type: "object",
+                            required: ["experiment"],
+                            properties: {
+                                experiment: { type: "object", additionalProperties: true }
+                            }
+                        }, "Created nutrition experiment")
+                    }
+                }
+            },
+            "/api/v1/health/weight-loss/experiments/{id}": {
+                patch: {
+                    tags: ["Health"],
+                    summary: "Patch a nutrition N-of-1 experiment",
+                    responses: {
+                        "200": jsonResponse({
+                            type: "object",
+                            required: ["experiment"],
+                            properties: {
+                                experiment: { type: "object", additionalProperties: true }
+                            }
+                        }, "Updated nutrition experiment")
+                    }
+                }
+            },
             "/api/v1/health/workouts": {
                 post: {
                     summary: "Create one manual workout session",

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

@@ -2,7 +2,6 @@ import { listActivityEvents } from "../repositories/activity-events.js";
 import { listRewardLedger } from "../repositories/rewards.js";
 import { listTags, listTagsByIds } from "../repositories/tags.js";
 import { getDashboard } from "./dashboard.js";
-import { buildAchievementSignals, buildGamificationProfile, buildMilestoneRewards } from "./gamification.js";
 import { overviewContextSchema, riskContextSchema, todayContextSchema } from "../types.js";
 function priorityWeight(task) {
     switch (task.priority) {
@@ -105,7 +104,7 @@ function buildDomainBalance(goals, tasks) {
     return [...domainRows.values()].sort((left, right) => right.completedPoints - left.completedPoints);
 }
 export function getOverviewContext(now = new Date(), options = {}) {
-    const dashboard = getDashboard(options);
+    const dashboard = options.dashboard ?? getDashboard({ userIds: options.userIds });
     const focusTasks = dashboard.tasks.filter((task) => task.status === "focus" || task.status === "in_progress").length;
     const overdueTasks = dashboard.tasks.filter((task) => task.status !== "done" && task.dueDate !== null && task.dueDate < now.toISOString().slice(0, 10)).length;
     const dueHabits = dashboard.habits.filter((habit) => habit.dueToday).slice(0, 6);
@@ -129,17 +128,17 @@ export function getOverviewContext(now = new Date(), options = {}) {
         topTasks: sortStrategicTasks(tasks.filter((task) => task.status !== "done")).slice(0, 6),
         dueHabits,
         recentEvidence: listActivityEvents({ limit: 12, userIds: options.userIds }),
-        achievements: buildAchievementSignals(goals, tasks, habits, now),
+        achievements: dashboard.achievements,
         domainBalance: buildDomainBalance(goals, tasks),
         neglectedGoals: buildNeglectedGoals(goals, tasks, now)
     });
 }
 export function getTodayContext(now = new Date(), options = {}) {
-    const dashboard = getDashboard(options);
+    const dashboard = options.dashboard ?? getDashboard({ userIds: options.userIds });
     const goals = dashboard.goals;
     const tasks = dashboard.tasks;
     const habits = dashboard.habits;
-    const gamification = buildGamificationProfile(goals, tasks, habits, now);
+    const gamification = dashboard.gamification;
     const inProgressTasks = sortStrategicTasks(tasks.filter((task) => task.status === "in_progress")).slice(0, 4);
     const readyTasks = sortStrategicTasks(tasks.filter((task) => task.status === "focus" || task.status === "backlog")).slice(0, 4);
     const deferredTasks = sortStrategicTasks(tasks.filter((task) => task.status === "blocked")).slice(0, 4);
@@ -193,7 +192,7 @@ export function getTodayContext(now = new Date(), options = {}) {
             }
         ],
         dueHabits,
-        milestoneRewards: buildMilestoneRewards(goals, tasks, habits, now),
+        milestoneRewards: dashboard.milestoneRewards,
         recentHabitRewards: listRewardLedger({ entityType: "habit", limit: 8 }),
         momentum: {
             streakDays: gamification.streakDays,
@@ -207,7 +206,7 @@ export function getTodayContext(now = new Date(), options = {}) {
     });
 }
 export function getRiskContext(now = new Date(), options = {}) {
-    const dashboard = getDashboard(options);
+    const dashboard = options.dashboard ?? getDashboard({ userIds: options.userIds });
     const tasks = dashboard.tasks;
     const goals = dashboard.goals;
     const overdueTasks = sortStrategicTasks(tasks.filter((task) => task.status !== "done" && task.dueDate !== null && task.dueDate < now.toISOString().slice(0, 10))).slice(0, 8);

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

@@ -464,7 +464,39 @@ function strategyJsonChecks() {
 function rewardAndGamificationChecks(settings) {
     const checks = [];
     const catalogItemIds = new Set(GAMIFICATION_CATALOG.map((item) => item.id));
-    const equipmentItemIds = new Set(GAMIFICATION_CATALOG.filter((item) => item.kind === "unlock").map((item) => item.id));
+    const equipmentValueFields = [
+        {
+            column: "selected_mascot_skin",
+            unlockType: "mascot_skin",
+            payloadKey: "mascotSkin"
+        },
+        {
+            column: "selected_hud_treatment",
+            unlockType: "hud_treatment",
+            payloadKey: "hudTreatment"
+        },
+        {
+            column: "selected_streak_effect",
+            unlockType: "streak_effect",
+            payloadKey: "streakEffect"
+        },
+        {
+            column: "selected_trophy_shelf",
+            unlockType: "trophy_shelf",
+            payloadKey: "trophyShelf"
+        },
+        {
+            column: "selected_celebration_variant",
+            unlockType: "celebration_variant",
+            payloadKey: "celebrationVariant"
+        }
+    ];
+    const equipmentValuesByColumn = new Map(equipmentValueFields.map((field) => [
+        field.column,
+        new Set(GAMIFICATION_CATALOG.filter((item) => item.kind === "unlock" &&
+            item.unlockType === field.unlockType &&
+            typeof item.rewardPayload[field.payloadKey] === "string").map((item) => item.rewardPayload[field.payloadKey]))
+    ]));
     checks.push(safeCountCheck({
         id: "rewards.rules.missing",
         group: "Rewards",
@@ -532,7 +564,10 @@ function rewardAndGamificationChecks(settings) {
         : [];
     const staleEquipment = equipmentRows.reduce((count, row) => {
         return (count +
-            Object.values(row).filter((value) => typeof value === "string" && !equipmentItemIds.has(value)).length);
+            Object.entries(row).filter(([column, value]) => typeof value === "string" &&
+                !(equipmentValuesByColumn
+                    .get(column)
+                    ?.has(value) ?? false)).length);
     }, 0);
     checks.push(check({
         id: "rewards.gamification.equipment",
@@ -541,8 +576,8 @@ function rewardAndGamificationChecks(settings) {
         passed: staleEquipment === 0,
         severity: "warning",
         summary: staleEquipment === 0
-            ? "Selected gamification equipment points to current unlock catalog items."
-            : `${staleEquipment} selected equipment reference${staleEquipment === 1 ? "" : "s"} point to removed catalog items.`,
+            ? "Selected gamification equipment values match current unlock reward payloads."
+            : `${staleEquipment} selected equipment value${staleEquipment === 1 ? "" : "s"} point to removed catalog rewards.`,
         affectedCount: staleEquipment
     }));
     return checks.concat(check({