forge-openclaw-plugin 0.2.47 → 0.2.49

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

@@ -11,8 +11,9 @@ import { recordActivityEvent } from "./activity-events.js";
 import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
 import { recordHabitCheckInReward, reverseLatestHabitCheckInReward } from "./rewards.js";
 import { createHabitCheckInSchema, createHabitSchema, habitCheckInSchema, habitSchema, updateHabitSchema } from "../types.js";
+import { formatLocalDateKey } from "../../../src/lib/date-keys.js";
 function todayKey(now = new Date()) {
-    return now.toISOString().slice(0, 10);
+    return formatLocalDateKey(now);
 }
 function parseWeekDays(raw) {
     const parsed = JSON.parse(raw);
@@ -87,25 +88,25 @@ function calculateStreak(habit, checkIns, now = new Date()) {
             statusByDate.set(checkIn.dateKey, checkIn.status);
         }
     }
-    const isScheduledOn = (date) => habit.frequency === "daily" || habit.weekDays.includes(date.getUTCDay());
-    const toDateKey = (date) => date.toISOString().slice(0, 10);
-    const atUtcDayStart = (date) => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    const isScheduledOn = (date) => habit.frequency === "daily" || habit.weekDays.includes(date.getDay());
+    const toDateKey = (date) => formatLocalDateKey(date);
+    const atLocalDayStart = (date) => new Date(date.getFullYear(), date.getMonth(), date.getDate());
     const previousScheduledDate = (date) => {
-        const cursor = atUtcDayStart(date);
+        const cursor = atLocalDayStart(date);
         do {
-            cursor.setUTCDate(cursor.getUTCDate() - 1);
+            cursor.setDate(cursor.getDate() - 1);
         } while (!isScheduledOn(cursor));
         return cursor;
     };
