forge-openclaw-plugin 0.3.5 → 0.3.6

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

@@ -5354,6 +5354,10 @@ export function buildOpenApiDocument() {
         required: ["items"],
         properties: {
             loggedAt: { type: "string", format: "date-time" },
+            timeZone: {
+                type: "string",
+                description: "IANA timezone used to derive the local dayKey when dayKey is omitted."
+            },
             mealLabel: nullable({ type: "string" }),
             source: {
                 type: "string",
@@ -5889,6 +5893,29 @@ export function buildOpenApiDocument() {
                 get: {
                     tags: ["Health"],
                     summary: "Read the Forge nutrition, weight-loss, food-effect, and body insight surface",
+                    parameters: [
+                        {
+                            name: "dateKey",
+                            in: "query",
+                            schema: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" }
+                        },
+                        {
+                            name: "dayStartAt",
+                            in: "query",
+                            schema: { type: "string", format: "date-time" }
+                        },
+                        {
+                            name: "dayEndAt",
+                            in: "query",
+                            schema: { type: "string", format: "date-time" }
+                        },
+                        {
+                            name: "timeZone",
+                            in: "query",
+                            schema: { type: "string" },
+                            description: "IANA timezone used for default local-day calculation when dateKey is omitted."
+                        }
+                    ],
                     responses: {
                         "200": jsonResponse({
                             type: "object",
@@ -5940,6 +5967,10 @@ export function buildOpenApiDocument() {
                                             type: "string",
                                             pattern: "^\\d{4}-\\d{2}-\\d{2}$"
                                         },
+                                        timeZone: {
+                                            type: "string",
+                                            description: "IANA timezone used to derive the local dayKey when dayKey is omitted."
+                                        },
                                         activeCaloriesKcal: {
                                             type: ["number", "null"],
                                             minimum: 0

package/dist/server/server/src/repositories/gamification.js

@@ -14,7 +14,32 @@ function mapCelebration(row) {
         seenAt: row.seen_at
     });
 }
+function dailyActivityKey(row) {
+    return `${row.dateKey}\0${row.timezone}`;
+}
+function dailyActivityRowsEqual(existingRows, nextRows) {
+    if (existingRows.length !== nextRows.length) {
+        return false;
+    }
+    const existingByKey = new Map(existingRows.map((row) => [dailyActivityKey(row), row]));
+    for (const next of nextRows) {
+        const existing = existingByKey.get(dailyActivityKey(next));
+        if (!existing ||
+            existing.userId !== next.userId ||
+            existing.qualifyingXp !== next.qualifyingXp ||
+            existing.eventCount !== next.eventCount ||
+            existing.firstRewardEventId !== next.firstRewardEventId ||
+            existing.lastRewardEventId !== next.lastRewardEventId) {
+            return false;
+        }
+    }
+    return true;
+}
 export function replaceGamificationDailyActivity(userId, rows) {
+    const existingRows = listGamificationDailyActivity(userId);
+    if (dailyActivityRowsEqual(existingRows, rows)) {
+        return;
+    }
     const database = getDatabase();
     const deleteRows = database.prepare(`DELETE FROM gamification_daily_activity WHERE user_id = ?`);
     const insertRow = database.prepare(`INSERT INTO gamification_daily_activity (

package/dist/server/server/src/repositories/tasks.js

@@ -3,8 +3,8 @@ import { getDatabase } from "../db.js";
 import { runInTransaction } from "../db.js";
 import { HttpError } from "../errors.js";
 import { recordActivityEvent } from "./activity-events.js";
-import { decorateOwnedEntity, inferFirstOwnedUserId, replaceEntityAssignees, setEntityOwner } from "./entity-ownership.js";
-import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
+import { decorateOwnedEntities, decorateOwnedEntity, inferFirstOwnedUserId, replaceEntityAssignees, setEntityOwner } from "./entity-ownership.js";
+import { filterDeletedEntities, filterDeletedIds, getDeletedEntityIdSet, isEntityDeleted } from "./deleted-entities.js";
 import { getGoalById } from "./goals.js";
 import { createLinkedNotes } from "./notes.js";
 import { ensureDefaultProjectForGoal, getProjectById } from "./projects.js";
@@ -13,7 +13,7 @@ import { awardTaskCompletionReward, reverseLatestTaskCompletionReward } from "./
 import { findUserByLabel, getDefaultUser, getUserById, resolveUserForMutation } from "./users.js";
 import { assertTaskRelations } from "../services/relations.js";
 import { computeWorkTime, emptyTaskTimeSummary } from "../services/work-time.js";
-import { buildTaskLifeForceFields, getTaskCompletionRequirement, upsertTaskActionProfile } from "../services/life-force.js";
+import { buildTasksLifeForceFields, buildTaskLifeForceFields, getTaskCompletionRequirement, upsertTaskActionProfile } from "../services/life-force.js";
 import { createWorkAdjustment } from "./work-adjustments.js";
 import { calendarSchedulingRulesSchema, createTaskSchema, taskSchema } from "../types.js";
 function readTaskTagIds(taskId) {
@@ -22,14 +22,32 @@ function readTaskTagIds(taskId) {
         .all(taskId);
     return filterDeletedIds("tag", rows.map((row) => row.tag_id));
 }
-function readWorkItemGitRefs(taskId) {
+function readTaskTagIdsIndex(taskIds) {
+    const index = new Map(taskIds.map((taskId) => [taskId, []]));
+    if (taskIds.length === 0) {
+        return index;
+    }
+    const placeholders = taskIds.map(() => "?").join(", ");
     const rows = getDatabase()
-        .prepare(`SELECT id, work_item_id, ref_type, provider, repository, ref_value, url, display_title, created_at, updated_at
-       FROM work_item_git_refs
-       WHERE work_item_id = ?
-       ORDER BY created_at DESC`)
-        .all(taskId);
-    return rows.map((row) => ({
+        .prepare(`SELECT task_id, tag_id
+       FROM task_tags
+       WHERE task_id IN (${placeholders})
+       ORDER BY task_id, tag_id`)
+        .all(...taskIds);
+    const deletedTagIds = getDeletedEntityIdSet("tag");
+    for (const row of rows) {
+        if (deletedTagIds.has(row.tag_id)) {
+            continue;
+        }
+        const tagIds = index.get(row.task_id);
+        if (tagIds) {
+            tagIds.push(row.tag_id);
+        }
+    }
+    return index;
+}
+function mapWorkItemGitRef(row) {
+    return {
         id: row.id,
         workItemId: row.work_item_id,
         refType: row.ref_type === "commit" ||
@@ -44,7 +62,36 @@ function readWorkItemGitRefs(taskId) {
         displayTitle: row.display_title,
         createdAt: row.created_at,
         updatedAt: row.updated_at
-    }));
+    };
+}
+function readWorkItemGitRefs(taskId) {
+    const rows = getDatabase()
+        .prepare(`SELECT id, work_item_id, ref_type, provider, repository, ref_value, url, display_title, created_at, updated_at
+       FROM work_item_git_refs
+       WHERE work_item_id = ?
+       ORDER BY created_at DESC`)
+        .all(taskId);
+    return rows.map(mapWorkItemGitRef);
+}
+function readWorkItemGitRefsIndex(taskIds) {
+    const index = new Map(taskIds.map((taskId) => [taskId, []]));
+    if (taskIds.length === 0) {
+        return index;
+    }
+    const placeholders = taskIds.map(() => "?").join(", ");
+    const rows = getDatabase()
+        .prepare(`SELECT id, work_item_id, ref_type, provider, repository, ref_value, url, display_title, created_at, updated_at
+       FROM work_item_git_refs
+       WHERE work_item_id IN (${placeholders})
+       ORDER BY work_item_id, created_at DESC`)
+        .all(...taskIds);
+    for (const row of rows) {
+        const refs = index.get(row.work_item_id);
+        if (refs) {
+            refs.push(mapWorkItemGitRef(row));
+        }
+    }
+    return index;
 }
 function replaceWorkItemGitRefs(taskId, refs) {
     if (refs === undefined) {
@@ -98,8 +145,8 @@ function assertWorkItemHierarchy(options) {
         throw new HttpError(409, "subtask_parent_invalid", "Subtasks can only live under tasks");
     }
 }
-function mapTask(row, time = emptyTaskTimeSummary()) {
-    const task = taskSchema.parse(decorateOwnedEntity("task", {
+function mapTaskBase(row, time, relations) {
+    return {
         id: row.id,
         title: row.title,
         description: row.description,
@@ -134,18 +181,24 @@ function mapTask(row, time = emptyTaskTimeSummary()) {
         completionReport: row.completion_report_json === null
             ? null
             : JSON.parse(row.completion_report_json),
-        gitRefs: readWorkItemGitRefs(row.id),
+        gitRefs: relations?.gitRefs ?? readWorkItemGitRefs(row.id),
         completedAt: row.completed_at,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
-        tagIds: readTaskTagIds(row.id),
+        tagIds: relations?.tagIds ?? readTaskTagIds(row.id),
         time
-    }));
+    };
+}
+function finalizeTask(taskInput) {
+    const task = taskSchema.parse(taskInput);
     return {
         ...task,
         ...buildTaskLifeForceFields(task, task.userId ?? undefined)
     };
 }
+function mapTask(row, time = emptyTaskTimeSummary()) {
+    return finalizeTask(decorateOwnedEntity("task", mapTaskBase(row, time)));
+}
 function replaceTaskTags(taskId, tagIds) {
     const database = getDatabase();
     database.prepare(`DELETE FROM task_tags WHERE task_id = ?`).run(taskId);
@@ -662,8 +715,20 @@ export function listTasks(filters = {}) {
          created_at
        ${limitSql}`)
         .all(...params);
+    const taskIds = rows.map((row) => row.id);
+    const tagIdsByTaskId = readTaskTagIdsIndex(taskIds);
+    const gitRefsByTaskId = readWorkItemGitRefsIndex(taskIds);
     const workTime = computeWorkTime();
-    return filterDeletedEntities("task", rows.map((row) => mapTask(row, workTime.taskSummaries.get(row.id) ?? emptyTaskTimeSummary())));
+    const tasks = decorateOwnedEntities("task", rows.map((row) => taskSchema.parse(mapTaskBase(row, workTime.taskSummaries.get(row.id) ?? emptyTaskTimeSummary(), {
+        tagIds: tagIdsByTaskId.get(row.id) ?? [],
+        gitRefs: gitRefsByTaskId.get(row.id) ?? []
+    }))));
+    const lifeForceFieldsByTaskId = buildTasksLifeForceFields(tasks);
+    return filterDeletedEntities("task", tasks.map((task) => ({
+        ...task,
+        ...(lifeForceFieldsByTaskId.get(task.id) ??
+            buildTaskLifeForceFields(task, task.userId ?? undefined))
+    })));
 }
 export function getTaskById(taskId) {
     if (isEntityDeleted("task", taskId)) {

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

@@ -116,9 +116,10 @@ function buildGoalSummary(tasks, goalId) {
     return { progress, totalTasks, completedTasks, earnedPoints, momentumLabel };
 }
 export function getDashboard(options = {}) {
-    const goals = filterOwnedEntities("goal", listGoals(), options.userIds);
-    const tasks = filterOwnedEntities("task", listTasks(), options.userIds);
-    const habits = filterOwnedEntities("habit", listHabits(), options.userIds);
+    const goals = options.goals ?? filterOwnedEntities("goal", listGoals(), options.userIds);
+    const tasks = options.tasks ?? filterOwnedEntities("task", listTasks(), options.userIds);
+    const habits = options.habits ??
+        filterOwnedEntities("habit", listHabits(), options.userIds);
     const tags = listTags();
     const now = new Date();
     const weekStart = startOfWeek(now).toISOString();
@@ -149,7 +150,7 @@ export function getDashboard(options = {}) {
             tags: listTagsByIds(goal.tagIds)
         };
     });
-    const projects = listProjectSummaries({ userIds: options.userIds });
+    const projects = options.projects ?? listProjectSummaries({ userIds: options.userIds });
     const suggestedTags = tags.filter((tag) => ["value", "execution"].includes(tag.kind)).slice(0, 6);
     const owners = [...new Set(tasks.map((task) => task.owner).filter(Boolean))].sort((left, right) => left.localeCompare(right));
     const executionBuckets = buildExecutionBuckets(tasks, todayIso, weekEndIso);

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

@@ -3,7 +3,7 @@ import { enqueueGamificationCelebration, getGamificationEquipment, insertGamific
 import { getDailyAmbientXp, listRewardRules, recordEntityCreationReward } from "../repositories/rewards.js";
 import { getDefaultUser, listUsers, listUsersByIds } from "../repositories/users.js";
 import { GAMIFICATION_CATALOG, GAMIFICATION_STREAK_AWAY_DAY_KEYS, GAMIFICATION_STREAK_POWER_DAY_KEYS } from "../../../src/lib/gamification-catalog.js";
-import { achievementSignalSchema, gamificationCatalogPayloadSchema, gamificationProfileSchema, milestoneRewardSchema, rewardLedgerEventSchema } from "../types.js";
+import { achievementSignalSchema, gamificationCatalogPayloadSchema, gamificationProfileSchema, milestoneRewardSchema } from "../types.js";
 const XP_CURVE_VERSION = "smith-forge";
 const ENTITY_CREATION_REWARD_SOURCES = [
     { entityType: "goal", tableName: "goals", titleColumn: "title" },
@@ -102,14 +102,24 @@ function resolveTimezone() {
         Intl.DateTimeFormat().resolvedOptions().timeZone ||
         "UTC");
 }
-function dateKeyInTimezone(value, timezone) {
-    const date = typeof value === "string" ? new Date(value) : value;
-    const parts = new Intl.DateTimeFormat("en-CA", {
+const dateKeyFormattersByTimezone = new Map();
+function getDateKeyFormatter(timezone) {
+    const existing = dateKeyFormattersByTimezone.get(timezone);
+    if (existing) {
+        return existing;
+    }
+    const formatter = new Intl.DateTimeFormat("en-CA", {
         timeZone: timezone,
         year: "numeric",
         month: "2-digit",
         day: "2-digit"
-    }).formatToParts(date);
+    });
+    dateKeyFormattersByTimezone.set(timezone, formatter);
+    return formatter;
+}
+function dateKeyInTimezone(value, timezone) {
+    const date = typeof value === "string" ? new Date(value) : value;
+    const parts = getDateKeyFormatter(timezone).formatToParts(date);
     const year = parts.find((part) => part.type === "year")?.value ?? "1970";
     const month = parts.find((part) => part.type === "month")?.value ?? "01";
     const day = parts.find((part) => part.type === "day")?.value ?? "01";
@@ -237,7 +247,7 @@ function loadScopedRewardEvents(scope) {
     const resolveOwner = buildOwnerResolver(defaultUserId);
     return rows
         .map((row) => {
-        const event = rewardLedgerEventSchema.parse({
+        const event = {
             id: row.id,
             ruleId: row.rule_id,
             eventLogId: row.event_log_id,
@@ -252,7 +262,7 @@ function loadScopedRewardEvents(scope) {
             reversedByRewardId: row.reversed_by_reward_id,
             metadata: parseMetadata(row.metadata_json),
             createdAt: row.created_at
-        });
+        };
         return {
             ...event,
             ownerUserId: resolveOwner(event),
@@ -272,15 +282,20 @@ function syncEntityCreationRewards(scope) {
     const scopeUserIds = [...new Set(scope.userIds)];
     const scopePlaceholders = scopeUserIds.map(() => "?").join(", ");
     for (const source of ENTITY_CREATION_REWARD_SOURCES) {
-        const scopedWhere = scopeUserIds.length > 0
-            ? `WHERE (
+        const scopedPredicate = scopeUserIds.length > 0
+            ? `AND (
              entity_owners.user_id IN (${scopePlaceholders})
              OR (entity_owners.user_id IS NULL AND ? IS NOT NULL)
            )`
             : "";
         const params = scopeUserIds.length > 0
-            ? [source.entityType, ...scopeUserIds, scopeUserIds[0] ?? null]
-            : [source.entityType];
+            ? [
+                source.entityType,
+                source.entityType,
+                ...scopeUserIds,
+                scopeUserIds[0] ?? null
+            ]
+            : [source.entityType, source.entityType];
         const rows = database
             .prepare(`SELECT
            ${source.tableName}.id AS id,
@@ -290,7 +305,10 @@ function syncEntityCreationRewards(scope) {
          LEFT JOIN entity_owners
            ON entity_owners.entity_type = ?
           AND entity_owners.entity_id = ${source.tableName}.id
-         ${scopedWhere}`)
+         LEFT JOIN reward_ledger existing_reward
+           ON existing_reward.reversible_group = ('entity_created:' || ? || ':' || ${source.tableName}.id)
+         WHERE existing_reward.id IS NULL
+         ${scopedPredicate}`)
             .all(...params);
         for (const row of rows) {
             recordEntityCreationReward({
@@ -732,17 +750,30 @@ function syncCatalog(input) {
         ? listGamificationUnlocks(userId).filter((unlock) => catalogItemIds.has(unlock.itemId))
         : [];
     const isInitialBackfill = existingUnlocks.length === 0;
+    const unlocksByItemId = new Map(existingUnlocks.map((unlock) => [unlock.itemId, unlock]));
+    const evaluationsByItemId = new Map(GAMIFICATION_CATALOG.map((item) => [item.id, evaluateCatalogItem(item, input.metricValues)]));
     for (const item of GAMIFICATION_CATALOG) {
-        const evaluation = evaluateCatalogItem(item, input.metricValues);
-        if (userId && evaluation.met) {
+        const evaluation = evaluationsByItemId.get(item.id);
+        if (userId && evaluation.met && !unlocksByItemId.has(item.id)) {
+            const celebrationSeenAt = isInitialBackfill ? nowIso : null;
             const inserted = insertGamificationUnlock({
                 userId,
                 itemId: item.id,
                 unlockedAt: nowIso,
                 sourceMetric: evaluation.sourceMetric,
                 sourceValue: evaluation.current,
-                celebrationSeenAt: isInitialBackfill ? nowIso : null
+                celebrationSeenAt
             });
+            if (inserted) {
+                unlocksByItemId.set(item.id, {
+                    userId,
+                    itemId: item.id,
+                    unlockedAt: nowIso,
+                    sourceMetric: evaluation.sourceMetric,
+                    sourceValue: evaluation.current,
+                    celebrationSeenAt
+                });
+            }
             if (inserted && !isInitialBackfill) {
                 enqueueGamificationCelebration({
                     id: `gce_${userId}_${item.id}`,
@@ -794,11 +825,8 @@ function syncCatalog(input) {
             createdAt: nowIso
         });
     }
-    const unlocksByItemId = new Map((userId ? listGamificationUnlocks(userId) : existingUnlocks)
-        .filter((unlock) => catalogItemIds.has(unlock.itemId))
-        .map((unlock) => [unlock.itemId, unlock]));
     const entries = GAMIFICATION_CATALOG.map((item) => {
-        const evaluation = evaluateCatalogItem(item, input.metricValues);
+        const evaluation = evaluationsByItemId.get(item.id);
         const unlock = unlocksByItemId.get(item.id);
         const readOnlyAggregateUnlock = !userId && evaluation.met;
         return {

package/dist/server/server/src/services/life-force.js

@@ -836,6 +836,19 @@ function readEntityActionProfileRow(entityType, entityId) {
        WHERE entity_type = ? AND entity_id = ?`)
         .get(entityType, entityId);
 }
+function readEntityActionProfileRowsIndex(entityType, entityIds) {
+    if (entityIds.length === 0) {
+        return new Map();
+    }
+    const placeholders = entityIds.map(() => "?").join(", ");
+    const rows = getDatabase()
+        .prepare(`SELECT id, entity_type, entity_id, profile_json, created_at, updated_at
+       FROM entity_action_profiles
+       WHERE entity_type = ?
+         AND entity_id IN (${placeholders})`)
+        .all(entityType, ...entityIds);
+    return new Map(rows.map((row) => [row.entity_id, row]));
+}
 export function readEntityActionProfile(entityType, entityId, fallback) {
     const row = readEntityActionProfileRow(entityType, entityId);
     return row ? mapEntityProfileRow(row, fallback) : null;
@@ -1239,6 +1252,9 @@ function getOrCreateDaySnapshot(userId, date) {
 }
 export function resolveTaskActionProfile(task, lifeForceProfile) {
     const row = readEntityActionProfileRow("task", task.id);
+    return resolveTaskActionProfileFromRow(task, lifeForceProfile, row);
+}
+function resolveTaskActionProfileFromRow(task, lifeForceProfile, row) {
     const baseProfile = !row
         ? buildDefaultTaskActionProfile({
             id: `profile_task_${task.id}`,
@@ -1354,6 +1370,33 @@ function readActiveTaskRunProjectionRows(taskId) {
          AND status = 'active'`)
         .all(taskId);
 }
+function readActiveTaskRunProjectionRowsIndex(taskIds) {
+    const index = new Map(taskIds.map((taskId) => [taskId, []]));
+    if (taskIds.length === 0) {
+        return index;
+    }
+    const placeholders = taskIds.map(() => "?").join(", ");
+    const rows = getDatabase()
+        .prepare(`SELECT
+         id,
+         task_id,
+         timer_mode,
+         planned_duration_seconds,
+         claimed_at,
+         lease_expires_at,
+         status
+       FROM task_runs
+       WHERE task_id IN (${placeholders})
+         AND status = 'active'`)
+        .all(...taskIds);
+    for (const row of rows) {
+        const taskRows = index.get(row.task_id);
+        if (taskRows) {
+            taskRows.push(row);
+        }
+    }
+    return index;
+}
 function computeProjectedRemainingSeconds(row, now) {
     if (row.timer_mode !== "planned" || row.planned_duration_seconds === null) {
         return 0;
@@ -2601,6 +2644,62 @@ export function buildTaskLifeForceFields(task, userId) {
         })
     };
 }
+export function buildTasksLifeForceFields(tasks) {
+    const fieldsByTaskId = new Map();
+    if (tasks.length === 0) {
+        return fieldsByTaskId;
+    }
+    const now = new Date();
+    const range = buildDayRange(now);
+    const taskIds = tasks.map((task) => task.id);
+    const defaultUserId = getDefaultUser().id;
+    const profileRowsByTaskId = readEntityActionProfileRowsIndex("task", taskIds);
+    const activeProjectionRowsByTaskId = readActiveTaskRunProjectionRowsIndex(taskIds);
+    const tasksByUserId = new Map();
+    for (const task of tasks) {
+        const effectiveUserId = task.userId ?? defaultUserId;
+        const userTasks = tasksByUserId.get(effectiveUserId) ?? [];
+        userTasks.push(task);
+        tasksByUserId.set(effectiveUserId, userTasks);
+    }
+    for (const [userId, userTasks] of tasksByUserId.entries()) {
+        const taskIdSet = new Set(userTasks.map((task) => task.id));
+        const lifeForceProfile = ensureLifeForceProfile(userId);
+        const todayRunSecondsByTaskId = new Map();
+        for (const row of readTaskRunRows(range, userId)) {
+            if (!taskIdSet.has(row.task_id)) {
+                continue;
+            }
+            todayRunSecondsByTaskId.set(row.task_id, (todayRunSecondsByTaskId.get(row.task_id) ?? 0) +
+                overlapSeconds(range, row, now));
+        }
+        const todayAdjustmentSecondsByTaskId = readTodayAdjustmentSecondsByTaskId(userId, range);
+        for (const task of userTasks) {
+            const profile = resolveTaskActionProfileFromRow(task, lifeForceProfile, profileRowsByTaskId.get(task.id));
+            const todayCreditedSeconds = (todayRunSecondsByTaskId.get(task.id) ?? 0) +
+                (todayAdjustmentSecondsByTaskId.get(task.id) ?? 0);
+            const spentTodayAp = (todayCreditedSeconds / 3600) * profile.sustainRateApPerHour;
+            const spentTotalAp = (task.time.totalCreditedSeconds / 3600) *
+                profile.sustainRateApPerHour;
+            const projectedTotalSeconds = task.time.totalCreditedSeconds +
+                (activeProjectionRowsByTaskId.get(task.id) ?? []).reduce((sum, row) => sum + computeProjectedRemainingSeconds(row, now), 0);
+            fieldsByTaskId.set(task.id, {
+                actionPointSummary: buildTaskActionPointSummary({
+                    plannedDurationSeconds: task.plannedDurationSeconds,
+                    totalCostAp: profile.totalCostAp,
+                    spentTodayAp,
+                    spentTotalAp
+                }),
+                splitSuggestion: buildTaskSplitSuggestion({
+                    plannedDurationSeconds: task.plannedDurationSeconds,
+                    totalTrackedSeconds: task.time.totalCreditedSeconds,
+                    projectedTotalSeconds
+                })
+            });
+        }
+    }
+    return fieldsByTaskId;
+}
 export function getTaskCompletionRequirement(task, userId) {
     const effectiveUserId = userId ?? task.userId ?? getDefaultUser().id;
     const runtime = buildTaskLifeForceRuntime(task, effectiveUserId);

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

@@ -300,6 +300,7 @@ export function revokeOperatorSession() {
 }
 export function getForgeSnapshot(userIds) {
     const search = new URLSearchParams();
+    search.set("profile", "shell");
     appendUserIds(search, coerceUserIds(userIds));
     const suffix = search.size > 0 ? `?${search.toString()}` : "";
     return request(`/api/v1/context${suffix}`).then(normalizeForgeSnapshot);
@@ -1771,6 +1772,9 @@ export function getWeightLossView(userIds, options) {
     if (options?.dayEndAt) {
         search.set("dayEndAt", options.dayEndAt);
     }
+    if (options?.timeZone) {
+        search.set("timeZone", options.timeZone);
+    }
     const suffix = search.size > 0 ? `?${search.toString()}` : "";
     return request(`/api/v1/health/weight-loss${suffix}`);
 }