forge-openclaw-plugin 0.2.4 → 0.2.7

package/dist/server/services/gamification.js

@@ -0,0 +1,215 @@
+import { achievementSignalSchema, gamificationOverviewSchema, gamificationProfileSchema, milestoneRewardSchema } from "../types.js";
+import { getTotalXp, getWeeklyXp } from "../repositories/rewards.js";
+const XP_PER_LEVEL = 120;
+function startOfWeek(date) {
+    const clone = new Date(date);
+    const day = clone.getDay();
+    const delta = day === 0 ? -6 : 1 - day;
+    clone.setDate(clone.getDate() + delta);
+    clone.setHours(0, 0, 0, 0);
+    return clone;
+}
+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)] : [])));
+    if (completedDays.size === 0) {
+        return 0;
+    }
+    let streak = 0;
+    const cursor = new Date(now);
+    cursor.setHours(0, 0, 0, 0);
+    while (completedDays.has(cursor.toISOString().slice(0, 10))) {
+        streak += 1;
+        cursor.setDate(cursor.getDate() - 1);
+    }
+    return streak;
+}
+function calculateLevel(totalXp) {
+    const level = Math.floor(totalXp / XP_PER_LEVEL) + 1;
+    const currentLevelFloor = (level - 1) * XP_PER_LEVEL;
+    return {
+        level,
+        currentLevelXp: totalXp - currentLevelFloor,
+        nextLevelXp: XP_PER_LEVEL
+    };
+}
+function latestCompletionForTasks(tasks) {
+    return 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()) {
+    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 alignedDonePoints = doneTasks
+        .filter((task) => task.goalId !== null && task.tagIds.length > 0)
+        .reduce((sum, task) => sum + task.points, 0);
+    const streakDays = calculateStreak(tasks, now);
+    const levelState = calculateLevel(totalXp);
+    const goalScores = goals
+        .map((goal) => ({
+        goalId: goal.id,
+        goalTitle: goal.title,
+        earnedXp: doneTasks.filter((task) => task.goalId === goal.id).reduce((sum, task) => sum + task.points, 0)
+    }))
+        .sort((left, right) => right.earnedXp - left.earnedXp);
+    const topGoal = goalScores.find((goal) => goal.earnedXp > 0) ?? null;
+    return gamificationProfileSchema.parse({
+        totalXp,
+        level: levelState.level,
+        currentLevelXp: levelState.currentLevelXp,
+        nextLevelXp: levelState.nextLevelXp,
+        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))),
+        topGoalId: topGoal?.goalId ?? null,
+        topGoalTitle: topGoal?.goalTitle ?? null
+    });
+}
+export function buildAchievementSignals(goals, tasks, now = new Date()) {
+    const profile = buildGamificationProfile(goals, tasks, 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));
+    return [
+        {
+            id: "streak-operator",
+            title: "Streak Operator",
+            summary: "Maintain consecutive days of meaningful completions.",
+            tier: profile.streakDays >= 7 ? "gold" : "silver",
+            progressLabel: `${Math.min(profile.streakDays, 7)}/7 days`,
+            unlocked: profile.streakDays >= 7,
+            unlockedAt: profile.streakDays >= 7 ? latestCompletionForTasks(doneTasks) : null
+        },
+        {
+            id: "aligned-maker",
+            title: "Aligned Maker",
+            summary: "Complete work that is explicitly tied to a goal and tagged context.",
+            tier: alignedDoneTasks.length >= 5 ? "gold" : "bronze",
+            progressLabel: `${Math.min(alignedDoneTasks.length, 5)}/5 aligned completions`,
+            unlocked: alignedDoneTasks.length >= 5,
+            unlockedAt: alignedDoneTasks.length >= 5 ? latestCompletionForTasks(alignedDoneTasks) : null
+        },
+        {
+            id: "momentum-engine",
+            title: "Momentum Engine",
+            summary: "Push weekly XP high enough that momentum becomes visible.",
+            tier: profile.weeklyXp >= 240 ? "gold" : profile.weeklyXp >= 120 ? "silver" : "bronze",
+            progressLabel: `${Math.min(profile.weeklyXp, 240)}/240 weekly xp`,
+            unlocked: profile.weeklyXp >= 240,
+            unlockedAt: profile.weeklyXp >= 240 ? latestCompletionForTasks(doneTasks) : null
+        },
+        {
+            id: "path-keeper",
+            title: "Path Keeper",
+            summary: "Keep multiple life arcs alive instead of overfitting one lane.",
+            tier: highValueGoals.length >= 3 ? "platinum" : "silver",
+            progressLabel: `${Math.min(highValueGoals.length, 3)}/3 active arcs with wins`,
+            unlocked: highValueGoals.length >= 3,
+            unlockedAt: highValueGoals.length >= 3 ? latestCompletionForTasks(doneTasks) : null
+        },
+        {
+            id: "focus-lane",
+            title: "Focus Lane Live",
+            summary: "Sustain a protected execution lane instead of browsing a backlog.",
+            tier: focusTasks.length > 0 ? "silver" : "bronze",
+            progressLabel: `${Math.min(focusTasks.length, 1)}/1 live directives`,
+            unlocked: focusTasks.length > 0,
+            unlockedAt: focusTasks.length > 0 ? now.toISOString() : null
+        }
+    ].map((achievement) => achievementSignalSchema.parse(achievement));
+}
+export function buildMilestoneRewards(goals, tasks, now = new Date()) {
+    const profile = buildGamificationProfile(goals, tasks, 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;
+    return [
+        {
+            id: "next-level",
+            title: "Next level threshold",
+            summary: "Keep pushing until the next level unlocks a stronger sense of ascent.",
+            rewardLabel: `Level ${profile.level + 1}`,
+            progressLabel: `${profile.currentLevelXp}/${profile.nextLevelXp} xp`,
+            current: profile.currentLevelXp,
+            target: profile.nextLevelXp,
+            completed: profile.currentLevelXp >= profile.nextLevelXp
+        },
+        {
+            id: "weekly-sprint",
+            title: "Weekly sprint heat",
+            summary: "Cross the weekly XP line that keeps the system feeling alive.",
+            rewardLabel: "Momentum bonus",
+            progressLabel: `${Math.min(profile.weeklyXp, 240)}/240 weekly xp`,
+            current: profile.weeklyXp,
+            target: 240,
+            completed: profile.weeklyXp >= 240
+        },
+        {
+            id: "daily-mass",
+            title: "Daily mass threshold",
+            summary: "Make the day feel consequential with multiple completed tasks.",
+            rewardLabel: "Quest chest +90 xp",
+            progressLabel: `${Math.min(completedToday, 3)}/3 completions today`,
+            current: completedToday,
+            target: 3,
+            completed: completedToday >= 3
+        },
+        {
+            id: "goal-project",
+            title: "Project reward track",
+            summary: topGoal ? `Keep advancing the leading life goal through a concrete project path.` : "No leading life goal is established yet.",
+            rewardLabel: topGoal ? `${topGoal.title} milestone` : "Establish a lead goal",
+            progressLabel: topGoal ? `${Math.min(topGoalXp, topGoal.targetPoints)}/${topGoal.targetPoints} goal xp` : "0/1 lead arcs",
+            current: topGoal ? topGoalXp : 0,
+            target: topGoal ? topGoal.targetPoints : 1,
+            completed: topGoal ? topGoalXp >= topGoal.targetPoints : false
+        }
+    ].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);
+    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";
+    const headline = status === "surging"
+        ? `${profile.streakDays}-day streak online. Forge is compounding.`
+        : status === "steady"
+            ? `Momentum is stable. One sharp push keeps the engine hot.`
+            : `Recovery window open. A small real win will restart the climb.`;
+    const detail = nextMilestone !== null
+        ? `${nextMilestone.title} is the clean next unlock. ${nextMilestone.progressLabel}.`
+        : `Level ${profile.level} is active with ${profile.weeklyXp} weekly XP already recorded.`;
+    const celebrationLabel = unlockedAchievements > 0
+        ? `${unlockedAchievements} achievement${unlockedAchievements === 1 ? "" : "s"} unlocked`
+        : profile.weeklyXp >= 120
+            ? `Weekly sprint heat is building`
+            : `Next celebration comes from a real completion or repair`;
+    return {
+        status,
+        headline,
+        detail,
+        celebrationLabel,
+        nextMilestoneId: nextMilestone?.id ?? null,
+        nextMilestoneLabel: nextMilestone?.rewardLabel ?? "Keep building visible momentum"
+    };
+}
+export function buildGamificationOverview(goals, tasks, now = new Date()) {
+    return gamificationOverviewSchema.parse({
+        profile: buildGamificationProfile(goals, tasks, now),
+        achievements: buildAchievementSignals(goals, tasks, now),
+        milestoneRewards: buildMilestoneRewards(goals, tasks, now)
+    });
+}

