GP-142 GP-143 GP-144: Harden training plan guardrails

apps/mobile/components/plan/training-path/usePlanTrainingPathData.ts

@@ -1,3 +1,4 @@
+import { resolveTrainingPlanProjectionWindow } from "@repo/core";
 import { startTransition, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { api } from "@/lib/api";
 import { scheduleAwareReadQueryOptions } from "@/lib/api/scheduleQueryOptions";
@@ -68,16 +69,12 @@ export function usePlanTrainingPathData() {
   const { data: activePlan, refetch: refetchActivePlan } = activePlanQuery;
   const today = useMemo(() => new Date(), []);
   const todayKey = useMemo(() => getDateKey(today), [today]);
-  const recentWindowStart = useMemo(() => {
-    const start = new Date(today);
-    start.setDate(start.getDate() - 45);
-    return getDateKey(start);
-  }, [today]);
-  const upcomingWindowEnd = useMemo(() => {
-    const end = new Date(today);
-    end.setDate(end.getDate() + 365);
-    return getDateKey(end);
-  }, [today]);
+  const projectionWindow = useMemo(
+    () => resolveTrainingPlanProjectionWindow({ anchorDate: todayKey }),
+    [todayKey],
+  );
+  const recentWindowStart = projectionWindow.startDate;
+  const upcomingWindowEnd = projectionWindow.endDate;
 
   const upcomingPlannedEventsQuery = api.events.list.useQuery(
     {

apps/mobile/lib/training-plan-creation/backend-planning/preview-input.ts

@@ -21,10 +21,13 @@ export { createPlanningContextFingerprint, mapPlanningContextToPreviewCreationCo
 
 export function getBackendPlanningClientStatus(): BackendPlanningClientStatus {
   return {
-    available: false,
-    enabledOperations: [],
-    reason:
-      "Backend planning adapter scaffolded; local projection remains authoritative for this pass.",
+    available: true,
+    enabledOperations: [
+      "previewCreationConfig",
+      "createFromCreationConfig",
+      "updateFromCreationConfig",
+    ],
+    reason: "Backend planning preview and commit routes are available when input mapping succeeds.",
   };
 }
 
@@ -46,10 +49,13 @@ export function deriveBackendPlanningState(
   return {
     status: previewMapping.ok
       ? {
-          available: false,
-          enabledOperations: [],
-          reason:
-            "Backend planning input is mapped; network preview remains disabled for this pass.",
+          available: true,
+          enabledOperations: [
+            "previewCreationConfig",
+            "createFromCreationConfig",
+            "updateFromCreationConfig",
+          ],
+          reason: "Backend planning input is mapped and ready for authoritative preview.",
         }
       : {
           available: false,

apps/mobile/lib/training-plan-creation/training-plan-creation.test.ts

@@ -301,6 +301,28 @@ describe("training plan creation domain", () => {
     });
   });
 
+  it("uses core readiness blockers for incompatible planning preferences", () => {
+    const fixtures = createTrainingPlanBuilderFixtures();
+    const state = {
+      ...fixtures.readyState,
+      planPreferences: {
+        durationWeeks: 4,
+        weeklySessionCount: 6,
+        targetWeeklyHours: null,
+        restDaysPerWeek: 2,
+      },
+    };
+
+    expect(selectSaveReadiness(state).blockers).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "weekly_session_rest_day_conflict",
+          target: { type: "assumptions" },
+        }),
+      ]),
+    );
+  });
+
   it("derives local schedule preview dates and conflict checks without persisting calendar fields", () => {
     const state = {
       ...createDefaultTrainingPlanBuilderState(),
@@ -660,10 +682,14 @@ describe("training plan creation domain", () => {
     const context = createTrainingPlanPlanningContext(fixtures.readyState);
 
     expect(getBackendPlanningClientStatus()).toEqual({
-      available: false,
-      enabledOperations: [],
+      available: true,
+      enabledOperations: [
+        "previewCreationConfig",
+        "createFromCreationConfig",
+        "updateFromCreationConfig",
+      ],
       reason:
-        "Backend planning adapter scaffolded; local projection remains authoritative for this pass.",
+        "Backend planning preview and commit routes are available when input mapping succeeds.",
     });
     expect(getPlannedBackendPlanningOperations()).toEqual([
       "getCreationSuggestions",
@@ -715,8 +741,17 @@ describe("training plan creation domain", () => {
     const context = createTrainingPlanPlanningContext(state);
 
     const result = mapPlanningContextToPreviewCreationConfigInput(context);
+    const backendState = deriveBackendPlanningState(context);
 
     expect(result).toMatchObject({ ok: true });
+    expect(backendState.status).toMatchObject({
+      available: true,
+      enabledOperations: [
+        "previewCreationConfig",
+        "createFromCreationConfig",
+        "updateFromCreationConfig",
+      ],
+    });
     if (!result.ok) throw new Error(result.reason);
     expect(result.input.minimal_plan).toMatchObject({
       plan_start_date: state.scheduling.startDate,

apps/mobile/lib/training-plan-creation/types.ts

@@ -93,6 +93,8 @@ export type TrainingPlanBuilderSaveBlockerCode =
   | "unpublished_activity_plan"
   | "invalid_start_time"
   | "duplicate_session"
+  | "weekly_session_rest_day_conflict"
+  | "weekly_hours_session_mismatch"
   | "canonical_schema_failure";
 
 export type TrainingPlanBuilderSaveBlocker = {

apps/mobile/lib/training-plan-creation/useTrainingPlanCreationService.ts

@@ -294,6 +294,7 @@ export function useTrainingPlanCreationService({
     500,
   );
   const backendPreviewInput =
+    localProjection.backendPlanning.status.available &&
     debouncedBackendPlanningFingerprint === localProjection.backendPlanning.contextFingerprint
       ? localProjection.backendPlanning.previewInput
       : null;
@@ -316,14 +317,16 @@ export function useTrainingPlanCreationService({
     () =>
       selectActiveTrainingPlanProjection({
         backendPreview: authoritativeProjection,
-        backendPreviewEnabled: backendPreviewInput !== null,
+        backendPreviewEnabled:
+          localProjection.backendPlanning.status.available && backendPreviewInput !== null,
         isBackendInputStale: isBackendPlanningInputStale,
         localChart: localProjection.builderViewModel.dailyTrainingPathChart,
       }),
     [
       authoritativeProjection,
       backendPreviewInput,
       isBackendPlanningInputStale,
+      localProjection.backendPlanning.status.available,
       localProjection.builderViewModel.dailyTrainingPathChart,
     ],
   );
@@ -573,7 +576,7 @@ export function useTrainingPlanCreationService({
       backendPlanningPreview: {
         data: backendPlanningPreviewQuery.data,
         error: backendPlanningPreviewQuery.error,
-        isEnabled: backendPreviewInput !== null,
+        isEnabled: localProjection.backendPlanning.status.available && backendPreviewInput !== null,
         isFetching: backendPlanningPreviewQuery.isFetching,
         isLoading: backendPlanningPreviewQuery.isLoading,
         isStaleInput: isBackendPlanningInputStale,

apps/mobile/lib/training-plan-creation/validation.ts

@@ -1,4 +1,4 @@
-import { isValidDateOnlyUtc, validateTrainingPlanCreationInput } from "@repo/core";
+import { evaluateTrainingPlanCreationReadiness, isValidDateOnlyUtc } from "@repo/core";
 import { ZodError } from "zod";
 import { toTrainingPlanStructure } from "./mappers";
 import { trainingPlanBuilderPlanPreferencesSchema } from "./schemas";
@@ -34,14 +34,15 @@ export function validateTrainingPlanBuilderState(
   const planPreferenceResult = trainingPlanBuilderPlanPreferencesSchema.safeParse(
     state.planPreferences,
   );
-  const blockers: TrainingPlanBuilderSaveBlocker[] = validateTrainingPlanCreationInput({
+  const readiness = evaluateTrainingPlanCreationReadiness({
     name: state.details.name,
     anchorDateValid: isValidDateOnlyUtc(state.anchorDate),
     profileBirthDateValid: true,
     planPreferencesValid: planPreferenceResult.success,
     planPreferencesMessage: planPreferenceResult.success
       ? undefined
       : planPreferenceResult.error.issues[0]?.message,
+    preferences: state.planPreferences,
     sessions: state.structure.sessions.map((session) => ({
       localId: session.localId,
       offsetDays: session.offsetDays,
@@ -61,7 +62,8 @@ export function validateTrainingPlanBuilderState(
       targetDateValid: goal.targetDate ? isValidDateOnlyUtc(goal.targetDate) : true,
       targetOffsetDays: goal.targetOffsetDays,
     })),
-  }).map((issue) =>
+  });
+  const blockers: TrainingPlanBuilderSaveBlocker[] = readiness.blockers.map((issue) =>
     createBlocker({
       code: issue.code,
       message: issue.message,

apps/mobile/lib/training-plan-form/projectionPreview.ts

@@ -1,6 +1,10 @@
 import { canonicalizeMinimalTrainingPlanCreate } from "@repo/core/plan/canonicalization";
 import type { ProjectionChartPayload } from "@repo/core/plan/projectionTypes";
 import { withLegacyTrainingLoadAliases } from "@repo/core/plan/trainingLoadTimeline";
+import {
+  filterDateKeyedItemsToProjectionWindow,
+  resolveTrainingPlanProjectionWindow,
+} from "@repo/core/plan/trainingPlanProjectionBudgets";
 import {
   type AthleteTrainingSettings,
   type AthleteTrainingSettingsFormInput,
@@ -78,6 +82,7 @@ function toGoalTargets(goal: TrainingPlanSnapshot["profileGoals"][number]): Goal
         case "hr":
           return [{ target_type: "hr_threshold", target_lthr_bpm: objective.value }];
       }
+      return [];
     }
     default:
       return [];
@@ -188,21 +193,35 @@ export function buildTrainingPreferencesLoadTimeline(input: {
   scheduledWindowStart?: string | null;
   scheduledWindowEnd?: string | null;
 }) {
+  const todayKey = toDateKey(new Date());
+  const projectionWindow = resolveTrainingPlanProjectionWindow({
+    anchorDate: todayKey,
+    requestedStartDate: input.scheduledWindowStart,
+    requestedEndDate: input.scheduledWindowEnd,
+  });
   const baselineTimeline = input.snapshot.insightTimeline?.timeline ?? [];
   const baselineByDate = new Map(baselineTimeline.map((point) => [point.date, point]));
   const previewByDate = new Map(
     (input.projectionChart?.display_points ?? []).map((point) => [point.date, point]),
   );
-  const dateSource = baselineTimeline.length > 0 ? baselineTimeline : [...previewByDate.values()];
-  const dates = new Set(dateSource.map((point) => point.date));
+  const dateSource: Array<{ date: string }> =
+    baselineTimeline.length > 0 ? baselineTimeline : [...previewByDate.values()];
+  const dates = new Set(
+    filterDateKeyedItemsToProjectionWindow(dateSource, {
+      window: projectionWindow,
+      getDate: (point) => point.date,
+    }).map((point) => point.date),
+  );
   const scheduledLoadAggregation = aggregateScheduledLoadByDate(input);
-  for (const date of scheduledLoadAggregation.dates) dates.add(date);
+  for (const date of scheduledLoadAggregation.dates) {
+    if (date >= projectionWindow.startDate && date <= projectionWindow.endDate) dates.add(date);
+  }
 
   const hasCalendarScheduleForDate = (date: string) =>
     !!input.scheduledWindowStart &&
     !!input.scheduledWindowEnd &&
-    date >= input.scheduledWindowStart &&
-    date <= input.scheduledWindowEnd;
+    date >= projectionWindow.startDate &&
+    date <= projectionWindow.endDate;
 
   return [...dates]
     .sort((left, right) => left.localeCompare(right))

packages/core/plan/index.ts

@@ -61,6 +61,7 @@ export * from "./trainingLoadTimeline";
 export * from "./trainingPlanCreationPreview";
 export * from "./trainingPlanCreationValidation";
 export * from "./trainingPlanPreview";
+export * from "./trainingPlanProjectionBudgets";
 export * from "./trainingPlanSchedulingPreview";
 export * from "./trainingPlanStructureProposal";
 export * from "./trainingSettingsDefaults";

packages/core/plan/trainingPlanCreationValidation.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+import {
+  evaluateTrainingPlanCreationReadiness,
+  validateTrainingPlanCreationInput,
+} from "./trainingPlanCreationValidation";
+
+const publishedAccessiblePlan = {
+  id: "activity-plan-1",
+  accessible: true,
+  published: true,
+};
+
+describe("trainingPlanCreationValidation", () => {
+  it("returns a deterministic readiness result with blockers and warnings", () => {
+    const readiness = evaluateTrainingPlanCreationReadiness({
+      name: "",
+      anchorDateValid: true,
+      profileBirthDateValid: true,
+      planPreferencesValid: true,
+      preferences: {
+        weeklySessionCount: 6,
+        targetWeeklyHours: 1,
+        restDaysPerWeek: 2,
+      },
+      sessions: [
+        {
+          localId: "session-1",
+          offsetDays: 0,
+          activityPlan: publishedAccessiblePlan,
+          startTime: "09:00",
+        },
+      ],
+      goals: [],
+    });
+
+    expect(readiness.canSave).toBe(false);
+    expect(readiness.blockers.map((issue) => issue.code)).toEqual([
+      "missing_plan_name",
+      "weekly_session_rest_day_conflict",
+    ]);
+    expect(readiness.warnings.map((issue) => issue.code)).toEqual([
+      "weekly_hours_session_mismatch",
+    ]);
+    expect(readiness.issues.every((issue) => issue.severity)).toBe(true);
+  });
+
+  it("keeps the legacy validation helper blocker-only", () => {
+    const issues = validateTrainingPlanCreationInput({
+      name: "Base build",
+      anchorDateValid: true,
+      profileBirthDateValid: true,
+      planPreferencesValid: true,
+      preferences: {
+        weeklySessionCount: 4,
+        targetWeeklyHours: 1,
+        restDaysPerWeek: null,
+      },
+      sessions: [
+        {
+          localId: "session-1",
+          offsetDays: 0,
+          activityPlan: publishedAccessiblePlan,
+        },
+      ],
+      goals: [],
+    });
+
+    expect(issues).toEqual([]);
+  });
+
+  it("allows a complete creation input", () => {
+    const readiness = evaluateTrainingPlanCreationReadiness({
+      name: "Base build",
+      anchorDateValid: true,
+      profileBirthDateValid: true,
+      planPreferencesValid: true,
+      preferences: {
+        weeklySessionCount: 4,
+        targetWeeklyHours: 5,
+        restDaysPerWeek: 2,
+      },
+      sessions: [
+        {
+          localId: "session-1",
+          offsetDays: 0,
+          activityPlan: publishedAccessiblePlan,
+          startTime: "09:00",
+        },
+      ],
+      goals: [{ localId: "goal-1", targetDateValid: true, targetOffsetDays: 28 }],
+    });
+
+    expect(readiness).toMatchObject({ canSave: true, blockers: [], warnings: [] });
+  });
+});