forge-openclaw-plugin 0.2.15 → 0.2.18

package/dist/server/repositories/rewards.js

@@ -43,6 +43,22 @@ const DEFAULT_RULES = [
         description: "Reward a concrete decision to apply a useful insight.",
         config: { fixedXp: 15 }
     },
+    {
+        id: "reward_rule_habit_aligned",
+        family: "consistency",
+        code: "habit_aligned",
+        title: "Habit alignment",
+        description: "Award XP when a habit outcome matches the intended direction.",
+        config: { award: "habit.rewardXp" }
+    },
+    {
+        id: "reward_rule_habit_misaligned",
+        family: "recovery",
+        code: "habit_misaligned",
+        title: "Habit miss",
+        description: "Apply a small XP penalty when a habit outcome moves against the intended direction.",
+        config: { penalty: "habit.penaltyXp" }
+    },
     {
         id: "reward_rule_psyche_reflection_capture",
         family: "alignment",
@@ -633,6 +649,52 @@ export function recordSessionEvent(input, activity, now = new Date()) {
     }, now);
     return { sessionEvent, rewardEvent };
 }
+export function recordHabitCheckInReward(habit, status, dateKey, activity) {
+    ensureDefaultRewardRules();
+    const aligned = (habit.polarity === "positive" && status === "done") ||
+        (habit.polarity === "negative" && status === "missed");
+    const rule = getRuleByCode(aligned ? "habit_aligned" : "habit_misaligned");
+    const deltaXp = aligned ? habit.rewardXp : -Math.abs(habit.penaltyXp);
+    const actionLabel = habit.polarity === "positive"
+        ? status === "done"
+            ? "completed"
+            : "missed"
+        : status === "done"
+            ? "performed"
+            : "resisted";
+    const eventLog = recordEventLog({
+        eventKind: aligned ? "reward.habit_aligned" : "reward.habit_misaligned",
+        entityType: "habit",
+        entityId: habit.id,
+        actor: activity.actor ?? null,
+        source: activity.source,
+        metadata: {
+            habitId: habit.id,
+            status,
+            polarity: habit.polarity,
+            dateKey,
+            deltaXp
+        }
+    });
+    return insertLedgerEvent({
+        ruleId: rule?.id ?? null,
+        eventLogId: eventLog.id,
+        entityType: "habit",
+        entityId: habit.id,
+        actor: activity.actor ?? null,
+        source: activity.source,
+        deltaXp,
+        reasonTitle: aligned ? `${habit.title} aligned` : `${habit.title} slipped`,
+        reasonSummary: `Habit ${actionLabel} on ${dateKey}.`,
+        reversibleGroup: `habit:${habit.id}:${dateKey}`,
+        metadata: {
+            habitId: habit.id,
+            status,
+            polarity: habit.polarity,
+            dateKey
+        }
+    });
+}
 export function listSessionEvents(limit = 50) {
     const rows = getDatabase()
         .prepare(`SELECT id, session_id, event_type, actor, source, metrics_json, created_at

package/dist/server/services/context.js

@@ -1,5 +1,7 @@
 import { listActivityEvents } from "../repositories/activity-events.js";
 import { listGoals } from "../repositories/goals.js";
+import { listHabits } from "../repositories/habits.js";
+import { listRewardLedger } from "../repositories/rewards.js";
 import { listTags, listTagsByIds } from "../repositories/tags.js";
 import { listTasks } from "../repositories/tasks.js";
 import { getDashboard } from "./dashboard.js";
@@ -109,6 +111,7 @@ export function getOverviewContext(now = new Date()) {
     const dashboard = getDashboard();
     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);
     return overviewContextSchema.parse({
         generatedAt: now.toISOString(),
         strategicHeader: {
@@ -124,8 +127,9 @@ export function getOverviewContext(now = new Date()) {
         projects: dashboard.projects.slice(0, 5),
         activeGoals: dashboard.goals.filter((goal) => goal.status === "active").slice(0, 6),
         topTasks: sortStrategicTasks(dashboard.tasks.filter((task) => task.status !== "done")).slice(0, 6),
+        dueHabits,
         recentEvidence: listActivityEvents({ limit: 12 }),
-        achievements: buildAchievementSignals(listGoals(), listTasks(), now),
+        achievements: buildAchievementSignals(listGoals(), listTasks(), listHabits(), now),
         domainBalance: buildDomainBalance(listGoals(), listTasks()),
         neglectedGoals: buildNeglectedGoals(listGoals(), listTasks(), now)
     });
@@ -133,10 +137,12 @@ export function getOverviewContext(now = new Date()) {
 export function getTodayContext(now = new Date()) {
     const goals = listGoals();
     const tasks = listTasks();
-    const gamification = buildGamificationProfile(goals, tasks, now);
+    const habits = listHabits();
+    const gamification = buildGamificationProfile(goals, tasks, habits, now);
     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);
+    const dueHabits = habits.filter((habit) => habit.dueToday).slice(0, 6);
     const completedTasks = [...tasks]
         .filter((task) => task.status === "done" && task.completedAt !== null)
         .sort((left, right) => Date.parse(right.completedAt ?? "") - Date.parse(left.completedAt ?? ""))
@@ -185,13 +191,17 @@ export function getTodayContext(now = new Date()) {
                 completed: false
             }
         ],
-        milestoneRewards: buildMilestoneRewards(goals, tasks, now),
+        dueHabits,
+        milestoneRewards: buildMilestoneRewards(goals, tasks, habits, now),
+        recentHabitRewards: listRewardLedger({ entityType: "habit", limit: 8 }),
         momentum: {
             streakDays: gamification.streakDays,
             momentumScore: gamification.momentumScore,
-            recoveryHint: overdueCount > 0
-                ? `Clear ${overdueCount} overdue task${overdueCount === 1 ? "" : "s"} to keep momentum from decaying.`
-                : "No overdue drag right now. Preserve the rhythm with one decisive completion."
+            recoveryHint: dueHabits.length > 0
+                ? `${dueHabits.length} habit${dueHabits.length === 1 ? "" : "s"} still need a check-in today. Closing one will keep momentum honest.`
+                : overdueCount > 0
+                    ? `Clear ${overdueCount} overdue task${overdueCount === 1 ? "" : "s"} to keep momentum from decaying.`
+                    : "No overdue drag right now. Preserve the rhythm with one decisive completion."
         }
     });
 }

package/dist/server/services/dashboard.js

@@ -1,5 +1,6 @@
 import { listGoals } from "../repositories/goals.js";
 import { listActivityEvents } from "../repositories/activity-events.js";
+import { listHabits } from "../repositories/habits.js";
 import { buildNotesSummaryByEntity } from "../repositories/notes.js";
 import { listTagsByIds, listTags } from "../repositories/tags.js";
 import { listTasks } from "../repositories/tasks.js";
@@ -116,6 +117,7 @@ function buildGoalSummary(tasks, goalId) {
 export function getDashboard() {
     const goals = listGoals();
     const tasks = listTasks();
+    const habits = listHabits();
     const tags = listTags();
     const now = new Date();
     const weekStart = startOfWeek(now).toISOString();
@@ -150,9 +152,9 @@ export function getDashboard() {
     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);
-    const gamification = buildGamificationProfile(goals, tasks, now);
-    const achievements = buildAchievementSignals(goals, tasks, now);
-    const milestoneRewards = buildMilestoneRewards(goals, tasks, now);
+    const gamification = buildGamificationProfile(goals, tasks, habits, now);
+    const achievements = buildAchievementSignals(goals, tasks, habits, now);
+    const milestoneRewards = buildMilestoneRewards(goals, tasks, habits, now);
     const recentActivity = listActivityEvents({ limit: 12 });
     const notesSummaryByEntity = buildNotesSummaryByEntity();
     return dashboardPayloadSchema.parse({
@@ -160,6 +162,7 @@ export function getDashboard() {
         goals: goalCards,
         projects,
         tasks,
+        habits,
         tags,
         suggestedTags,
         owners,

package/dist/server/services/entity-crud.js

@@ -4,11 +4,12 @@ import { createNote, deleteNote, getNoteById, listNotes, unlinkNotesForEntity, u
 import { createBehaviorPatternSchema, createBehaviorSchema, createBeliefEntrySchema, createEmotionDefinitionSchema, createEventTypeSchema, createModeGuideSessionSchema, createModeProfileSchema, createPsycheValueSchema, createTriggerReportSchema, updateBehaviorPatternSchema, updateBehaviorSchema, updateBeliefEntrySchema, updateEmotionDefinitionSchema, updateEventTypeSchema, updateModeGuideSessionSchema, updateModeProfileSchema, updatePsycheValueSchema, updateTriggerReportSchema } from "../psyche-types.js";
 import { buildSettingsBinPayload, cascadeSoftDeleteAnchoredCollaboration, clearDeletedEntityRecord, getDeletedEntityRecord, listDeletedEntities, restoreAnchoredCollaboration, restoreDeletedEntityRecord, upsertDeletedEntityRecord } from "../repositories/deleted-entities.js";
 import { createGoal, deleteGoal, getGoalById, listGoals, updateGoal } from "../repositories/goals.js";
+import { createHabit, deleteHabit, getHabitById, listHabits, updateHabit } from "../repositories/habits.js";
 import { createBehavior, createBehaviorPattern, createBeliefEntry, createEmotionDefinition, createEventType, createModeGuideSession, createModeProfile, createPsycheValue, createTriggerReport, deleteBehavior, deleteBehaviorPattern, deleteBeliefEntry, deleteEmotionDefinition, deleteEventType, deleteModeGuideSession, deleteModeProfile, deletePsycheValue, deleteTriggerReport, getBehaviorById, getBehaviorPatternById, getBeliefEntryById, getEmotionDefinitionById, getEventTypeById, getModeGuideSessionById, getModeProfileById, getPsycheValueById, getTriggerReportById, listBehaviors, listBehaviorPatterns, listBeliefEntries, listEmotionDefinitions, listEventTypes, listModeGuideSessions, listModeProfiles, listPsycheValues, listTriggerReports, updateBehavior, updateBehaviorPattern, updateBeliefEntry, updateEmotionDefinition, updateEventType, updateModeGuideSession, updateModeProfile, updatePsycheValue, updateTriggerReport } from "../repositories/psyche.js";
 import { createProject, deleteProject, getProjectById, listProjects, updateProject } from "../repositories/projects.js";
 import { createTag, deleteTag, getTagById, listTags, updateTag } from "../repositories/tags.js";
 import { createTask, deleteTask, getTaskById, listTasks, updateTask } from "../repositories/tasks.js";
-import { createGoalSchema, createInsightSchema, createNoteSchema, createProjectSchema, createTagSchema, createTaskSchema, updateGoalSchema, updateInsightSchema, updateNoteSchema, updateProjectSchema, updateTagSchema, updateTaskSchema } from "../types.js";
+import { createGoalSchema, createHabitSchema, createInsightSchema, createNoteSchema, createProjectSchema, createTagSchema, createTaskSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateNoteSchema, updateProjectSchema, updateTagSchema, updateTaskSchema } from "../types.js";
 class AtomicBatchRollback extends Error {
     index;
     code;
@@ -49,6 +50,15 @@ const CRUD_ENTITY_CAPABILITIES = {
         update: (id, patch, context) => updateTask(id, patch, context),
         hardDelete: (id, context) => deleteTask(id, context)
     },
+    habit: {
+        entityType: "habit",
+        routeBase: "/api/v1/habits",
+        list: () => listHabits(),
+        get: (id) => getHabitById(id),
+        create: (data, context) => createHabit(data, context),
+        update: (id, patch, context) => updateHabit(id, patch, context),
+        hardDelete: (id, context) => deleteHabit(id, context)
+    },
     tag: {
         entityType: "tag",
         routeBase: "/api/v1/tags",
@@ -174,6 +184,7 @@ const CREATE_ENTITY_SCHEMAS = {
     goal: createGoalSchema,
     project: createProjectSchema,
     task: createTaskSchema,
+    habit: createHabitSchema,
     tag: createTagSchema,
     note: createNoteSchema,
     insight: createInsightSchema,
@@ -191,6 +202,7 @@ const UPDATE_ENTITY_SCHEMAS = {
     goal: updateGoalSchema,
     project: updateProjectSchema,
     task: updateTaskSchema,
+    habit: updateHabitSchema,
     tag: updateTagSchema,
     note: updateNoteSchema,
     insight: updateInsightSchema,
@@ -312,6 +324,16 @@ function matchesLinkedTo(entityType, entity, linkedTo) {
             return linkedTo.entityType === "goal" && entity.goalId === linkedTo.id;
         case "task":
             return (linkedTo.entityType === "goal" && entity.goalId === linkedTo.id) || (linkedTo.entityType === "project" && entity.projectId === linkedTo.id);
+        case "habit":
+            return ((linkedTo.entityType === "goal" && Array.isArray(entity.linkedGoalIds) && entity.linkedGoalIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "project" && Array.isArray(entity.linkedProjectIds) && entity.linkedProjectIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "task" && Array.isArray(entity.linkedTaskIds) && entity.linkedTaskIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "psyche_value" && Array.isArray(entity.linkedValueIds) && entity.linkedValueIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "behavior_pattern" && Array.isArray(entity.linkedPatternIds) && entity.linkedPatternIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "behavior" && Array.isArray(entity.linkedBehaviorIds) && entity.linkedBehaviorIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "belief_entry" && Array.isArray(entity.linkedBeliefIds) && entity.linkedBeliefIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "mode_profile" && Array.isArray(entity.linkedModeIds) && entity.linkedModeIds.includes(linkedTo.id)) ||
+                (linkedTo.entityType === "trigger_report" && Array.isArray(entity.linkedReportIds) && entity.linkedReportIds.includes(linkedTo.id)));
         case "note":
             return (Array.isArray(entity.links) &&
                 entity.links.some((link) => typeof link === "object" &&

package/dist/server/services/gamification.js

@@ -12,9 +12,15 @@ function startOfWeek(date) {
 function dayKey(isoDate) {
     return isoDate.slice(0, 10);
 }
-function calculateStreak(tasks, now) {
-    const completedDays = new Set(tasks
-        .flatMap((task) => (task.status === "done" && task.completedAt !== null ? [dayKey(task.completedAt)] : [])));
+function isAlignedHabitCheckIn(habit, checkIn) {
+    return (habit.polarity === "positive" && checkIn.status === "done") || (habit.polarity === "negative" && checkIn.status === "missed");
+}
+function calculateStreak(tasks, habits, now) {
+    const completedDays = new Set([
+        ...tasks
+            .flatMap((task) => (task.status === "done" && task.completedAt !== null ? [dayKey(task.completedAt)] : [])),
+        ...habits.flatMap((habit) => habit.checkIns.filter((checkIn) => isAlignedHabitCheckIn(habit, checkIn)).map((checkIn) => checkIn.dateKey))
+    ]);
     if (completedDays.size === 0) {
         return 0;
     }
@@ -41,17 +47,27 @@ function latestCompletionForTasks(tasks) {
         .flatMap((task) => (task.completedAt ? [task.completedAt] : []))
         .sort((left, right) => Date.parse(right) - Date.parse(left))[0] ?? null;
 }
-export function buildGamificationProfile(goals, tasks, now = new Date()) {
+function latestAlignedHabitAt(habits) {
+    return habits
+        .flatMap((habit) => habit.checkIns
+        .filter((checkIn) => isAlignedHabitCheckIn(habit, checkIn))
+        .map((checkIn) => checkIn.createdAt))
+        .sort((left, right) => Date.parse(right) - Date.parse(left))[0] ?? null;
+}
+export function buildGamificationProfile(goals, tasks, habits, now = new Date()) {
     const weekStart = startOfWeek(now).toISOString();
     const doneTasks = tasks.filter((task) => task.status === "done");
     const totalXp = getTotalXp();
     const weeklyXp = getWeeklyXp(weekStart);
     const focusTasks = tasks.filter((task) => task.status === "focus" || task.status === "in_progress").length;
     const overdueTasks = tasks.filter((task) => task.status !== "done" && task.dueDate !== null && task.dueDate < now.toISOString().slice(0, 10)).length;
+    const dueHabits = habits.filter((habit) => habit.dueToday).length;
+    const alignedHabitCheckIns = habits.flatMap((habit) => habit.checkIns.filter((checkIn) => isAlignedHabitCheckIn(habit, checkIn)));
+    const habitMomentum = habits.reduce((sum, habit) => sum + habit.streakCount * 3 + (habit.dueToday ? -4 : 2), 0);
     const alignedDonePoints = doneTasks
         .filter((task) => task.goalId !== null && task.tagIds.length > 0)
         .reduce((sum, task) => sum + task.points, 0);
-    const streakDays = calculateStreak(tasks, now);
+    const streakDays = calculateStreak(tasks, habits, now);
     const levelState = calculateLevel(totalXp);
     const goalScores = goals
         .map((goal) => ({
@@ -69,17 +85,20 @@ export function buildGamificationProfile(goals, tasks, now = new Date()) {
         weeklyXp,
         streakDays,
         comboMultiplier: Number((1 + Math.min(0.75, streakDays * 0.05)).toFixed(2)),
-        momentumScore: Math.max(0, Math.min(100, Math.round(weeklyXp / 6 + alignedDonePoints / 20 + focusTasks * 5 - overdueTasks * 9))),
+        momentumScore: Math.max(0, Math.min(100, Math.round(weeklyXp / 6 + alignedDonePoints / 20 + focusTasks * 5 + alignedHabitCheckIns.length * 4 + habitMomentum - overdueTasks * 9 - dueHabits * 3))),
         topGoalId: topGoal?.goalId ?? null,
         topGoalTitle: topGoal?.goalTitle ?? null
     });
 }
-export function buildAchievementSignals(goals, tasks, now = new Date()) {
-    const profile = buildGamificationProfile(goals, tasks, now);
+export function buildAchievementSignals(goals, tasks, habits, now = new Date()) {
+    const profile = buildGamificationProfile(goals, tasks, habits, now);
     const doneTasks = tasks.filter((task) => task.status === "done");
     const alignedDoneTasks = doneTasks.filter((task) => task.goalId !== null && task.tagIds.length > 0);
     const focusTasks = tasks.filter((task) => task.status === "focus" || task.status === "in_progress");
     const highValueGoals = goals.filter((goal) => doneTasks.some((task) => task.goalId === goal.id));
+    const alignedHabitCount = habits.reduce((sum, habit) => sum + habit.checkIns.filter((checkIn) => isAlignedHabitCheckIn(habit, checkIn)).length, 0);
+    const topHabitStreak = Math.max(0, ...habits.map((habit) => habit.streakCount));
+    const latestHabitWin = latestAlignedHabitAt(habits);
     return [
         {
             id: "streak-operator",
@@ -125,15 +144,34 @@ export function buildAchievementSignals(goals, tasks, now = new Date()) {
             progressLabel: `${Math.min(focusTasks.length, 1)}/1 live directives`,
             unlocked: focusTasks.length > 0,
             unlockedAt: focusTasks.length > 0 ? now.toISOString() : null
+        },
+        {
+            id: "habit-keeper",
+            title: "Habit Keeper",
+            summary: "Turn recurring behavior into visible operating evidence.",
+            tier: alignedHabitCount >= 12 ? "gold" : alignedHabitCount >= 6 ? "silver" : "bronze",
+            progressLabel: `${Math.min(alignedHabitCount, 12)}/12 aligned habit wins`,
+            unlocked: alignedHabitCount >= 12,
+            unlockedAt: alignedHabitCount >= 12 ? latestHabitWin : null
+        },
+        {
+            id: "ritual-pressure",
+            title: "Ritual Pressure",
+            summary: "Keep one habit alive long enough that it changes the texture of the week.",
+            tier: topHabitStreak >= 10 ? "gold" : "silver",
+            progressLabel: `${Math.min(topHabitStreak, 10)}/10 habit streak`,
+            unlocked: topHabitStreak >= 10,
+            unlockedAt: topHabitStreak >= 10 ? latestHabitWin : null
         }
     ].map((achievement) => achievementSignalSchema.parse(achievement));
 }
-export function buildMilestoneRewards(goals, tasks, now = new Date()) {
-    const profile = buildGamificationProfile(goals, tasks, now);
+export function buildMilestoneRewards(goals, tasks, habits, now = new Date()) {
+    const profile = buildGamificationProfile(goals, tasks, habits, now);
     const doneTasks = tasks.filter((task) => task.status === "done");
     const topGoal = profile.topGoalId ? goals.find((goal) => goal.id === profile.topGoalId) ?? null : null;
     const topGoalXp = topGoal ? doneTasks.filter((task) => task.goalId === topGoal.id).reduce((sum, task) => sum + task.points, 0) : 0;
     const completedToday = doneTasks.filter((task) => task.completedAt?.slice(0, 10) === now.toISOString().slice(0, 10)).length;
+    const alignedHabitCount = habits.reduce((sum, habit) => sum + habit.checkIns.filter((checkIn) => isAlignedHabitCheckIn(habit, checkIn)).length, 0);
     return [
         {
             id: "next-level",
@@ -174,13 +212,23 @@ export function buildMilestoneRewards(goals, tasks, now = new Date()) {
             current: topGoal ? topGoalXp : 0,
             target: topGoal ? topGoal.targetPoints : 1,
             completed: topGoal ? topGoalXp >= topGoal.targetPoints : false
+        },
+        {
+            id: "habit-mass",
+            title: "Habit mass threshold",
+            summary: "Make recurring behavior part of the same reward engine as tasks and projects.",
+            rewardLabel: "Consistency cache +75 xp",
+            progressLabel: `${Math.min(alignedHabitCount, 14)}/14 aligned habit check-ins`,
+            current: alignedHabitCount,
+            target: 14,
+            completed: alignedHabitCount >= 14
         }
     ].map((reward) => milestoneRewardSchema.parse(reward));
 }
-export function buildXpMomentumPulse(goals, tasks, now = new Date()) {
-    const profile = buildGamificationProfile(goals, tasks, now);
-    const achievements = buildAchievementSignals(goals, tasks, now);
-    const milestoneRewards = buildMilestoneRewards(goals, tasks, now);
+export function buildXpMomentumPulse(goals, tasks, habits, now = new Date()) {
+    const profile = buildGamificationProfile(goals, tasks, habits, now);
+    const achievements = buildAchievementSignals(goals, tasks, habits, now);
+    const milestoneRewards = buildMilestoneRewards(goals, tasks, habits, now);
     const nextMilestone = milestoneRewards.find((reward) => !reward.completed) ?? milestoneRewards[0] ?? null;
     const unlockedAchievements = achievements.filter((achievement) => achievement.unlocked).length;
     const status = profile.momentumScore >= 80 ? "surging" : profile.momentumScore >= 60 ? "steady" : "recovering";
@@ -206,10 +254,10 @@ export function buildXpMomentumPulse(goals, tasks, now = new Date()) {
         nextMilestoneLabel: nextMilestone?.rewardLabel ?? "Keep building visible momentum"
     };
 }
-export function buildGamificationOverview(goals, tasks, now = new Date()) {
+export function buildGamificationOverview(goals, tasks, habits, now = new Date()) {
     return gamificationOverviewSchema.parse({
-        profile: buildGamificationProfile(goals, tasks, now),
-        achievements: buildAchievementSignals(goals, tasks, now),
-        milestoneRewards: buildMilestoneRewards(goals, tasks, now)
+        profile: buildGamificationProfile(goals, tasks, habits, now),
+        achievements: buildAchievementSignals(goals, tasks, habits, now),
+        milestoneRewards: buildMilestoneRewards(goals, tasks, habits, now)
     });
 }

package/dist/server/services/insights.js

@@ -1,6 +1,7 @@
 import { listActivityEvents } from "../repositories/activity-events.js";
 import { listInsights } from "../repositories/collaboration.js";
 import { listGoals } from "../repositories/goals.js";
+import { listHabits } from "../repositories/habits.js";
 import { listTasks } from "../repositories/tasks.js";
 import { getOverviewContext } from "./context.js";
 import { buildGamificationProfile } from "./gamification.js";
@@ -33,7 +34,7 @@ function buildHeatmap(tasks, now) {
 export function getInsightsPayload(now = new Date()) {
     const goals = listGoals();
     const tasks = listTasks();
-    const gamification = buildGamificationProfile(goals, tasks, now);
+    const gamification = buildGamificationProfile(goals, tasks, listHabits(), now);
     const overview = getOverviewContext(now);
     const activity = listActivityEvents({ limit: 60 });
     const trends = Array.from({ length: 6 }, (_, offset) => {

package/dist/server/services/reviews.js

@@ -1,5 +1,6 @@
 import { listActivityEvents } from "../repositories/activity-events.js";
 import { listGoals } from "../repositories/goals.js";
+import { listHabits } from "../repositories/habits.js";
 import { listTasks } from "../repositories/tasks.js";
 import { buildGamificationProfile } from "./gamification.js";
 import { weeklyReviewPayloadSchema } from "../types.js";
@@ -36,7 +37,7 @@ function dailyBuckets(tasks, start) {
 export function getWeeklyReviewPayload(now = new Date()) {
     const goals = listGoals();
     const tasks = listTasks();
-    const gamification = buildGamificationProfile(goals, tasks, now);
+    const gamification = buildGamificationProfile(goals, tasks, listHabits(), now);
     const weekStart = startOfWeek(now);
     const weekEnd = addDays(weekStart, 6);
     const weekTasks = tasks.filter((task) => task.updatedAt >= weekStart.toISOString() && task.updatedAt <= addDays(weekEnd, 1).toISOString());

package/dist/server/types.js

@@ -11,8 +11,13 @@ export const taskDueFilterSchema = z.enum(["overdue", "today", "week"]);
 export const taskRunStatusSchema = z.enum(["active", "completed", "released", "timed_out"]);
 export const taskTimerModeSchema = z.enum(["planned", "unlimited"]);
 export const timeAccountingModeSchema = z.enum(["split", "parallel", "primary_only"]);
+export const habitFrequencySchema = z.enum(["daily", "weekly"]);
+export const habitPolaritySchema = z.enum(["positive", "negative"]);
+export const habitStatusSchema = z.enum(["active", "paused", "archived"]);
+export const habitCheckInStatusSchema = z.enum(["done", "missed"]);
 export const activityEntityTypeSchema = z.enum([
     "task",
+    "habit",
     "goal",
     "project",
     "domain",
@@ -50,6 +55,7 @@ export const crudEntityTypeSchema = z.enum([
     "goal",
     "project",
     "task",
+    "habit",
     "tag",
     "note",
     "insight",
@@ -63,6 +69,22 @@ export const crudEntityTypeSchema = z.enum([
     "emotion_definition",
     "trigger_report"
 ]);
+export const rewardableEntityTypeSchema = z.enum([
+    "system",
+    "goal",
+    "project",
+    "task",
+    "habit",
+    "tag",
+    "note",
+    "insight",
+    "psyche_value",
+    "behavior_pattern",
+    "behavior",
+    "belief_entry",
+    "mode_profile",
+    "trigger_report"
+]);
 export const deleteModeSchema = z.enum(["soft", "hard"]);
 export const rewardRuleFamilySchema = z.enum([
     "completion",
@@ -215,6 +237,48 @@ export const taskRunSchema = z.object({
     timedOutAt: z.string().nullable(),
     updatedAt: z.string()
 });
+export const habitCheckInSchema = z.object({
+    id: z.string(),
+    habitId: z.string(),
+    dateKey: z.string(),
+    status: habitCheckInStatusSchema,
+    note: z.string(),
+    deltaXp: z.number().int(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const habitSchema = z.object({
+    id: z.string(),
+    title: nonEmptyTrimmedString,
+    description: trimmedString,
+    status: habitStatusSchema,
+    polarity: habitPolaritySchema,
+    frequency: habitFrequencySchema,
+    targetCount: z.number().int().positive(),
+    weekDays: z.array(z.number().int().min(0).max(6)).default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorId: z.string().nullable(),
+    linkedBehaviorTitle: z.string().nullable(),
+    linkedBehaviorTitles: z.array(z.string()).default([]),
+    rewardXp: z.number().int().positive(),
+    penaltyXp: z.number().int().positive(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    lastCheckInAt: z.string().nullable(),
+    lastCheckInStatus: habitCheckInStatusSchema.nullable(),
+    streakCount: z.number().int().nonnegative(),
+    completionRate: z.number().min(0).max(100),
+    dueToday: z.boolean(),
+    checkIns: z.array(habitCheckInSchema).default([])
+});
 export const activityEventSchema = z.object({
     id: z.string(),
     entityType: activityEntityTypeSchema,
@@ -314,6 +378,7 @@ export const dashboardPayloadSchema = z.object({
     goals: z.array(dashboardGoalSchema),
     projects: z.array(projectSummarySchema),
     tasks: z.array(taskSchema),
+    habits: z.array(habitSchema),
     tags: z.array(tagSchema),
     suggestedTags: z.array(tagSchema),
     owners: z.array(z.string()),
@@ -354,6 +419,7 @@ export const overviewContextSchema = z.object({
     projects: z.array(projectSummarySchema),
     activeGoals: z.array(dashboardGoalSchema),
     topTasks: z.array(taskSchema),
+    dueHabits: z.array(habitSchema),
     recentEvidence: z.array(activityEventSchema),
     achievements: z.array(achievementSignalSchema),
     domainBalance: z.array(contextDomainBalanceSchema),
@@ -381,8 +447,10 @@ export const todayContextSchema = z.object({
         sessionLabel: z.string()
     }),
     timeline: z.array(todayTimelineBucketSchema),
+    dueHabits: z.array(habitSchema),
     dailyQuests: z.array(todayQuestSchema),
     milestoneRewards: z.array(milestoneRewardSchema),
+    recentHabitRewards: z.array(z.lazy(() => rewardLedgerEventSchema)).default([]),
     momentum: z.object({
         streakDays: z.number().int().nonnegative(),
         momentumScore: z.number().int().min(0).max(100),
@@ -656,6 +724,7 @@ export const operatorContextPayloadSchema = z.object({
     generatedAt: z.string(),
     activeProjects: z.array(projectSummarySchema),
     focusTasks: z.array(taskSchema),
+    dueHabits: z.array(habitSchema),
     currentBoard: z.object({
         backlog: z.array(taskSchema),
         focus: z.array(taskSchema),
@@ -675,7 +744,7 @@ export const updateRewardRuleSchema = z.object({
     config: z.record(z.string(), rewardConfigValueSchema).optional()
 });
 export const createManualRewardGrantSchema = z.object({
-    entityType: nonEmptyTrimmedString,
+    entityType: rewardableEntityTypeSchema,
     entityId: nonEmptyTrimmedString,
     deltaXp: z.number().int().refine((value) => value !== 0, {
         message: "deltaXp must not be zero"
@@ -777,6 +846,12 @@ export const projectListQuerySchema = z.object({
     status: projectStatusSchema.optional(),
     limit: z.coerce.number().int().positive().max(100).optional()
 });
+export const habitListQuerySchema = z.object({
+    status: habitStatusSchema.optional(),
+    polarity: habitPolaritySchema.optional(),
+    dueToday: z.coerce.boolean().optional(),
+    limit: z.coerce.number().int().positive().max(100).optional()
+});
 export const createGoalSchema = z.object({
     title: nonEmptyTrimmedString,
     description: trimmedString.default(""),
@@ -822,6 +897,65 @@ export const taskMutationShape = {
     notes: z.array(nestedCreateNoteSchema).default([])
 };
 export const createTaskSchema = z.object(taskMutationShape);
+const habitMutationShape = {
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    status: habitStatusSchema.default("active"),
+    polarity: habitPolaritySchema.default("positive"),
+    frequency: habitFrequencySchema.default("daily"),
+    targetCount: z.number().int().min(1).max(14).default(1),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7).default([]),
+    linkedGoalIds: uniqueStringArraySchema.default([]),
+    linkedProjectIds: uniqueStringArraySchema.default([]),
+    linkedTaskIds: uniqueStringArraySchema.default([]),
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    linkedPatternIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorIds: uniqueStringArraySchema.default([]),
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    linkedBehaviorId: nonEmptyTrimmedString.nullable().default(null),
+    rewardXp: z.number().int().min(1).max(100).default(12),
+    penaltyXp: z.number().int().min(1).max(100).default(8)
+};
+export const createHabitSchema = z.object(habitMutationShape).superRefine((value, context) => {
+    if (value.frequency === "weekly" && value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Select at least one weekday for weekly habits"
+        });
+    }
+});
+export const updateHabitSchema = z.object({
+    title: nonEmptyTrimmedString.optional(),
+    description: trimmedString.optional(),
+    status: habitStatusSchema.optional(),
+    polarity: habitPolaritySchema.optional(),
+    frequency: habitFrequencySchema.optional(),
+    targetCount: z.number().int().min(1).max(14).optional(),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7).optional(),
+    linkedGoalIds: uniqueStringArraySchema.optional(),
+    linkedProjectIds: uniqueStringArraySchema.optional(),
+    linkedTaskIds: uniqueStringArraySchema.optional(),
+    linkedValueIds: uniqueStringArraySchema.optional(),
+    linkedPatternIds: uniqueStringArraySchema.optional(),
+    linkedBehaviorIds: uniqueStringArraySchema.optional(),
+    linkedBeliefIds: uniqueStringArraySchema.optional(),
+    linkedModeIds: uniqueStringArraySchema.optional(),
+    linkedReportIds: uniqueStringArraySchema.optional(),
+    linkedBehaviorId: nonEmptyTrimmedString.nullable().optional(),
+    rewardXp: z.number().int().min(1).max(100).optional(),
+    penaltyXp: z.number().int().min(1).max(100).optional()
+}).superRefine((value, context) => {
+    if (value.frequency === "weekly" && value.weekDays !== undefined && value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Select at least one weekday for weekly habits"
+        });
+    }
+});
 export const updateTaskSchema = z.object({
     title: nonEmptyTrimmedString.optional(),
     description: trimmedString.optional(),
@@ -880,6 +1014,11 @@ 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("")
+});
 export const updateSettingsSchema = z.object({
     profile: z
         .object({

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