package/dist/server/services/insights.js

@@ -0,0 +1,91 @@
+import { listActivityEvents } from "../repositories/activity-events.js";
+import { listInsights } from "../repositories/collaboration.js";
+import { listGoals } from "../repositories/goals.js";
+import { listTasks } from "../repositories/tasks.js";
+import { getOverviewContext } from "./context.js";
+import { buildGamificationProfile } from "./gamification.js";
+import { insightsPayloadSchema } from "../types.js";
+function dayKey(date) {
+    return date.toISOString().slice(0, 10);
+}
+function addDays(date, days) {
+    const clone = new Date(date);
+    clone.setDate(clone.getDate() + days);
+    return clone;
+}
+function buildHeatmap(tasks, now) {
+    const cells = [];
+    for (let index = 29; index >= 0; index -= 1) {
+        const current = addDays(now, -index);
+        const currentKey = dayKey(current);
+        const completed = tasks.filter((task) => task.completedAt?.slice(0, 10) === currentKey).length;
+        const focus = tasks.filter((task) => task.updatedAt.slice(0, 10) === currentKey && (task.status === "focus" || task.status === "in_progress")).length;
+        cells.push({
+            id: currentKey,
+            label: current.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+            completed,
+            focus,
+            intensity: Math.min(4, completed + focus)
+        });
+    }
+    return cells;
+}
+export function getInsightsPayload(now = new Date()) {
+    const goals = listGoals();
+    const tasks = listTasks();
+    const gamification = buildGamificationProfile(goals, tasks, now);
+    const overview = getOverviewContext(now);
+    const activity = listActivityEvents({ limit: 60 });
+    const trends = Array.from({ length: 6 }, (_, offset) => {
+        const bucketStart = addDays(now, -(5 - offset) * 5);
+        const bucketEnd = addDays(bucketStart, 4);
+        const completedTasks = tasks.filter((task) => {
+            const completedAt = task.completedAt;
+            return completedAt !== null && completedAt >= bucketStart.toISOString() && completedAt <= bucketEnd.toISOString();
+        });
+        const updatedTasks = tasks.filter((task) => task.updatedAt >= bucketStart.toISOString() && task.updatedAt <= bucketEnd.toISOString());
+        return {
+            label: bucketStart.toLocaleDateString("en-US", { month: "short", day: "numeric" }),
+            xp: completedTasks.reduce((sum, task) => sum + task.points, 0),
+            focusScore: Math.min(100, updatedTasks.length * 12 + completedTasks.length * 20)
+        };
+    });
+    const domainBalance = overview.domainBalance.map((domain) => ({
+        label: domain.label,
+        value: Math.min(100, domain.completedPoints + domain.activeTaskCount * 8),
+        color: domain.color,
+        note: domain.momentumLabel
+    }));
+    const hottestGoal = overview.activeGoals[0] ?? null;
+    const blockedTasks = tasks.filter((task) => task.status === "blocked").length;
+    const overdueTasks = tasks.filter((task) => task.status !== "done" && task.dueDate !== null && task.dueDate < dayKey(now)).length;
+    const feed = listInsights({ limit: 8 });
+    return insightsPayloadSchema.parse({
+        generatedAt: now.toISOString(),
+        status: {
+            systemStatus: gamification.momentumScore >= 80 ? "Optimal Flow" : gamification.momentumScore >= 60 ? "Stable Build" : "Needs Recovery",
+            streakDays: gamification.streakDays,
+            momentumScore: gamification.momentumScore
+        },
+        momentumHeatmap: buildHeatmap(tasks, now),
+        executionTrends: trends,
+        domainBalance,
+        coaching: {
+            title: hottestGoal ? `Protect ${hottestGoal.title}` : "Rebuild momentum",
+            summary: blockedTasks > 0
+                ? `${blockedTasks} blocked task${blockedTasks === 1 ? "" : "s"} are leaking velocity out of the system.`
+                : overdueTasks > 0
+                    ? `${overdueTasks} overdue task${overdueTasks === 1 ? "" : "s"} are the main drag vector right now.`
+                    : "Recent evidence shows enough movement to push the next arc more aggressively.",
+            recommendation: blockedTasks > 0
+                ? "Clear one blocked task before adding more new work."
+                : hottestGoal
+                    ? `Queue the next decisive move for ${hottestGoal.title} and keep a deep-work lane active.`
+                    : "Pick one life goal, one project, and one task to stabilize the next 24 hours.",
+            ctaLabel: "Trigger coaching insight"
+        },
+        evidenceDigest: activity.slice(0, 5),
+        feed,
+        openCount: feed.filter((insight) => insight.status === "open").length
+    });
+}