-    const startOfUtcWeek = (date) => {
-        const start = atUtcDayStart(date);
-        const offset = (start.getUTCDay() + 6) % 7;
-        start.setUTCDate(start.getUTCDate() - offset);
+    const startOfLocalWeek = (date) => {
+        const start = atLocalDayStart(date);
+        const offset = (start.getDay() + 6) % 7;
+        start.setDate(start.getDate() - offset);
         return start;
     };
-    const previousUtcWeek = (date) => {
-        const start = startOfUtcWeek(date);
-        start.setUTCDate(start.getUTCDate() - 7);
+    const previousLocalWeek = (date) => {
+        const start = startOfLocalWeek(date);
+        start.setDate(start.getDate() - 7);
         return start;
     };
     const alignedStatusOn = (date) => {
@@ -113,7 +114,7 @@ function calculateStreak(habit, checkIns, now = new Date()) {
         return status ? isAligned(habit, { status }) : false;
     };
     if (habit.frequency === "daily") {
-        const today = atUtcDayStart(now);
+        const today = atLocalDayStart(now);
         let cursor = isScheduledOn(today) && !statusByDate.has(toDateKey(today))
             ? previousScheduledDate(today)
             : today;
@@ -128,21 +129,21 @@ function calculateStreak(habit, checkIns, now = new Date()) {
         let count = 0;
         for (let offset = 0; offset < 7; offset += 1) {
             const day = new Date(weekStart);
-            day.setUTCDate(weekStart.getUTCDate() + offset);
+            day.setDate(weekStart.getDate() + offset);
             if (isScheduledOn(day) && alignedStatusOn(day)) {
                 count += 1;
             }
         }
         return count;
     };
-    const currentWeekStart = startOfUtcWeek(now);
+    const currentWeekStart = startOfLocalWeek(now);
     let cursor = alignedCountForWeek(currentWeekStart) >= habit.targetCount
         ? currentWeekStart
-        : previousUtcWeek(currentWeekStart);
+        : previousLocalWeek(currentWeekStart);
     let streak = 0;
     while (alignedCountForWeek(cursor) >= habit.targetCount) {
         streak += 1;
-        cursor = previousUtcWeek(cursor);
+        cursor = previousLocalWeek(cursor);
     }
     return streak;
 }
@@ -157,7 +158,7 @@ function isHabitDueToday(habit, latestCheckIn, now = new Date()) {
     if (habit.frequency === "daily") {
         return true;
     }
-    return habit.weekDays.includes(now.getUTCDay());
+    return habit.weekDays.includes(now.getDay());
 }
 function mapHabit(row, checkIns = listCheckInsForHabit(row.id)) {
     const latestCheckIn = checkIns[0] ?? null;
@@ -235,21 +236,28 @@ function sortHabits(habits, orderBy) {
     const nextHabits = [...habits];
     nextHabits.sort((left, right) => {
         if (orderBy === "name") {
-            return (left.title.localeCompare(right.title, undefined, { sensitivity: "base" }) ||
-                compareDateDesc(left.createdAt, right.createdAt));
+            return (left.title.localeCompare(right.title, undefined, {
+                sensitivity: "base"
+            }) || compareDateDesc(left.createdAt, right.createdAt));
         }
         if (orderBy === "streak") {
             return (right.streakCount - left.streakCount ||
                 Number(right.dueToday) - Number(left.dueToday) ||
-                left.title.localeCompare(right.title, undefined, { sensitivity: "base" }));
+                left.title.localeCompare(right.title, undefined, {
+                    sensitivity: "base"
+                }));
         }
         if (orderBy === "created_at") {
             return (compareDateDesc(left.createdAt, right.createdAt) ||
-                left.title.localeCompare(right.title, undefined, { sensitivity: "base" }));
+                left.title.localeCompare(right.title, undefined, {
+                    sensitivity: "base"
+                }));
         }
         if (orderBy === "updated_at") {
             return (compareDateDesc(left.updatedAt, right.updatedAt) ||
-                left.title.localeCompare(right.title, undefined, { sensitivity: "base" }));
+                left.title.localeCompare(right.title, undefined, {
+                    sensitivity: "base"
+                }));
         }
         return (Number(right.dueToday) - Number(left.dueToday) ||
             compareDateAsc(left.lastCheckInAt, right.lastCheckInAt) ||
@@ -367,6 +375,32 @@ export function updateHabit(habitId, input, activity) {
         return undefined;
     }
     const parsed = updateHabitSchema.parse(input);
+    const shouldApplyEntityPatch = parsed.title !== undefined ||
+        parsed.description !== undefined ||
+        parsed.status !== undefined ||
+        parsed.polarity !== undefined ||
+        parsed.frequency !== undefined ||
+        parsed.targetCount !== undefined ||
+        parsed.weekDays !== undefined ||
+        parsed.linkedGoalIds !== undefined ||
+        parsed.linkedProjectIds !== undefined ||
+        parsed.linkedTaskIds !== undefined ||
+        parsed.linkedValueIds !== undefined ||
+        parsed.linkedPatternIds !== undefined ||
+        parsed.linkedBehaviorIds !== undefined ||
+        parsed.linkedBeliefIds !== undefined ||
+        parsed.linkedModeIds !== undefined ||
+        parsed.linkedReportIds !== undefined ||
+        parsed.linkedBehaviorId !== undefined ||
+        parsed.rewardXp !== undefined ||
+        parsed.penaltyXp !== undefined ||
+        parsed.generatedHealthEventTemplate !== undefined ||
+        parsed.userId !== undefined;
+    if (!shouldApplyEntityPatch) {
+        return parsed.checkIn
+            ? createHabitCheckIn(habitId, parsed.checkIn, activity)
+            : current;
+    }
     const nextLinkedBehaviorIds = parsed.linkedBehaviorIds !== undefined ||
         parsed.linkedBehaviorId !== undefined
         ? normalizeLinkedBehaviorIds({
@@ -385,7 +419,7 @@ export function updateHabit(habitId, input, activity) {
     validateExistingIds(parsed.linkedBeliefIds ?? current.linkedBeliefIds, getBeliefEntryById, "belief_not_found", "Belief");
     validateExistingIds(parsed.linkedModeIds ?? current.linkedModeIds, getModeProfileById, "mode_not_found", "Mode");
     validateExistingIds(parsed.linkedReportIds ?? current.linkedReportIds, getTriggerReportById, "report_not_found", "Report");
-    return runInTransaction(() => {
+    const updatedHabit = runInTransaction(() => {
         const updatedAt = new Date().toISOString();
         getDatabase()
             .prepare(`UPDATE habits
@@ -419,6 +453,9 @@ export function updateHabit(habitId, input, activity) {
         }
         return habit;
     });
+    return parsed.checkIn
+        ? createHabitCheckIn(habitId, parsed.checkIn, activity) ?? updatedHabit
+        : updatedHabit;
 }
 export function deleteHabit(habitId, activity) {
     const current = getHabitById(habitId);

package/dist/server/server/src/repositories/model-settings.js

@@ -47,6 +47,11 @@ export function buildConnectionAgentIdentity(connection) {
         id: connection.agentId,
         label: connection.agentLabel,
         agentType: connection.provider,
+        identityKey: `model:${connection.id}`,
+        provider: null,
+        machineKey: null,
+        personaKey: connection.provider,
+        linkedUsers: [],
         trustLevel: "trusted",
         autonomyMode: "approval_required",
         approvalMode: "approval_by_default",

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

@@ -7,6 +7,7 @@ import { recordActivityEvent } from "./activity-events.js";
 import { recordEventLog } from "./event-log.js";
 import { resolveGoogleCalendarOauthPublicConfig } from "../services/google-calendar-oauth-config.js";
 import { buildConnectionAgentIdentity, FORGE_DEFAULT_AGENT_ID, listAiModelConnections, syncForgeManagedWikiProfile } from "./model-settings.js";
+import { listUsersByIds } from "./users.js";
 import { agentBootstrapPolicySchema, agentScopePolicySchema, createAgentTokenSchema, legacyAgentBootstrapPolicy, defaultAgentScopePolicy, agentIdentitySchema, customThemeSchema, settingsPayloadSchema, updateSettingsSchema } from "../types.js";
 const settingsFileSchema = settingsPayloadSchema.deepPartial();
 let settingsFileSyncDepth = 0;
@@ -303,11 +304,40 @@ function pickComparableOverrideSubset(source, template) {
     }
     return picked;
 }
-function mapAgent(row) {
+function listAgentIdentityUserLinks(agentIds) {
+    if (agentIds.length === 0) {
+        return new Map();
+    }
+    const placeholders = agentIds.map(() => "?").join(",");
+    const rows = getDatabase()
+        .prepare(`SELECT agent_id, user_id, role
+       FROM agent_identity_users
+       WHERE agent_id IN (${placeholders})
+       ORDER BY role = 'primary' DESC, created_at ASC`)
+        .all(...agentIds);
+    const usersById = new Map(listUsersByIds(rows.map((row) => row.user_id)).map((user) => [user.id, user]));
+    const linksByAgentId = new Map();
+    for (const row of rows) {
+        const current = linksByAgentId.get(row.agent_id) ?? [];
+        current.push({
+            userId: row.user_id,
+            role: row.role,
+            user: usersById.get(row.user_id) ?? null
+        });
+        linksByAgentId.set(row.agent_id, current);
+    }
+    return linksByAgentId;
+}
+function mapAgent(row, linkedUsers = []) {
     return agentIdentitySchema.parse({
         id: row.id,
         label: row.label,
         agentType: row.agent_type,
+        identityKey: row.identity_key,
+        provider: row.provider,
+        machineKey: row.machine_key,
+        personaKey: row.persona_key,
+        linkedUsers,
         trustLevel: row.trust_level,
         autonomyMode: row.autonomy_mode,
         approvalMode: row.approval_mode,
@@ -351,6 +381,10 @@ function findAgentIdentity(agentId) {
          agent_identities.id,
          agent_identities.label,
          agent_identities.agent_type,
+         agent_identities.identity_key,
+         agent_identities.provider,
+         agent_identities.machine_key,
+         agent_identities.persona_key,
          agent_identities.trust_level,
          agent_identities.autonomy_mode,
          agent_identities.approval_mode,
@@ -358,36 +392,76 @@ function findAgentIdentity(agentId) {
          agent_identities.created_at,
          agent_identities.updated_at,
          COUNT(agent_tokens.id) AS token_count,
-         COALESCE(SUM(CASE WHEN agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
+         COALESCE(SUM(CASE WHEN agent_tokens.id IS NOT NULL AND agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
        FROM agent_identities
        LEFT JOIN agent_tokens ON agent_tokens.agent_id = agent_identities.id
        WHERE agent_identities.id = ?
        GROUP BY agent_identities.id`)
         .get(agentId);
-    return row ? mapAgent(row) : undefined;
+    const links = row ? listAgentIdentityUserLinks([row.id]) : new Map();
+    return row ? mapAgent(row, links.get(row.id) ?? []) : undefined;
+}
+function normalizeAgentIdentityPart(value) {
+    return value
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._:]+/g, "_")
+        .replace(/^_+|_+$/g, "") || "";
+}
+function runtimeProviderFromAgentType(agentType) {
+    const normalized = normalizeAgentIdentityPart(agentType);
+    if (normalized === "openclaw" ||
+        normalized === "hermes" ||
+        normalized === "codex") {
+        return normalized;
+    }
+    return null;
+}
+function deriveTokenAgentIdentityFields(input) {
+    const provider = runtimeProviderFromAgentType(input.agentType);
+    if (!provider) {
+        return {
+            identityKey: null,
+            provider: null,
+            machineKey: null,
+            personaKey: null
+        };
+    }
+    return {
+        identityKey: `runtime:${provider}:token:default`,
+        provider,
+        machineKey: "token",
+        personaKey: "default"
+    };
 }
 function upsertAgentIdentity(input) {
     const now = new Date().toISOString();
+    const identityFields = deriveTokenAgentIdentityFields(input);
     const existing = getDatabase()
         .prepare(`SELECT id
        FROM agent_identities
-       WHERE lower(label) = lower(?)
+       WHERE (? IS NOT NULL AND identity_key = ?)
+          OR lower(label) = lower(?)
        LIMIT 1`)
-        .get(input.agentLabel);
+        .get(identityFields.identityKey, identityFields.identityKey, input.agentLabel);
     if (existing) {
         getDatabase()
             .prepare(`UPDATE agent_identities
-         SET agent_type = ?, trust_level = ?, autonomy_mode = ?, approval_mode = ?, description = ?, updated_at = ?
+         SET agent_type = ?, identity_key = COALESCE(identity_key, ?),
+             provider = COALESCE(provider, ?), machine_key = COALESCE(machine_key, ?),
+             persona_key = COALESCE(persona_key, ?), trust_level = ?,
+             autonomy_mode = ?, approval_mode = ?, description = ?, updated_at = ?
          WHERE id = ?`)
-            .run(input.agentType, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, existing.id);
+            .run(input.agentType, identityFields.identityKey, identityFields.provider, identityFields.machineKey, identityFields.personaKey, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, existing.id);
         return findAgentIdentity(existing.id);
     }
     const agentId = `agt_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
     getDatabase()
         .prepare(`INSERT INTO agent_identities (
-        id, label, agent_type, trust_level, autonomy_mode, approval_mode, description, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(agentId, input.agentLabel, input.agentType, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, now);
+        id, label, agent_type, identity_key, provider, machine_key, persona_key,
+        trust_level, autonomy_mode, approval_mode, description, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(agentId, input.agentLabel, input.agentType, identityFields.identityKey, identityFields.provider, identityFields.machineKey, identityFields.personaKey, input.trustLevel, input.autonomyMode, input.approvalMode, input.description, now, now);
     return findAgentIdentity(agentId);
 }
 function ensureSettingsRow(now = new Date().toISOString()) {
@@ -441,6 +515,10 @@ export function listAgentIdentities() {
          agent_identities.id,
          agent_identities.label,
          agent_identities.agent_type,
+         agent_identities.identity_key,
+         agent_identities.provider,
+         agent_identities.machine_key,
+         agent_identities.persona_key,
          agent_identities.trust_level,
          agent_identities.autonomy_mode,
          agent_identities.approval_mode,
@@ -448,19 +526,25 @@ export function listAgentIdentities() {
          agent_identities.created_at,
          agent_identities.updated_at,
          COUNT(agent_tokens.id) AS token_count,
-         COALESCE(SUM(CASE WHEN agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
+         COALESCE(SUM(CASE WHEN agent_tokens.id IS NOT NULL AND agent_tokens.revoked_at IS NULL THEN 1 ELSE 0 END), 0) AS active_token_count
        FROM agent_identities
        LEFT JOIN agent_tokens ON agent_tokens.agent_id = agent_identities.id
        GROUP BY agent_identities.id
        ORDER BY agent_identities.created_at DESC`)
         .all();
-    const manualAgents = rows.map(mapAgent);
+    const links = listAgentIdentityUserLinks(rows.map((row) => row.id));
+    const manualAgents = rows.map((row) => mapAgent(row, links.get(row.id) ?? []));
     const modelAgents = listAiModelConnections().map(buildConnectionAgentIdentity);
     const settings = readSettingsRow();
     const forgeAgent = agentIdentitySchema.parse({
         id: FORGE_DEFAULT_AGENT_ID,
         label: "Forge Agent",
         agentType: "forge_default",
+        identityKey: "forge:default",
+        provider: null,
+        machineKey: null,
+        personaKey: "default",
+        linkedUsers: [],
         trustLevel: "trusted",
         autonomyMode: "approval_required",
         approvalMode: "approval_by_default",
@@ -470,7 +554,11 @@ export function listAgentIdentities() {
         createdAt: settings.created_at,
         updatedAt: settings.updated_at
     });
-    return [forgeAgent, ...modelAgents, ...manualAgents];
+    const deduped = new Map();
+    for (const agent of [forgeAgent, ...modelAgents, ...manualAgents]) {
+        deduped.set(agent.identityKey ?? agent.id, agent);
+    }
+    return Array.from(deduped.values());
 }
 export function isPsycheAuthRequired() {
     ensureSettingsRow();

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

@@ -153,6 +153,29 @@ export function ensureSystemUsers() {
         }
     }
 }
+export function ensureBotUser(input) {
+    const parsed = createUserSchema.parse({
+        kind: "bot",
+        handle: normalizeHandle(input.handle),
+        displayName: input.displayName,
+        description: input.description,
+        accentColor: input.accentColor
+    });
+    const now = new Date().toISOString();
+    getDatabase()
+        .prepare(`INSERT INTO users (id, kind, handle, display_name, description, accent_color, created_at, updated_at)
+       VALUES (?, 'bot', ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         kind = 'bot',
+         handle = excluded.handle,
+         display_name = excluded.display_name,
+         description = excluded.description,
+         accent_color = excluded.accent_color,
+         updated_at = excluded.updated_at`)
+        .run(input.id, parsed.handle, parsed.displayName, parsed.description, parsed.accentColor, now, now);
+    ensurePermissiveGrantsForUser(input.id, now);
+    return getUserById(input.id);
+}
 function ensurePermissiveGrantsForUser(userId, now) {
     const existingUsers = listUsers();
     for (const otherUser of existingUsers) {

package/dist/server/server/src/types.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { LEGACY_WORKBENCH_PORT_KINDS, WORKBENCH_PORT_KINDS, normalizeWorkbenchPortKind } from "../../src/lib/workbench/nodes.js";
+import { formatLocalDateKey } from "../../src/lib/date-keys.js";
 export const taskStatusSchema = z.enum([
     "backlog",
     "focus",
@@ -2103,6 +2104,15 @@ export const agentIdentitySchema = z.object({
     id: z.string(),
     label: z.string(),
     agentType: z.string(),
+    identityKey: z.string().nullable().default(null),
+    provider: agentRuntimeProviderSchema.nullable().default(null),
+    machineKey: z.string().nullable().default(null),
+    personaKey: z.string().nullable().default(null),
+    linkedUsers: z.array(z.object({
+        userId: z.string(),
+        role: z.string(),
+        user: userSummarySchema.nullable().default(null)
+    })).default([]),
     trustLevel: agentTrustLevelSchema,
     autonomyMode: autonomyModeSchema,
     approvalMode: approvalModeSchema,
@@ -2187,6 +2197,10 @@ export const createAgentRuntimeSessionSchema = z.object({
     provider: agentRuntimeProviderSchema,
     agentLabel: nonEmptyTrimmedString,
     agentType: trimmedString.default("assistant"),
+    agentIdentityKey: trimmedString.optional(),
+    machineKey: trimmedString.optional(),
+    personaKey: trimmedString.optional(),
+    linkedUserIds: uniqueStringArraySchema.default([]),
     actorLabel: nonEmptyTrimmedString,
     sessionKey: nonEmptyTrimmedString,
     sessionLabel: trimmedString.default(""),
@@ -3120,6 +3134,12 @@ export const taskMutationShape = {
     notes: z.array(nestedCreateNoteSchema).default([])
 };
 export const createTaskSchema = z.object(taskMutationShape);
+const habitCheckInWriteSchema = z.object({
+    dateKey: dateOnlySchema.default(() => formatLocalDateKey()),
+    status: habitCheckInStatusSchema,
+    note: trimmedString.default(""),
+    description: trimmedString.optional()
+});
 const habitMutationShape = {
     title: nonEmptyTrimmedString,
     description: trimmedString.default(""),
@@ -3206,6 +3226,7 @@ export const updateHabitSchema = z
     linkedBehaviorId: nonEmptyTrimmedString.nullable().optional(),
     rewardXp: z.number().int().min(1).max(100).optional(),
     penaltyXp: z.number().int().min(1).max(100).optional(),
+    checkIn: habitCheckInWriteSchema.optional(),
     generatedHealthEventTemplate: z
         .object({
         enabled: z.boolean().optional(),
@@ -3371,12 +3392,7 @@ export const taskRunFinishSchema = z.object({
 export const taskRunFocusSchema = z.object({
     actor: nonEmptyTrimmedString.optional()
 });
-export const createHabitCheckInSchema = z.object({
-    dateKey: dateOnlySchema.default(new Date().toISOString().slice(0, 10)),
-    status: habitCheckInStatusSchema,
-    note: trimmedString.default(""),
-    description: trimmedString.optional()
-});
+export const createHabitCheckInSchema = habitCheckInWriteSchema;
 export const updateSettingsSchema = z.object({
     profile: z
         .object({

package/dist/server/server/src/watch-mobile.js

@@ -5,6 +5,7 @@ import { HttpError } from "./errors.js";
 import { updateWorkoutMetadata } from "./health.js";
 import { canonicalizeMovementCategoryTags, listMovementPlaces, normalizeMovementCategoryTag, updateMovementPlace } from "./movement.js";
 import { listHabits } from "./repositories/habits.js";
+import { formatLocalDateKey } from "../../src/lib/date-keys.js";
 const watchCapability = "watch-ready";
 const watchHistoryStateSchema = z.enum(["aligned", "unaligned", "unknown"]);
 const watchPromptKindSchema = z.enum([
@@ -56,7 +57,11 @@ export const mobileWatchHabitCheckInSchema = z.object({
     sessionId: z.string().trim().min(1),
     pairingToken: z.string().trim().min(1),
     dedupeKey: z.string().trim().min(1),
-    dateKey: z.string().trim().min(1).default(new Date().toISOString().slice(0, 10)),
+    dateKey: z
+        .string()
+        .trim()
+        .min(1)
+        .default(() => formatLocalDateKey()),
     status: z.enum(["done", "missed"]),
     note: z.string().trim().default(""),
     description: z.string().trim().optional()
@@ -82,24 +87,24 @@ function nowIso() {
     return new Date().toISOString();
 }
 function formatDateKey(date) {
-    return date.toISOString().slice(0, 10);
+    return formatLocalDateKey(date);
 }
 function parseDateKey(dateKey) {
     const [year, month, day] = dateKey.split("-").map(Number);
-    return new Date(Date.UTC(year, month - 1, day));
+    return new Date(year, month - 1, day);
 }
-function startOfUtcDay(date) {
-    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+function startOfLocalDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
 }
-function addUtcDays(date, days) {
+function addLocalDays(date, days) {
     const next = new Date(date);
-    next.setUTCDate(next.getUTCDate() + days);
+    next.setDate(next.getDate() + days);
     return next;
 }
-function startOfUtcWeek(date) {
-    const start = startOfUtcDay(date);
-    const offset = (start.getUTCDay() + 6) % 7;
-    start.setUTCDate(start.getUTCDate() - offset);
+function startOfLocalWeek(date) {
+    const start = startOfLocalDay(date);
+    const offset = (start.getDay() + 6) % 7;
+    start.setDate(start.getDate() - offset);
     return start;
 }
 function isAlignedCheckIn(habit, status) {
@@ -125,15 +130,15 @@ function buildHabitHistory(habit, options) {
         ? parseDateKey(options.anchorDateKey)
         : new Date();
     if (habit.frequency === "daily") {
-        const today = startOfUtcDay(now);
+        const today = startOfLocalDay(now);
         return Array.from({ length: 7 }, (_, index) => {
             const offset = index - 6;
-            const date = addUtcDays(today, offset);
+            const date = addLocalDays(today, offset);
             const dateKey = formatDateKey(date);
             const checkIn = habit.checkIns.find((entry) => entry.dateKey === dateKey) ?? null;
             return {
                 id: dateKey,
-                label: ["S", "M", "T", "W", "T", "F", "S"][date.getUTCDay()],
+                label: ["S", "M", "T", "W", "T", "F", "S"][date.getDay()],
                 periodKey: dateKey,
                 current: offset === 0,
                 state: checkIn
@@ -144,13 +149,13 @@ function buildHabitHistory(habit, options) {
             };
         });
     }
-    const thisWeek = startOfUtcWeek(now);
+    const thisWeek = startOfLocalWeek(now);
     return Array.from({ length: 7 }, (_, index) => {
         const offset = index - 6;
-        const weekStart = addUtcDays(thisWeek, offset * 7);
+        const weekStart = addLocalDays(thisWeek, offset * 7);
         const weekKey = formatDateKey(weekStart);
         const weekEntries = habit.checkIns.filter((entry) => {
-            const entryWeek = formatDateKey(startOfUtcWeek(parseDateKey(entry.dateKey)));
+            const entryWeek = formatDateKey(startOfLocalWeek(parseDateKey(entry.dateKey)));
             return entryWeek === weekKey;
         });
         const alignedCount = weekEntries.filter((entry) => isAlignedCheckIn(habit, entry.status)).length;
@@ -375,7 +380,9 @@ function projectionForStoredEvent(event) {
         const categoryCandidate = Array.isArray(event.payload.categoryTags)
             ? event.payload.categoryTags
             : typeof event.payload.category === "string"
-                ? watchCategoryMap.get(event.payload.category) ?? [event.payload.category]
+                ? (watchCategoryMap.get(event.payload.category) ?? [
+                    event.payload.category
+                ])
                 : [];
         const categoryTags = canonicalizeMovementCategoryTags(categoryCandidate.flatMap((value) => typeof value === "string" ? [normalizeMovementCategoryTag(value)] : []));
         try {
@@ -403,12 +410,15 @@ function projectionForStoredEvent(event) {
                 status: "projection_failed",
                 details: {
                     reason: "place_update_failed",
-                    message: error instanceof Error ? error.message : "Unknown place update error"
+                    message: error instanceof Error
+                        ? error.message
+                        : "Unknown place update error"
                 }
             };
         }
     }
-    if (event.eventType === "workout_annotation" && event.linkedContext.workoutId) {
+    if (event.eventType === "workout_annotation" &&
+        event.linkedContext.workoutId) {
         try {
             const workout = updateWorkoutMetadata(event.linkedContext.workoutId, {
                 subjectiveEffort: typeof event.payload.subjectiveEffort === "number"
@@ -449,7 +459,9 @@ function projectionForStoredEvent(event) {
                 status: "projection_failed",
                 details: {
                     reason: "workout_update_failed",
-                    message: error instanceof Error ? error.message : "Unknown workout update error"
+                    message: error instanceof Error
+                        ? error.message
+                        : "Unknown workout update error"
                 }
             };
         }

package/dist/server/src/lib/date-keys.js

@@ -0,0 +1,21 @@
+function readPart(parts, type) {
+    return parts.find((part) => part.type === type)?.value ?? "";
+}
+export function getRuntimeTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+export function formatDateKeyInTimeZone(date, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+    }).formatToParts(date);
+    const year = readPart(parts, "year");
+    const month = readPart(parts, "month");
+    const day = readPart(parts, "day");
+    return `${year}-${month}-${day}`;
+}
+export function formatLocalDateKey(date = new Date()) {
+    return formatDateKeyInTimeZone(date, getRuntimeTimeZone());
+}

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