forge-openclaw-plugin 0.2.25 → 0.2.27

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

@@ -0,0 +1,238 @@
+import { z } from "zod";
+import { forgeCustomThemeSchema, forgeThemePreferenceSchema } from "@/lib/theme-system";
+export const appLocaleSchema = z.enum(["en", "fr"]);
+export const inlineCreateNoteSchema = z.object({
+    contentMarkdown: z.string().trim().min(1, "Note content is required"),
+    author: z.string().trim()
+});
+export const goalMutationSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    horizon: z.enum(["quarter", "year", "lifetime"]),
+    status: z.enum(["active", "paused", "completed"]),
+    userId: z.string().trim().nullable().optional(),
+    targetPoints: z.coerce.number().int().min(25).max(10000),
+    themeColor: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Theme color must be a valid hex value"),
+    tagIds: z.array(z.string()),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const projectMutationSchema = z.object({
+    goalId: z.string().trim().min(1, "Life goal is required"),
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    status: z.enum(["active", "paused", "completed"]),
+    userId: z.string().trim().nullable().optional(),
+    targetPoints: z.coerce.number().int().min(25).max(10000),
+    themeColor: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Theme color must be a valid hex value"),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const settingsMutationSchema = z.object({
+    profile: z.object({
+        operatorName: z.string().trim().min(1, "Name is required"),
+        operatorEmail: z.string().trim().min(1, "Email is required"),
+        operatorTitle: z.string().trim().min(1, "Title is required")
+    }),
+    notifications: z.object({
+        goalDriftAlerts: z.boolean(),
+        dailyQuestReminders: z.boolean(),
+        achievementCelebrations: z.boolean()
+    }),
+    execution: z.object({
+        maxActiveTasks: z.coerce.number().int().min(1).max(8),
+        timeAccountingMode: z.enum(["split", "parallel", "primary_only"])
+    }),
+    themePreference: forgeThemePreferenceSchema,
+    customTheme: forgeCustomThemeSchema.nullable().optional(),
+    localePreference: appLocaleSchema,
+    calendarProviders: z
+        .object({
+        google: z
+            .object({
+            clientId: z.string().trim().optional(),
+            clientSecret: z.string().trim().optional(),
+            storedClientId: z.string().optional(),
+            storedClientSecret: z.string().optional(),
+            appBaseUrl: z.string().optional(),
+            redirectUri: z.string().optional(),
+            allowedOrigins: z.array(z.string()).optional(),
+            usesPkce: z.literal(true).optional(),
+            requiresServerClientSecret: z.literal(false).optional(),
+            oauthClientType: z.literal("desktop_app").optional(),
+            authMode: z.literal("localhost_pkce").optional(),
+            isConfigured: z.boolean().optional(),
+            isReadyForPairing: z.boolean().optional(),
+            isLocalOnly: z.literal(true).optional(),
+            runtimeOrigin: z.string().optional(),
+            setupMessage: z.string().optional()
+        })
+            .optional(),
+        microsoft: z
+            .object({
+            clientId: z.string().trim(),
+            tenantId: z.string().trim(),
+            redirectUri: z.string().trim()
+        })
+            .optional()
+    })
+        .optional()
+        .superRefine((value, context) => {
+        const google = value?.google;
+        if (!google) {
+            return;
+        }
+        const hasClientIdField = google.clientId !== undefined;
+        const hasClientSecretField = google.clientSecret !== undefined;
+        const hasClientIdValue = (google.clientId?.length ?? 0) > 0;
+        const hasClientSecretValue = (google.clientSecret?.length ?? 0) > 0;
+        if (hasClientIdField !== hasClientSecretField) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdField ? "clientSecret" : "clientId"],
+                message: "Provide both the Google client ID and client secret together, or clear both together."
+            });
+            return;
+        }
+        if (hasClientIdValue !== hasClientSecretValue) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdValue ? "clientSecret" : "clientId"],
+                message: "Provide both the Google client ID and client secret together, or clear both together."
+            });
+        }
+    }),
+    modelSettings: z
+        .object({
+        forgeAgent: z
+            .object({
+            basicChat: z
+                .object({
+                connectionId: z.string().trim().nullable().optional(),
+                model: z.string().trim().optional()
+            })
+                .optional(),
+            wiki: z
+                .object({
+                connectionId: z.string().trim().nullable().optional(),
+                model: z.string().trim().optional()
+            })
+                .optional()
+        })
+            .optional()
+    })
+        .optional()
+});
+export const createAgentTokenSchema = z.object({
+    label: z.string().trim().min(1, "Label is required"),
+    agentLabel: z.string().trim().min(1, "Agent name is required"),
+    agentType: z.string().trim().min(1, "Agent type is required"),
+    description: z.string().trim(),
+    trustLevel: z.enum(["standard", "trusted", "autonomous"]),
+    autonomyMode: z.enum(["approval_required", "scoped_write", "autonomous"]),
+    approvalMode: z.enum(["approval_by_default", "high_impact_only", "none"]),
+    scopes: z.array(z.string().trim().min(1)).min(1)
+});
+export const createInsightSchema = z.object({
+    originType: z.enum(["system", "user", "agent"]),
+    originAgentId: z.string().trim(),
+    originLabel: z.string().trim(),
+    entityType: z.string().trim(),
+    entityId: z.string().trim(),
+    timeframeLabel: z.string().trim(),
+    title: z.string().trim().min(1, "Title is required"),
+    summary: z.string().trim().min(1, "Summary is required"),
+    recommendation: z.string().trim().min(1, "Recommendation is required"),
+    rationale: z.string().trim(),
+    confidence: z.coerce.number().min(0).max(1),
+    ctaLabel: z.string().trim().min(1, "CTA label is required")
+});
+export const quickTaskSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    owner: z.string().trim().min(1, "Owner is required"),
+    userId: z.string().trim().nullable().optional(),
+    goalId: z.string().trim(),
+    projectId: z.string().trim().min(1, "Project is required"),
+    priority: z.enum(["low", "medium", "high", "critical"]),
+    status: z.enum(["backlog", "focus", "in_progress", "blocked", "done"]),
+    effort: z.enum(["light", "deep", "marathon"]),
+    energy: z.enum(["low", "steady", "high"]),
+    dueDate: z.string().trim(),
+    points: z.coerce.number().int().min(5).max(500),
+    plannedDurationSeconds: z.coerce.number().int().min(60).max(7 * 86_400).nullable().optional(),
+    actionCostBand: z
+        .enum(["tiny", "light", "standard", "heavy", "brutal"])
+        .optional(),
+    tagIds: z.array(z.string()),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const habitMutationSchema = z
+    .object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    status: z.enum(["active", "paused", "archived"]),
+    userId: z.string().trim().nullable().optional(),
+    polarity: z.enum(["positive", "negative"]),
+    frequency: z.enum(["daily", "weekly"]),
+    targetCount: z.coerce.number().int().min(1).max(14),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7),
+    linkedGoalIds: z.array(z.string().trim().min(1)),
+    linkedProjectIds: z.array(z.string().trim().min(1)),
+    linkedTaskIds: z.array(z.string().trim().min(1)),
+    linkedValueIds: z.array(z.string().trim().min(1)),
+    linkedPatternIds: z.array(z.string().trim().min(1)),
+    linkedBehaviorIds: z.array(z.string().trim().min(1)),
+    linkedBeliefIds: z.array(z.string().trim().min(1)),
+    linkedModeIds: z.array(z.string().trim().min(1)),
+    linkedReportIds: z.array(z.string().trim().min(1)),
+    linkedBehaviorId: z.string().trim(),
+    rewardXp: z.coerce.number().int().min(1).max(100),
+    penaltyXp: z.coerce.number().int().min(1).max(100),
+    generatedHealthEventTemplate: z.object({
+        enabled: z.boolean(),
+        workoutType: z.string().trim(),
+        title: z.string().trim(),
+        durationMinutes: z.coerce.number().int().min(1).max(24 * 60),
+        xpReward: z.coerce.number().int().min(0).max(500),
+        tags: z.array(z.string().trim()),
+        links: z.array(z.object({
+            entityType: z.string().trim().min(1),
+            entityId: z.string().trim().min(1),
+            relationshipType: z.string().trim().default("context")
+        })),
+        notesTemplate: z.string().trim()
+    })
+})
+    .superRefine((value, context) => {
+    if (value.frequency === "weekly" && value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Pick at least one weekday"
+        });
+    }
+});
+export const workAdjustmentMutationSchema = z.object({
+    entityType: z.enum(["task", "project"]),
+    entityId: z.string().trim().min(1, "A target is required"),
+    deltaMinutes: z.coerce
+        .number()
+        .int()
+        .refine((value) => value !== 0, "Minutes must not be zero"),
+    note: z.string().trim()
+});
+export const tagMutationSchema = z.object({
+    name: z.string().trim().min(1, "Name is required"),
+    kind: z.enum(["value", "category", "execution"]),
+    userId: z.string().trim().nullable().optional(),
+    color: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Color must be a valid hex value"),
+    description: z.string().trim()
+});