package/dist/server/services/projects.js

@@ -0,0 +1,75 @@
+import { listActivityEvents } from "../repositories/activity-events.js";
+import { getGoalById, listGoals } from "../repositories/goals.js";
+import { listProjects } from "../repositories/projects.js";
+import { listTasks } from "../repositories/tasks.js";
+import { emptyTaskTimeSummary } from "./work-time.js";
+import { projectBoardPayloadSchema, projectSummarySchema } from "../types.js";
+function projectTaskSummary(tasks) {
+    const completedTasks = tasks.filter((task) => task.status === "done");
+    const activeTasks = tasks.filter((task) => task.status !== "done");
+    const totalTasks = tasks.length;
+    const earnedPoints = completedTasks.reduce((sum, task) => sum + task.points, 0);
+    const progress = totalTasks === 0 ? 0 : Math.min(100, Math.round((completedTasks.length / totalTasks) * 100));
+    const nextTask = activeTasks.find((task) => task.status === "focus" || task.status === "in_progress") ??
+        activeTasks.find((task) => task.status === "backlog") ??
+        activeTasks[0] ??
+        null;
+    const momentumLabel = completedTasks.length === 0
+        ? activeTasks.length > 0
+            ? "Building momentum"
+            : "Waiting for the first task"
+        : activeTasks.some((task) => task.status === "blocked")
+            ? "Needs intervention"
+            : progress >= 70
+                ? "Closing strong"
+                : "Making steady progress";
+    return {
+        activeTaskCount: activeTasks.length,
+        completedTaskCount: completedTasks.length,
+        totalTasks,
+        earnedPoints,
+        progress,
+        nextTaskId: nextTask?.id ?? null,
+        nextTaskTitle: nextTask?.title ?? null,
+        momentumLabel,
+        time: tasks.reduce((summary, task) => ({
+            totalTrackedSeconds: summary.totalTrackedSeconds + task.time.totalTrackedSeconds,
+            totalCreditedSeconds: Math.round((summary.totalCreditedSeconds + task.time.totalCreditedSeconds) * 100) / 100,
+            activeRunCount: summary.activeRunCount + task.time.activeRunCount,
+            hasCurrentRun: summary.hasCurrentRun || task.time.hasCurrentRun,
+            currentRunId: summary.currentRunId ?? task.time.currentRunId
+        }), emptyTaskTimeSummary())
+    };
+}
+export function listProjectSummaries(filters = {}) {
+    const goals = new Map(listGoals().map((goal) => [goal.id, goal]));
+    const tasks = listTasks();
+    return listProjects(filters).map((project) => {
+        const goal = goals.get(project.goalId);
+        const projectTasks = tasks.filter((task) => task.projectId === project.id);
+        return projectSummarySchema.parse({
+            ...project,
+            goalTitle: goal?.title ?? "Unknown life goal",
+            ...projectTaskSummary(projectTasks)
+        });
+    });
+}
+export function getProjectSummary(projectId) {
+    return listProjectSummaries().find((project) => project.id === projectId);
+}
+export function getProjectBoard(projectId) {
+    const project = getProjectSummary(projectId);
+    if (!project) {
+        return undefined;
+    }
+    const goal = getGoalById(project.goalId);
+    if (!goal) {
+        return undefined;
+    }
+    return projectBoardPayloadSchema.parse({
+        project,
+        goal,
+        tasks: listTasks({ projectId }),
+        activity: listActivityEvents({ entityType: "project", entityId: projectId, limit: 20 }).concat(listActivityEvents({ entityType: "task", limit: 100 }).filter((event) => listTasks({ projectId }).some((task) => task.id === event.entityId)).slice(0, 20))
+    });
+}

