forge-openclaw-plugin 0.2.13 → 0.2.18

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.13",
+  "version": "0.2.18",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",

package/server/migrations/003_habits.sql

@@ -0,0 +1,30 @@
+CREATE TABLE IF NOT EXISTS habits (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  status TEXT NOT NULL DEFAULT 'active',
+  polarity TEXT NOT NULL DEFAULT 'positive',
+  frequency TEXT NOT NULL DEFAULT 'daily',
+  target_count INTEGER NOT NULL DEFAULT 1,
+  week_days_json TEXT NOT NULL DEFAULT '[]',
+  linked_behavior_id TEXT REFERENCES psyche_behaviors(id) ON DELETE SET NULL,
+  reward_xp INTEGER NOT NULL DEFAULT 12,
+  penalty_xp INTEGER NOT NULL DEFAULT 8,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS habit_check_ins (
+  id TEXT PRIMARY KEY,
+  habit_id TEXT NOT NULL REFERENCES habits(id) ON DELETE CASCADE,
+  date_key TEXT NOT NULL,
+  status TEXT NOT NULL,
+  note TEXT NOT NULL DEFAULT '',
+  delta_xp INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (habit_id, date_key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_habits_status ON habits(status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_habit_check_ins_habit_date ON habit_check_ins(habit_id, date_key DESC);

package/server/migrations/004_habit_links.sql

@@ -0,0 +1,8 @@
+ALTER TABLE habits
+ADD COLUMN linked_goal_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_project_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_task_ids_json TEXT NOT NULL DEFAULT '[]';

package/server/migrations/005_habit_psyche_links.sql

@@ -0,0 +1,24 @@
+ALTER TABLE habits
+ADD COLUMN linked_value_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_pattern_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_behavior_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_belief_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_mode_ids_json TEXT NOT NULL DEFAULT '[]';
+
+ALTER TABLE habits
+ADD COLUMN linked_report_ids_json TEXT NOT NULL DEFAULT '[]';
+
+UPDATE habits
+SET linked_behavior_ids_json = CASE
+  WHEN linked_behavior_id IS NULL OR trim(linked_behavior_id) = '' THEN '[]'
+  ELSE json_array(linked_behavior_id)
+END
+WHERE linked_behavior_ids_json = '[]';

package/skills/forge-openclaw/SKILL.md

@@ -1,14 +1,17 @@
 ---
 name: forge-openclaw
-description: use when the user wants to save, search, update, review, start, stop, or explain work or psyche records inside forge, or when the conversation is clearly about a forge entity such as a goal, project, task, task_run, insight, psyche_value, behavior_pattern, behavior, belief_entry, mode_profile, mode_guide_session, trigger_report, event_type, or emotion_definition. identify the exact forge entity, keep the main conversation natural, offer saving once when helpful, ask only for missing fields, and use the correct forge tool and payload shape.
+description: use when the user wants to save, search, update, review, start, stop, reward, or explain work or psyche records inside forge, or when the conversation is clearly about a forge entity such as a goal, project, task, habit, task_run, insight, psyche_value, behavior_pattern, behavior, belief_entry, mode_profile, mode_guide_session, trigger_report, event_type, or emotion_definition. identify the exact forge entity, keep the main conversation natural, offer saving once when helpful, ask only for missing fields, and use the correct forge tool and payload shape.
 ---
 
 Forge is the user's structured system for planning work, doing work, reflecting on patterns, and keeping a truthful record of what is happening. Use it when the user is clearly working inside that system, or when they are describing something that naturally belongs there and would benefit from being stored, updated, reviewed, or acted on in Forge. Keep the conversation natural first. Do not turn every message into intake. When a real Forge entity is clearly present, name the exact entity type plainly, help with the substance of the conversation, and then offer Forge once, lightly, if storing it would genuinely help.
 
 Forge has two major domains. The planning side covers goals, projects, tasks, notes, live work sessions, and agent-authored insights. The Psyche side covers values, patterns, behaviors, beliefs, modes, guided mode sessions, trigger reports, event types, and reusable emotion definitions. The model should use the real entity names, not vague substitutes. Say `project`, not “initiative”. Say `behavior_pattern`, not “theme”. Say `trigger_report`, not “incident note”.
+Habits are a first-class recurring entity in the planning side. They can link directly to goals, projects, tasks, values, patterns, behaviors, beliefs, modes, and trigger reports, and they participate in the same searchable noteable graph as the rest of Forge.
 
 Write to Forge only with clear user consent. If the user is just thinking aloud, helping first is usually better than writing immediately. After helping, you may offer one short Forge prompt if the match is strong. If the user agrees, ask only for the missing fields and only one to three focused questions at a time. Do not offer Forge again after a decline unless the user reopens it.
 
+Optional recurring automation templates live in `cron_jobs.md` next to this skill. Use that file only when the user explicitly asks for recurring Forge automations, cron jobs, scheduled check-ins, or a recurring synthesis workflow. Those entries are rich examples, not defaults: adapt personal details such as names, recipients, phone numbers, or project titles to the current user, but preserve the intended tone, operational logic, and any example naming conventions when the user chooses to adopt that pattern.
+
 Forge data location rule:
 
 - by default, Forge stores data under the active runtime root at `data/forge.sqlite`
@@ -80,6 +83,15 @@ Ask:
 2. Should it live under an existing goal or project?
 3. Does it need a due date, priority, or owner?
 
+`habit`
+Use for a recurring commitment or recurring slip with explicit cadence and XP consequences.
+Minimum field: `title`
+Usually useful: `polarity`, `frequency`, `linkedGoalIds`, `linkedProjectIds`, `linkedTaskIds`, `linkedValueIds`, `linkedPatternIds`, `linkedBehaviorIds`, `linkedBeliefIds`, `linkedModeIds`, `linkedReportIds`
+Ask:
+1. What is the recurring behavior in one concrete sentence?
+2. Is doing it good (`positive`) or a slip (`negative`)?
+3. What should it link back to in Forge or Psyche?
+
 `task_run`
 Use for live work happening now.
 Required fields to start: `taskId`, `actor`
@@ -171,12 +183,13 @@ Use the batch entity tools for stored records:
 `forge_search_entities`, `forge_create_entities`, `forge_update_entities`, `forge_delete_entities`, `forge_restore_entities`
 
 These tools operate on:
-`goal`, `project`, `task`, `note`, `psyche_value`, `behavior_pattern`, `behavior`, `belief_entry`, `mode_profile`, `mode_guide_session`, `trigger_report`, `event_type`, `emotion_definition`
+`goal`, `project`, `task`, `habit`, `note`, `psyche_value`, `behavior_pattern`, `behavior`, `belief_entry`, `mode_profile`, `mode_guide_session`, `trigger_report`, `event_type`, `emotion_definition`
 
 Use live work tools for `task_run`:
 `forge_log_work`, `forge_start_task_run`, `forge_heartbeat_task_run`, `forge_focus_task_run`, `forge_complete_task_run`, `forge_release_task_run`
 
 Use `forge_post_insight` for `insight`.
+Use `forge_grant_reward_bonus` only for explicit manual XP bonuses or penalties that should be auditable and cannot be expressed through the normal task-run or habit check-in routes.
 
 Do not say you lack a creation path when these tools cover the request. Do not open the Forge UI or a browser for normal creation or updates that the tools already support. Use `forge_get_ui_entrypoint` only when visual review, Kanban movement, graph exploration, or complex multi-record editing would genuinely be easier there.
 
@@ -247,6 +260,7 @@ When the user asks which Forge tools are available, list exactly these tools:
 `forge_update_entities`
 `forge_delete_entities`
 `forge_restore_entities`
+`forge_grant_reward_bonus`
 `forge_log_work`
 `forge_start_task_run`
 `forge_heartbeat_task_run`