package/dist/server/src/lib/snapshot-normalizer.js

@@ -0,0 +1,416 @@
+const EMPTY_CALENDAR_RULES = {
+    allowWorkBlockKinds: [],
+    blockWorkBlockKinds: [],
+    allowCalendarIds: [],
+    blockCalendarIds: [],
+    allowEventTypes: [],
+    blockEventTypes: [],
+    allowEventKeywords: [],
+    blockEventKeywords: [],
+    allowAvailability: [],
+    blockAvailability: []
+};
+function normalizeTask(task) {
+    return {
+        id: task?.id ?? "",
+        title: task?.title ?? "",
+        description: task?.description ?? "",
+        status: task?.status ?? "backlog",
+        priority: task?.priority ?? "medium",
+        owner: task?.owner ?? "Albert",
+        goalId: task?.goalId ?? null,
+        projectId: task?.projectId ?? null,
+        dueDate: task?.dueDate ?? null,
+        effort: task?.effort ?? "deep",
+        energy: task?.energy ?? "steady",
+        points: task?.points ?? 0,
+        plannedDurationSeconds: task?.plannedDurationSeconds ?? null,
+        schedulingRules: task?.schedulingRules ?? null,
+        sortOrder: task?.sortOrder ?? 0,
+        resolutionKind: task?.resolutionKind ?? null,
+        splitParentTaskId: task?.splitParentTaskId ?? null,
+        completedAt: task?.completedAt ?? null,
+        createdAt: task?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: task?.updatedAt ?? new Date(0).toISOString(),
+        tagIds: task?.tagIds ?? [],
+        userId: task?.userId ?? null,
+        user: task?.user ?? null,
+        time: task?.time ?? {
+            totalTrackedSeconds: 0,
+            totalCreditedSeconds: 0,
+            liveTrackedSeconds: 0,
+            liveCreditedSeconds: 0,
+            manualAdjustedSeconds: 0,
+            activeRunCount: 0,
+            hasCurrentRun: false,
+            currentRunId: null
+        },
+        actionPointSummary: task?.actionPointSummary ?? {
+            costBand: "standard",
+            totalCostAp: 100,
+            expectedDurationSeconds: 86_400,
+            sustainRateApPerHour: 100 / 24,
+            spentTodayAp: 0,
+            spentTotalAp: 0,
+            remainingAp: 100
+        },
+        splitSuggestion: task?.splitSuggestion ?? {
+            shouldSplit: false,
+            reason: null,
+            thresholdSeconds: 2 * 86_400
+        }
+    };
+}
+function normalizeGoal(goal) {
+    return {
+        id: goal?.id ?? "",
+        title: goal?.title ?? "",
+        description: goal?.description ?? "",
+        horizon: goal?.horizon === "quarter" || goal?.horizon === "lifetime"
+            ? goal.horizon
+            : "year",
+        status: goal?.status === "paused" || goal?.status === "completed"
+            ? goal.status
+            : "active",
+        targetPoints: goal?.targetPoints ?? 0,
+        themeColor: goal?.themeColor ?? "#c8a46b",
+        createdAt: goal?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: goal?.updatedAt ?? new Date(0).toISOString(),
+        tagIds: goal?.tagIds ?? [],
+        userId: goal?.userId ?? null,
+        user: goal?.user ?? null
+    };
+}
+function normalizeTag(tag) {
+    return {
+        id: tag?.id ?? "",
+        name: tag?.name ?? "",
+        kind: tag?.kind === "value" || tag?.kind === "execution"
+            ? tag.kind
+            : "category",
+        color: tag?.color ?? "#71717a",
+        description: tag?.description ?? "",
+        userId: tag?.userId ?? null,
+        user: tag?.user ?? null
+    };
+}
+function normalizeProject(project) {
+    return {
+        id: project?.id ?? "",
+        goalId: project?.goalId ?? "",
+        title: project?.title ?? "",
+        description: project?.description ?? project?.summary ?? "",
+        status: project?.status === "paused" || project?.status === "completed"
+            ? project.status
+            : "active",
+        targetPoints: project?.targetPoints ?? project?.totalPoints ?? 0,
+        themeColor: project?.themeColor ?? "#c0c1ff",
+        schedulingRules: project?.schedulingRules ?? EMPTY_CALENDAR_RULES,
+        createdAt: project?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: project?.updatedAt ?? new Date(0).toISOString(),
+        goalTitle: project?.goalTitle ?? "",
+        activeTaskCount: project?.activeTaskCount ?? 0,
+        completedTaskCount: project?.completedTaskCount ?? 0,
+        totalTasks: project?.totalTasks ?? 0,
+        earnedPoints: project?.earnedPoints ?? project?.totalPoints ?? 0,
+        progress: project?.progress ?? 0,
+        nextTaskId: project?.nextTaskId ?? null,
+        nextTaskTitle: project?.nextTaskTitle ?? null,
+        momentumLabel: project?.momentumLabel ?? "No momentum yet",
+        userId: project?.userId ?? null,
+        user: project?.user ?? null,
+        time: project?.time ?? {
+            totalTrackedSeconds: 0,
+            totalCreditedSeconds: 0,
+            liveTrackedSeconds: 0,
+            liveCreditedSeconds: 0,
+            manualAdjustedSeconds: 0,
+            activeRunCount: 0,
+            hasCurrentRun: false,
+            currentRunId: null
+        }
+    };
+}
+function normalizeHabit(habit) {
+    return {
+        id: habit?.id ?? "",
+        title: habit?.title ?? "",
+        description: habit?.description ?? "",
+        status: habit?.status ?? "active",
+        polarity: habit?.polarity ?? "positive",
+        frequency: habit?.frequency ?? "daily",
+        targetCount: habit?.targetCount ?? 1,
+        weekDays: habit?.weekDays ?? [],
+        linkedGoalIds: habit?.linkedGoalIds ?? [],
+        linkedProjectIds: habit?.linkedProjectIds ?? [],
+        linkedTaskIds: habit?.linkedTaskIds ?? [],
+        linkedValueIds: habit?.linkedValueIds ?? [],
+        linkedPatternIds: habit?.linkedPatternIds ?? [],
+        linkedBehaviorIds: habit?.linkedBehaviorIds ?? [],
+        linkedBeliefIds: habit?.linkedBeliefIds ?? [],
+        linkedModeIds: habit?.linkedModeIds ?? [],
+        linkedReportIds: habit?.linkedReportIds ?? [],
+        linkedBehaviorId: habit?.linkedBehaviorId ?? null,
+        linkedBehaviorTitle: habit?.linkedBehaviorTitle ?? null,
+        linkedBehaviorTitles: habit?.linkedBehaviorTitles ?? [],
+        rewardXp: habit?.rewardXp ?? 12,
+        penaltyXp: habit?.penaltyXp ?? 8,
+        generatedHealthEventTemplate: habit?.generatedHealthEventTemplate ?? {
+            enabled: false,
+            workoutType: "",
+            title: "",
+            durationMinutes: 60,
+            xpReward: 0,
+            tags: [],
+            links: [],
+            notesTemplate: ""
+        },
+        createdAt: habit?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: habit?.updatedAt ?? new Date(0).toISOString(),
+        lastCheckInAt: habit?.lastCheckInAt ?? null,
+        lastCheckInStatus: habit?.lastCheckInStatus ?? null,
+        streakCount: habit?.streakCount ?? 0,
+        completionRate: habit?.completionRate ?? 0,
+        dueToday: habit?.dueToday ?? false,
+        userId: habit?.userId ?? null,
+        user: habit?.user ?? null,
+        checkIns: habit?.checkIns ?? []
+    };
+}
+function normalizeUser(user) {
+    return {
+        id: user?.id ?? "",
+        kind: user?.kind ?? "human",
+        handle: user?.handle ?? "",
+        displayName: user?.displayName ?? "",
+        description: user?.description ?? "",
+        accentColor: user?.accentColor ?? "#c0c1ff",
+        createdAt: user?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: user?.updatedAt ?? new Date(0).toISOString()
+    };
+}
+function normalizeStrategy(strategy) {
+    return {
+        id: strategy?.id ?? "",
+        title: strategy?.title ?? "",
+        overview: strategy?.overview ?? "",
+        endStateDescription: strategy?.endStateDescription ?? "",
+        status: strategy?.status === "paused" || strategy?.status === "completed"
+            ? strategy.status
+            : "active",
+        targetGoalIds: strategy?.targetGoalIds ?? [],
+        targetProjectIds: strategy?.targetProjectIds ?? [],
+        linkedEntities: strategy?.linkedEntities ?? [],
+        graph: strategy?.graph ?? { nodes: [], edges: [] },
+        metrics: strategy?.metrics ?? {
+            alignmentScore: 0,
+            planCoverageScore: 0,
+            sequencingScore: 100,
+            scopeDisciplineScore: 100,
+            qualityScore: 0,
+            targetProgressScore: 0,
+            completedNodeCount: 0,
+            startedNodeCount: 0,
+            readyNodeCount: 0,
+            totalNodeCount: 1,
+            completedTargetCount: 0,
+            totalTargetCount: 0,
+            offPlanEntityCount: 0,
+            offPlanActiveEntityCount: 0,
+            offPlanCompletedEntityCount: 0,
+            activeNodeIds: [],
+            nextNodeIds: [],
+            blockedNodeIds: [],
+            outOfOrderNodeIds: []
+        },
+        isLocked: strategy?.isLocked ?? false,
+        lockedAt: strategy?.lockedAt ?? null,
+        lockedByUserId: strategy?.lockedByUserId ?? null,
+        lockedByUser: strategy?.lockedByUser ?? null,
+        createdAt: strategy?.createdAt ?? new Date(0).toISOString(),
+        updatedAt: strategy?.updatedAt ?? new Date(0).toISOString(),
+        userId: strategy?.userId ?? null,
+        user: strategy?.user ?? null
+    };
+}
+export function normalizeForgeSnapshot(raw) {
+    const legacy = raw;
+    const rootProjects = (legacy.projects ?? legacy.campaigns ?? []).map(normalizeProject);
+    const dashboardProjects = (legacy.dashboard?.projects ??
+        legacy.dashboard?.campaigns ??
+        rootProjects).map(normalizeProject);
+    const overviewProjects = (legacy.overview?.projects ??
+        legacy.overview?.campaigns ??
+        dashboardProjects).map(normalizeProject);
+    return {
+        ...raw,
+        meta: {
+            apiVersion: "v1",
+            transport: "rest+sse",
+            generatedAt: raw.meta?.generatedAt ?? new Date().toISOString(),
+            backend: raw.meta?.backend ?? "forge-node-runtime",
+            mode: raw.meta?.mode ?? "transitional-node"
+        },
+        metrics: {
+            totalXp: raw.metrics?.totalXp ?? 0,
+            level: raw.metrics?.level ?? 1,
+            currentLevelXp: raw.metrics?.currentLevelXp ?? 0,
+            nextLevelXp: raw.metrics?.nextLevelXp ?? 120,
+            weeklyXp: raw.metrics?.weeklyXp ?? 0,
+            streakDays: raw.metrics?.streakDays ?? 0,
+            comboMultiplier: raw.metrics?.comboMultiplier ?? 1,
+            momentumScore: raw.metrics?.momentumScore ?? 0,
+            topGoalId: raw.metrics?.topGoalId ?? null,
+            topGoalTitle: raw.metrics?.topGoalTitle ?? null
+        },
+        users: (raw.users ?? []).map(normalizeUser),
+        strategies: (raw.strategies ?? []).map(normalizeStrategy),
+        userScope: {
+            selectedUserIds: raw.userScope?.selectedUserIds ?? [],
+            selectedUsers: (raw.userScope?.selectedUsers ?? []).map(normalizeUser)
+        },
+        dashboard: {
+            stats: {
+                totalPoints: raw.dashboard?.stats?.totalPoints ?? 0,
+                completedThisWeek: raw.dashboard?.stats?.completedThisWeek ?? 0,
+                activeGoals: raw.dashboard?.stats?.activeGoals ?? 0,
+                alignmentScore: raw.dashboard?.stats?.alignmentScore ?? 0,
+                focusTasks: raw.dashboard?.stats?.focusTasks ?? 0,
+                overdueTasks: raw.dashboard?.stats?.overdueTasks ?? 0,
+                dueThisWeek: raw.dashboard?.stats?.dueThisWeek ?? 0
+            },
+            goals: (raw.dashboard?.goals ?? []).map((goal) => ({
+                ...goal,
+                ...normalizeGoal(goal)
+            })),
+            projects: dashboardProjects,
+            tasks: (raw.dashboard?.tasks ?? []).map(normalizeTask),
+            habits: (raw.dashboard?.habits ?? raw.habits ?? []).map(normalizeHabit),
+            tags: (raw.dashboard?.tags ?? []).map(normalizeTag),
+            suggestedTags: (raw.dashboard?.suggestedTags ?? []).map(normalizeTag),
+            owners: raw.dashboard?.owners ?? [],
+            executionBuckets: (raw.dashboard?.executionBuckets ?? []).map((bucket) => ({
+                ...bucket,
+                tasks: (bucket.tasks ?? []).map(normalizeTask)
+            })),
+            gamification: raw.dashboard?.gamification ?? {
+                totalXp: raw.metrics?.totalXp ?? 0,
+                level: raw.metrics?.level ?? 1,
+                currentLevelXp: raw.metrics?.currentLevelXp ?? 0,
+                nextLevelXp: raw.metrics?.nextLevelXp ?? 120,
+                weeklyXp: raw.metrics?.weeklyXp ?? 0,
+                streakDays: raw.metrics?.streakDays ?? 0,
+                comboMultiplier: raw.metrics?.comboMultiplier ?? 1,
+                momentumScore: raw.metrics?.momentumScore ?? 0,
+                topGoalId: raw.metrics?.topGoalId ?? null,
+                topGoalTitle: raw.metrics?.topGoalTitle ?? null
+            },
+            achievements: raw.dashboard?.achievements ?? [],
+            milestoneRewards: raw.dashboard?.milestoneRewards ?? [],
+            recentActivity: raw.dashboard?.recentActivity ?? [],
+            notesSummaryByEntity: raw.dashboard?.notesSummaryByEntity ?? {}
+        },
+        overview: {
+            generatedAt: raw.overview?.generatedAt ?? new Date().toISOString(),
+            strategicHeader: {
+                streakDays: raw.overview?.strategicHeader?.streakDays ??
+                    raw.metrics?.streakDays ??
+                    0,
+                level: raw.overview?.strategicHeader?.level ?? raw.metrics?.level ?? 1,
+                totalXp: raw.overview?.strategicHeader?.totalXp ?? raw.metrics?.totalXp ?? 0,
+                currentLevelXp: raw.overview?.strategicHeader?.currentLevelXp ??
+                    raw.metrics?.currentLevelXp ??
+                    0,
+                nextLevelXp: raw.overview?.strategicHeader?.nextLevelXp ??
+                    raw.metrics?.nextLevelXp ??
+                    120,
+                momentumScore: raw.overview?.strategicHeader?.momentumScore ??
+                    raw.metrics?.momentumScore ??
+                    0,
+                focusTasks: raw.overview?.strategicHeader?.focusTasks ?? 0,
+                overdueTasks: raw.overview?.strategicHeader?.overdueTasks ?? 0
+            },
+            projects: overviewProjects,
+            activeGoals: (raw.overview?.activeGoals ?? []).map((goal) => ({
+                ...goal,
+                ...normalizeGoal(goal)
+            })),
+            topTasks: (raw.overview?.topTasks ?? []).map(normalizeTask),
+            dueHabits: (raw.overview?.dueHabits ??
+                raw.today?.dueHabits ??
+                raw.dashboard?.habits ??
+                []).map(normalizeHabit),
+            recentEvidence: raw.overview?.recentEvidence ?? [],
+            achievements: raw.overview?.achievements ?? [],
+            domainBalance: raw.overview?.domainBalance ?? [],
+            neglectedGoals: raw.overview?.neglectedGoals ?? []
+        },
+        today: {
+            generatedAt: raw.today?.generatedAt ?? new Date().toISOString(),
+            directive: {
+                task: raw.today?.directive?.task
+                    ? normalizeTask(raw.today.directive.task)
+                    : null,
+                goalTitle: raw.today?.directive?.goalTitle ?? null,
+                rewardXp: raw.today?.directive?.rewardXp ?? 0,
+                sessionLabel: raw.today?.directive?.sessionLabel ?? "No active session"
+            },
+            timeline: (raw.today?.timeline ?? []).map((bucket) => ({
+                ...bucket,
+                tasks: (bucket.tasks ?? []).map(normalizeTask)
+            })),
+            dueHabits: (raw.today?.dueHabits ??
+                raw.overview?.dueHabits ??
+                raw.dashboard?.habits ??
+                []).map(normalizeHabit),
+            dailyQuests: raw.today?.dailyQuests ?? [],
+            milestoneRewards: raw.today?.milestoneRewards ?? [],
+            recentHabitRewards: raw.today?.recentHabitRewards ?? [],
+            momentum: {
+                streakDays: raw.today?.momentum?.streakDays ?? 0,
+                momentumScore: raw.today?.momentum?.momentumScore ?? 0,
+                recoveryHint: raw.today?.momentum?.recoveryHint ?? ""
+            }
+        },
+        risk: {
+            generatedAt: raw.risk?.generatedAt ?? new Date().toISOString(),
+            overdueTasks: (raw.risk?.overdueTasks ?? []).map(normalizeTask),
+            blockedTasks: (raw.risk?.blockedTasks ?? []).map(normalizeTask),
+            neglectedGoals: raw.risk?.neglectedGoals ?? [],
+            summary: raw.risk?.summary ?? ""
+        },
+        goals: (raw.goals ?? []).map(normalizeGoal),
+        projects: rootProjects,
+        tags: (raw.tags ?? []).map(normalizeTag),
+        tasks: (raw.tasks ?? []).map(normalizeTask),
+        habits: (raw.habits ?? raw.dashboard?.habits ?? []).map(normalizeHabit),
+        activity: raw.activity ?? [],
+        activeTaskRuns: raw.activeTaskRuns ?? [],
+        lifeForce: raw.lifeForce ?? {
+            userId: "",
+            dateKey: new Date().toISOString().slice(0, 10),
+            baselineDailyAp: 200,
+            dailyBudgetAp: 200,
+            spentTodayAp: 0,
+            remainingAp: 200,
+            forecastAp: 0,
+            targetBandMinAp: 170,
+            targetBandMaxAp: 200,
+            instantCapacityApPerHour: 0,
+            instantFreeApPerHour: 0,
+            overloadApPerHour: 0,
+            currentDrainApPerHour: 0,
+            fatigueBufferApPerHour: 0,
+            sleepRecoveryMultiplier: 1,
+            readinessMultiplier: 1,
+            fatigueDebtCarry: 0,
+            stats: [],
+            currentCurve: [],
+            activeDrains: [],
+            warnings: [],
+            recommendations: [],
+            topTaskIdsNeedingSplit: [],
+            updatedAt: new Date(0).toISOString()
+        }
+    };
+}