package/dist/server/services/psyche.js

@@ -0,0 +1,63 @@
+import { getDomainBySlug } from "../repositories/domains.js";
+import { listComments } from "../repositories/comments.js";
+import { listInsights } from "../repositories/collaboration.js";
+import { listBehaviorPatterns, listBehaviors, listBeliefEntries, listModeProfiles, listPsycheValues, listSchemaCatalog, listTriggerReports } from "../repositories/psyche.js";
+import { psycheOverviewPayloadSchema } from "../psyche-types.js";
+const PSYCHE_ENTITY_TYPE_SET = new Set([
+    "psyche_value",
+    "behavior_pattern",
+    "behavior",
+    "belief_entry",
+    "mode_profile",
+    "trigger_report"
+]);
+export function getPsycheOverview() {
+    const domain = getDomainBySlug("psyche");
+    if (!domain) {
+        throw new Error("Psyche domain is not available");
+    }
+    const values = listPsycheValues();
+    const patterns = listBehaviorPatterns();
+    const behaviors = listBehaviors();
+    const beliefs = listBeliefEntries();
+    const modes = listModeProfiles();
+    const reports = listTriggerReports(5);
+    const schemaCatalog = listSchemaCatalog();
+    const comments = listComments({ limit: 200 });
+    const openInsights = listInsights({ limit: 100 }).filter((insight) => insight.entityType && PSYCHE_ENTITY_TYPE_SET.has(insight.entityType)).length;
+    const unresolvedComments = comments.filter((comment) => PSYCHE_ENTITY_TYPE_SET.has(comment.entityType)).length;
+    const committedActions = [
+        ...values.flatMap((value) => value.committedActions),
+        ...behaviors.filter((behavior) => behavior.kind === "committed").map((behavior) => behavior.title),
+        ...reports.flatMap((report) => report.nextMoves)
+    ];
+    const schemaPressure = schemaCatalog
+        .filter((schema) => schema.schemaType === "maladaptive")
+        .map((schema) => {
+        const activationCount = beliefs.filter((belief) => belief.schemaId === schema.id).length +
+            behaviors.filter((behavior) => behavior.linkedSchemaIds.includes(schema.id)).length +
+            reports.filter((report) => report.schemaLinks.includes(schema.id) || report.schemaLinks.includes(schema.slug)).length;
+        return {
+            schemaId: schema.id,
+            title: schema.title,
+            activationCount
+        };
+    })
+        .filter((entry) => entry.activationCount > 0)
+        .sort((left, right) => right.activationCount - left.activationCount)
+        .slice(0, 6);
+    return psycheOverviewPayloadSchema.parse({
+        generatedAt: new Date().toISOString(),
+        domain,
+        values,
+        patterns,
+        behaviors,
+        beliefs,
+        modes,
+        reports,
+        schemaPressure,
+        openInsights,
+        unresolvedComments,
+        committedActions
+    });
+}

package/dist/server/services/relations.js

@@ -0,0 +1,28 @@
+import { getGoalById } from "../repositories/goals.js";
+import { listTagsByIds } from "../repositories/tags.js";
+import { HttpError } from "../errors.js";
+function assertKnownTags(tagIds) {
+    if (tagIds.length === 0) {
+        return;
+    }
+    const knownTagIds = new Set(listTagsByIds(tagIds).map((tag) => tag.id));
+    const missingTagIds = [...new Set(tagIds)].filter((tagId) => !knownTagIds.has(tagId));
+    if (missingTagIds.length > 0) {
+        throw new HttpError(404, "tag_not_found", `Unknown tag ids: ${missingTagIds.join(", ")}`);
+    }
+}
+export function assertGoalExists(goalId) {
+    if (!goalId) {
+        return;
+    }
+    if (!getGoalById(goalId)) {
+        throw new HttpError(404, "goal_not_found", `Goal ${goalId} does not exist`);
+    }
+}
+export function assertTaskRelations(input) {
+    assertGoalExists(input.goalId);
+    assertKnownTags(input.tagIds ?? []);
+}
+export function assertGoalRelations(input) {
+    assertKnownTags(input.tagIds ?? []);
+}

package/dist/server/services/reviews.js

@@ -0,0 +1,88 @@
+import { listActivityEvents } from "../repositories/activity-events.js";
+import { listGoals } from "../repositories/goals.js";
+import { listTasks } from "../repositories/tasks.js";
+import { buildGamificationProfile } from "./gamification.js";
+import { weeklyReviewPayloadSchema } from "../types.js";
+function startOfWeek(date) {
+    const clone = new Date(date);
+    const day = clone.getDay();
+    const delta = day === 0 ? -6 : 1 - day;
+    clone.setDate(clone.getDate() + delta);
+    clone.setHours(0, 0, 0, 0);
+    return clone;
+}
+function addDays(date, days) {
+    const clone = new Date(date);
+    clone.setDate(clone.getDate() + days);
+    return clone;
+}
+function formatRange(start, end) {
+    return `${start.toLocaleDateString("en-US", { month: "short", day: "numeric" })} - ${end.toLocaleDateString("en-US", { month: "short", day: "numeric" })}`;
+}
+function dailyBuckets(tasks, start) {
+    return Array.from({ length: 7 }, (_, index) => {
+        const current = addDays(start, index);
+        const dayLabel = current.toLocaleDateString("en-US", { weekday: "short" }).toUpperCase();
+        const dayIso = current.toISOString().slice(0, 10);
+        const completed = tasks.filter((task) => task.completedAt?.slice(0, 10) === dayIso);
+        const totalXp = completed.reduce((sum, task) => sum + task.points, 0);
+        return {
+            label: dayLabel,
+            xp: totalXp,
+            focusHours: completed.length * 2 + completed.filter((task) => task.effort !== "light").length
+        };
+    });
+}
+export function getWeeklyReviewPayload(now = new Date()) {
+    const goals = listGoals();
+    const tasks = listTasks();
+    const gamification = buildGamificationProfile(goals, tasks, 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());
+    const completedTasks = weekTasks.filter((task) => task.completedAt !== null);
+    const buckets = dailyBuckets(tasks, weekStart);
+    const totalXp = completedTasks.reduce((sum, task) => sum + task.points, 0);
+    const peakBucket = [...buckets].sort((left, right) => right.xp - left.xp)[0] ?? buckets[0];
+    const activity = listActivityEvents({ limit: 20 }).slice(0, 4);
+    const wins = activity.length > 0
+        ? activity.map((event) => ({
+            id: event.id,
+            title: event.title,
+            summary: event.description || "Structured proof of movement.",
+            rewardXp: typeof event.metadata.points === "number" ? event.metadata.points : 40
+        }))
+        : completedTasks.slice(0, 3).map((task) => ({
+            id: task.id,
+            title: task.title,
+            summary: task.description || "Completed work converted into evidence.",
+            rewardXp: task.points
+        }));
+    return weeklyReviewPayloadSchema.parse({
+        generatedAt: now.toISOString(),
+        windowLabel: formatRange(weekStart, weekEnd),
+        momentumSummary: {
+            totalXp,
+            focusHours: buckets.reduce((sum, bucket) => sum + bucket.focusHours, 0),
+            efficiencyScore: Math.min(100, gamification.momentumScore + completedTasks.length * 3),
+            peakWindow: peakBucket.label
+        },
+        chart: buckets,
+        wins,
+        calibration: goals.slice(0, 3).map((goal, index) => ({
+            id: goal.id,
+            title: goal.title,
+            mode: index === 0 ? "accelerate" : index === 1 ? "maintain" : "recover",
+            note: index === 0
+                ? "This arc has enough evidence to push harder next cycle."
+                : index === 1
+                    ? "Keep the current load and prevent drift."
+                    : "Reduce friction and re-sequence the next steps."
+        })),
+        reward: {
+            title: "Review Completion Bonus",
+            summary: "Finalizing the review locks the current cycle into evidence.",
+            rewardXp: 250
+        }
+    });
+}

package/dist/server/services/run-recovery.js

@@ -0,0 +1,13 @@
+import { recoverTimedOutTaskRuns } from "../repositories/task-runs.js";
+export function reconcileExpiredTaskRuns(options = {}) {
+    const now = options.now ?? new Date();
+    const recoveredRuns = recoverTimedOutTaskRuns({ now, limit: options.limit });
+    return {
+        recoveredAt: now.toISOString(),
+        recoveredCount: recoveredRuns.length,
+        recoveredRunIds: recoveredRuns.map((run) => run.id)
+    };
+}
+export function recoverExpiredTaskRunsOnStartup(options = {}) {
+    return reconcileExpiredTaskRuns(options);
+}

package/dist/server/services/tagging.js

@@ -0,0 +1,49 @@
+import { getGoalById } from "../repositories/goals.js";
+import { listTags, listTagsByIds } from "../repositories/tags.js";
+const keywordHints = {
+    health: ["Health", "Vitality"],
+    train: ["Health", "Vitality"],
+    workout: ["Health", "Vitality"],
+    review: ["Reflection", "Craft"],
+    plan: ["Momentum", "Admin"],
+    admin: ["Admin"],
+    write: ["Craft", "Deep Work"],
+    draft: ["Craft", "Deep Work"],
+    relationship: ["Relationships"],
+    date: ["Relationships"],
+    focus: ["Deep Work"]
+};
+function uniqueTags(tags) {
+    const seen = new Set();
+    return tags.filter((tag) => {
+        if (seen.has(tag.id)) {
+            return false;
+        }
+        seen.add(tag.id);
+        return true;
+    });
+}
+export function suggestTags(input) {
+    const tagCatalog = listTags();
+    const selected = new Set(input.selectedTagIds);
+    const terms = `${input.title} ${input.description}`.toLowerCase();
+    const suggestions = [];
+    for (const [keyword, tagNames] of Object.entries(keywordHints)) {
+        if (!terms.includes(keyword)) {
+            continue;
+        }
+        for (const tagName of tagNames) {
+            const tag = tagCatalog.find((entry) => entry.name === tagName);
+            if (tag && !selected.has(tag.id)) {
+                suggestions.push(tag);
+            }
+        }
+    }
+    if (input.goalId) {
+        const goal = getGoalById(input.goalId);
+        if (goal) {
+            suggestions.push(...listTagsByIds(goal.tagIds).filter((tag) => !selected.has(tag.id)));
+        }
+    }
+    return uniqueTags(suggestions).slice(0, 6);
+}