incremnt 0.6.0 → 0.7.0

package/src/queries.js

@@ -1,12 +1,148 @@
 import { coachFactPolicyViolation } from './coach-facts.js';
 import { exerciseAliasMapping } from './exercise-aliases.js';
-import { programPhaseWindowContext, resolveProgramPhase } from './program-phase-resolver.js';
+import { resolveProgramPhase } from './program-phase-resolver.js';
 import { enrichScoreSnapshots } from './score-context.js';
 
 function completionDateForSession(session) {
   return session.completedAt ?? session.summary?.date ?? session.date;
 }
 
+const WEEKDAY_NAMES = ['', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+
+function isoWeekdayOf(date) {
+  const jsDay = date.getDay();
+  return jsDay === 0 ? 7 : jsDay;
+}
+
+function dateOnly(date) {
+  return localDateString(date);
+}
+
+function shiftDate(date, days) {
+  const d = new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+
+/**
+ * Mirror of iOS DashboardSchedulingLogic for AI prompt builders.
+ * Resolves the program's schedule position into one of:
+ *   - 'catchUp'  — currentDayIndex's scheduled weekday already passed this week
+ *                  and that index isn't in completedDayIndices.
+ *   - 'today'    — currentDayIndex's scheduled weekday is today.
+ *   - 'upcoming' — scheduled later this week or next.
+ *
+ * Without this, the naive `(trainingWeekdays[currentDayIndex] - todayIso + 7) % 7`
+ * surfaces a missed Friday session as "Friday (in 6 days)" the morning after.
+ */
+export function resolveProgramSchedule(program, now = new Date()) {
+  if (!program) return null;
+  const trainingWeekdays = program.trainingWeekdays ?? [];
+  const days = program.days ?? [];
+  const dayCount = days.length;
+  if (dayCount === 0) return null;
+
+  const currentDayIndex = program.currentDayIndex ?? 0;
+  if (!Number.isInteger(currentDayIndex) || currentDayIndex < 0 || currentDayIndex >= dayCount) {
+    return null;
+  }
+  const scheduledWeekday = trainingWeekdays[currentDayIndex];
+  if (scheduledWeekday == null) return null;
+
+  const todayIso = isoWeekdayOf(now);
+  const completed = new Set(program.completedDayIndices ?? []);
+  const dayTitle = days[currentDayIndex]?.title ?? `Day ${currentDayIndex + 1}`;
+
+  // Mirror DashboardSchedulingLogic.shouldShowCatchUpWorkout: cycle has started
+  // (some completions exist) and currentDayIndex itself isn't completed.
+  const cycleStarted = completed.size > 0;
+  const currentIncomplete = !completed.has(currentDayIndex);
+  const nextScheduledSession = trainingWeekdays
+    .map((weekday, dayIndex) => ({ weekday, dayIndex }))
+    .filter(({ weekday, dayIndex }) => (
+      dayIndex < dayCount
+      && weekday > todayIso
+      && !completed.has(dayIndex)
+    ))
+    .sort((a, b) => a.weekday - b.weekday)[0] ?? null;
+
+  if (
+    scheduledWeekday < todayIso
+    && cycleStarted
+    && currentIncomplete
+  ) {
+    const daysAgo = todayIso - scheduledWeekday;
+    const resolved = {
+      state: 'catchUp',
+      dayIndex: currentDayIndex,
+      dayTitle,
+      scheduledWeekday,
+      scheduledWeekdayName: WEEKDAY_NAMES[scheduledWeekday],
+      scheduledOn: dateOnly(shiftDate(now, -daysAgo)),
+      daysAgo
+    };
+    if (nextScheduledSession) {
+      const daysUntil = nextScheduledSession.weekday - todayIso;
+      resolved.nextScheduledSession = {
+        state: 'upcoming',
+        dayIndex: nextScheduledSession.dayIndex,
+        dayTitle: days[nextScheduledSession.dayIndex]?.title ?? `Day ${nextScheduledSession.dayIndex + 1}`,
+        scheduledWeekday: nextScheduledSession.weekday,
+        scheduledWeekdayName: WEEKDAY_NAMES[nextScheduledSession.weekday],
+        scheduledOn: dateOnly(shiftDate(now, daysUntil)),
+        daysUntil
+      };
+    }
+    return resolved;
+  }
+
+  let daysUntil = scheduledWeekday - todayIso;
+  if (daysUntil < 0) daysUntil += 7;
+  const state = daysUntil === 0 ? 'today' : 'upcoming';
+  return {
+    state,
+    dayIndex: currentDayIndex,
+    dayTitle,
+    scheduledWeekday,
+    scheduledWeekdayName: WEEKDAY_NAMES[scheduledWeekday],
+    scheduledOn: dateOnly(shiftDate(now, daysUntil)),
+    daysUntil
+  };
+}
+
+function formatScheduleLine(resolved) {
+  if (!resolved) return null;
+  if (resolved.state === 'catchUp') {
+    const next = resolved.nextScheduledSession;
+    const nextLine = next
+      ? ` Next scheduled session: ${next.dayTitle} on ${next.scheduledWeekdayName} (${next.daysUntil === 1 ? 'tomorrow' : `in ${next.daysUntil} days`}).`
+      : '';
+    return `Missed scheduled session: ${resolved.dayTitle} (was ${resolved.scheduledWeekdayName} ${resolved.scheduledOn}, not completed). Available to catch up.${nextLine}`;
+  }
+  if (resolved.state === 'today') {
+    return `Today's scheduled session: ${resolved.dayTitle} (${resolved.scheduledWeekdayName}).`;
+  }
+  const whenLabel = resolved.daysUntil === 1 ? 'tomorrow' : `in ${resolved.daysUntil} days`;
+  return `Next scheduled session: ${resolved.dayTitle} on ${resolved.scheduledWeekdayName} (${whenLabel}).`;
+}
+
+function completedThisCycleLines(program) {
+  if (!program) return [];
+  const completed = Array.from(new Set(program.completedDayIndices ?? []))
+    .filter((idx) => Number.isInteger(idx))
+    .sort((a, b) => a - b);
+  if (completed.length === 0) return [];
+  const days = program.days ?? [];
+  const trainingWeekdays = program.trainingWeekdays ?? [];
+  const parts = completed.map((idx) => {
+    const title = days[idx]?.title ?? `Day ${idx + 1}`;
+    const wd = trainingWeekdays[idx];
+    const wdName = wd != null ? WEEKDAY_NAMES[wd]?.slice(0, 3) : null;
+    return wdName ? `${title} (${wdName})` : title;
+  });
+  return [`Completed this cycle: ${parts.join(', ')}.`];
+}
+
 function normalizedNote(note) {
   if (typeof note !== 'string') return null;
   const trimmed = note.trim();
@@ -1101,38 +1237,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
     return { original, replacement, count };
   });
 
-  let goalProgress = null;
-  const plans = snapshot.strengthPlans ?? [];
-  const activePlan = plans.find(
-    (p) => p.status === 'active' && p.programId === program.id
-  );
-  if (activePlan) {
-    const programExerciseNames = new Set(
-      (program.days ?? [])
-        .flatMap((day) => day.exercises ?? [])
-        .map((exercise) => canonicalExerciseName(exercise.name ?? exercise.exerciseName))
-    );
-    goalProgress = (activePlan.liftGoals ?? [])
-    .filter((g) => {
-      if (programExerciseNames.size === 0) return true;
-      return programExerciseNames.has(canonicalExerciseName(g.exerciseDisplayName));
-    })
-    .map((g) => {
-      const range = g.targetE1RM - g.startingE1RM;
-      const gained = g.currentBestE1RM - g.startingE1RM;
-      const progressPct =
-        range > 0 ? Math.max(0, Math.round((gained / range) * 100)) : null;
-      return {
-        exerciseName: g.exerciseDisplayName,
-        progressPercent: progressPct,
-        currentBestE1RM: g.currentBestE1RM,
-        targetE1RM: g.targetE1RM,
-        goalAdjustmentAction: g.goalAdjustmentAction ?? null,
-        goalAdjustedAt: g.goalAdjustedAt ?? null
-      };
-    });
-  }
-
   const matchingSummary = programCycleSummaries[0] ?? null;
 
   const progressionDecisions = (matchingSummary?.progressionUpdates ?? []).map((u) => ({
@@ -1236,39 +1340,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
       actionability: 9
     });
   }
-  if (goalProgress?.length > 0) {
-    const lagging = goalProgress.filter((g) => g.progressPercent != null && g.progressPercent < 40);
-    if (lagging.length > 0) {
-      cycleSignals.push({
-        id: 'goal-lagging',
-        category: 'goals',
-        summary: `${lagging.length} goal${lagging.length === 1 ? '' : 's'} under 40% progress`,
-        detail: lagging.map((g) => `${g.exerciseName} ${g.progressPercent}%`).join(', '),
-        impact: 9,
-        confidence: 8,
-        novelty: 6,
-        actionability: 9
-      });
-    }
-  }
-
-  // Phase-window context (Step 9b of the deload-week unification plan): explicit
-  // structured phase facts so prompt builders / models never have to infer
-  // "is this a deload week?" from session prose.
-  const phaseRangeStart = cycleSessions[0]?.completedAt ?? cycleSessions[0]?.date ?? null;
-  const phaseRangeEnd = cycleSessions[cycleSessions.length - 1]?.completedAt
-    ?? cycleSessions[cycleSessions.length - 1]?.date
-    ?? null;
-  const summaryRange = phaseRangeStart && phaseRangeEnd
-    ? { start: phaseRangeStart, end: phaseRangeEnd }
-    : null;
-  const programPhase = programPhaseWindowContext(
-    program,
-    activeStrengthPlanForProgram(snapshot, program.id),
-    summaryRange,
-    new Date()
-  );
-
   return {
     programName: program.name,
     cycleNumber: cycleWeekNumber,
@@ -1276,7 +1347,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
     sessions,
     prsThisCycle,
     bwPrsThisCycle,
-    goalProgress,
     progressionDecisions,
     setCompletionRate,
     swapPatterns,
@@ -1291,7 +1361,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
     avgSleepMins,
     latestBodyWeightKg,
     prioritySignals: rankPrioritySignals(cycleSignals),
-    programPhase,
     excludeNote: buildExcludeNote(exclude)
   };
 }
@@ -1373,26 +1442,12 @@ export function checkpointContext(snapshot, programId, checkpointWeek, { exclude
     .slice(0, 3);
   const previousCycleNotes = programCycleSummaries.map((cs) => cs.aiSummary);
 
-  // Phase-window context (Step 9b). Scoped to a 14-day window ending today
-  // so phasesInRange covers "current week" + "previous week" — enough for
-  // the model to spot post-deload-return / pre-deload patterns without
-  // bloating the prompt with the entire plan timeline.
-  const checkpointToday = new Date();
-  const checkpointStart = new Date(checkpointToday.getTime() - 14 * 24 * 60 * 60 * 1000);
-  const programPhase = programPhaseWindowContext(
-    program,
-    activeStrengthPlanForProgram(snapshot, program.id),
-    { start: checkpointStart, end: checkpointToday },
-    checkpointToday
-  );
-
   return {
     programName: program.name,
     checkpointWeek,
     totalWeeks,
     exercises,
     previousCycleNotes,
-    programPhase,
     excludeNote: buildExcludeNote(exclude)
   };
 }
@@ -1402,6 +1457,7 @@ export function workoutSummaryContext(snapshot, sessionId, { exclude = new Set()
   const session = sessions.find((s) => s.id === sessionId);
   if (!session) return null;
 
+  const today = new Date();
   const sessionDate = completionDateForSession(session);
   const dayName = session.dayName ?? 'Session';
   const earlierSessions = sessions
@@ -1715,14 +1771,16 @@ export function workoutSummaryContext(snapshot, sessionId, { exclude = new Set()
       const nextExercises = ((program.days ?? [])[currentDayIndex]?.exercises ?? [])
         .map(ex => ex.exerciseName ?? ex.name)
         .filter(Boolean);
-      const nextSessionWeekday = (program.trainingWeekdays ?? [])[currentDayIndex];
-      let weekdayName = null;
-      if (nextSessionWeekday != null) {
-        const dayNames = ['', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
-        weekdayName = dayNames[nextSessionWeekday] ?? null;
-      }
+      const schedule = resolveProgramSchedule(program, today);
       if (nextDayTitle) {
-        nextSession = { dayTitle: nextDayTitle, weekday: weekdayName, exerciseNames: nextExercises };
+        nextSession = {
+          dayTitle: nextDayTitle,
+          weekday: schedule?.scheduledWeekdayName ?? null,
+          exerciseNames: nextExercises,
+          state: schedule?.state ?? null,
+          scheduledOn: schedule?.scheduledOn ?? null,
+          nextScheduledSession: schedule?.nextScheduledSession ?? null
+        };
       }
     }
   }
@@ -1997,30 +2055,13 @@ export function askContext(snapshot, { exclude = new Set() } = {}) {
     lines.push(`Recent frequency: ${perWeek} sessions/week (last 4 weeks).`);
   }
 
-  // Current program + week phase. Guided programs use ProgramPhaseResolver so
-  // coach text cannot contradict the structured programPhase prelude.
+  // Current program context without plan-week or phase framing. Score is the
+  // release progress model; program context is only for what the user trains.
   const program = activeProgram(snapshot);
   if (program) {
     const recoveryOutcome = exclude.has('recovery') ? null : deriveRecoveryOutcome(snapshot, program);
-    const programSessions = sessions
-      .filter((s) => s.programId === program.id && s.historicalContext?.programWeekNumber)
-      .sort((a, b) => String(completionDateForSession(b)).localeCompare(String(completionDateForSession(a))));
-    const latestSession = programSessions[0];
-    const phase = resolveCurrentProgramPhase(snapshot, program, today);
-    const currentWeek = phase?.displayWeek
-      ?? Math.max(
-        Number(program.completedCyclesCount ?? 0) + 1,
-        Number(latestSession?.historicalContext?.programWeekNumber ?? 0),
-        1
-      );
-    const weekPhase = phase?.phase
-      ?? latestSession?.historicalContext?.programProgressionType
-      ?? null;
-    const phaseLabel = weekPhase ? ` (${weekPhase} week)` : '';
-    lines.push(`Current program: ${program.name}, week ${currentWeek}${phaseLabel}, ${program.daysPerWeek} days/week, equipment: ${program.equipmentTier ?? 'unknown'}.`);
-    if (weekPhase === 'deload') {
-      lines.push('Note: This is a planned deload week — reduced volume and intensity are intentional, not a regression.');
-    }
+    const daysPerWeek = program.daysPerWeek ?? program.days?.length ?? 'unknown';
+    lines.push(`Current program: ${program.name}, ${daysPerWeek} days/week, equipment: ${program.equipmentTier ?? 'unknown'}.`);
 
     const weekStart = startOfCurrentIsoWeek(today);
     const strengthSessionsThisWeek = sessions.filter((session) => {
@@ -2038,30 +2079,21 @@ export function askContext(snapshot, { exclude = new Set() } = {}) {
       lines.push(`Last strength session: ${lastStrengthSessionDate}.`);
     }
 
-    const latestAdaptation = Array.isArray(program.adaptationEvents) && program.adaptationEvents.length > 0
-      ? program.adaptationEvents[0]
-      : null;
-    if (latestAdaptation?.actionRawValue === 'skipToNextWeek') {
-      const adaptedAt = String(latestAdaptation.occurredAt ?? '').slice(0, 10);
-      const suffix = adaptedAt ? ` on ${adaptedAt}` : '';
-      const adaptationDetails = normalizedNote(latestAdaptation.details);
-      const detailsSuffix = adaptationDetails ? ` ${adaptationDetails}` : '';
-      lines.push(`Latest program adaptation: Week skipped${suffix}.${detailsSuffix}`);
+    // Days until next session — respects iOS catch-up semantics.
+    const schedule = resolveProgramSchedule(program, today);
+    const scheduleLine = formatScheduleLine(schedule);
+    if (scheduleLine) {
+      // workout-summary historically uses "Next session:" lead — preserve when not catching up.
+      if (schedule.state === 'catchUp') {
+        lines.push(scheduleLine);
+      } else if (schedule.state === 'today') {
+        lines.push(`Next session: ${schedule.dayTitle} (today).`);
+      } else {
+        const whenLabel = schedule.daysUntil === 1 ? 'tomorrow' : `in ${schedule.daysUntil} days`;
+        lines.push(`Next session: ${schedule.dayTitle} on ${schedule.scheduledWeekdayName} (${whenLabel}).`);
+      }
     }
-
-    // Days until next session
     const currentDayIndex = program.currentDayIndex ?? 0;
-    const nextSessionWeekday = (program.trainingWeekdays ?? [])[currentDayIndex];
-    if (nextSessionWeekday != null) {
-      const jsDay = new Date().getDay(); // 0=Sun
-      const todayWeekday = jsDay === 0 ? 7 : jsDay; // 1=Mon … 7=Sun
-      let daysUntil = nextSessionWeekday - todayWeekday;
-      if (daysUntil < 0) daysUntil += 7;
-      const dayNames = ['', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
-      const whenLabel = daysUntil === 0 ? 'today' : daysUntil === 1 ? 'tomorrow' : `in ${daysUntil} days`;
-      const nextDayTitle = (program.days ?? [])[currentDayIndex]?.title ?? `Day ${currentDayIndex + 1}`;
-      lines.push(`Next session: ${nextDayTitle} on ${dayNames[nextSessionWeekday]} (${whenLabel}).`);
-    }
 
     if (recoveryOutcome) {
       lines.push(`Recovery update: ${recoveryOutcome.scheduleLine} ${recoveryOutcome.targetLine} ${recoveryOutcome.nextStepLine}`);
@@ -4039,12 +4071,51 @@ export function healthSummary(snapshot, days = 14) {
       nights: recentSleep.length
     },
     bodyWeight: (() => {
-      const recent = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
-      if (recent.length === 0) return { latest: null, readings: 0 };
+      const profileWeightKg = Number(snapshot.user?.weightKg);
+      const resolvedProfileWeightKg = Number.isFinite(profileWeightKg) && profileWeightKg > 0
+        ? Math.round(profileWeightKg * 10) / 10
+        : null;
+      const rows = (metrics.bodyWeight ?? [])
+        .filter((m) => m?.date && Number.isFinite(Number(m.value ?? m.weight)))
+        .map((m) => ({
+          date: String(m.date).slice(0, 10),
+          value: Number(m.value ?? m.weight)
+        }))
+        .sort((a, b) => a.date.localeCompare(b.date));
+      const recent = rows.filter((m) => m.date >= cutoff);
+      if (recent.length === 0 && resolvedProfileWeightKg != null) {
+        return {
+          latest: { value: resolvedProfileWeightKg, date: null, source: 'profile', stale: false },
+          trend: null,
+          readings: 0,
+          totalReadings: rows.length
+        };
+      }
+      if (recent.length === 0) {
+        const latestKnown = rows.at(-1);
+        if (!latestKnown) return { latest: null, readings: 0, totalReadings: 0 };
+        return {
+          latest: {
+            value: Math.round(latestKnown.value * 10) / 10,
+            date: latestKnown.date,
+            source: 'healthkit',
+            stale: true
+          },
+          trend: null,
+          readings: 0,
+          totalReadings: rows.length
+        };
+      }
       return {
-        latest: { value: Math.round(recent.at(-1).value * 10) / 10, date: recent.at(-1).date },
+        latest: {
+          value: Math.round(recent.at(-1).value * 10) / 10,
+          date: recent.at(-1).date,
+          source: 'healthkit',
+          stale: false
+        },
         trend: Math.round((recent.at(-1).value - recent[0].value) * 10) / 10,
-        readings: recent.length
+        readings: recent.length,
+        totalReadings: rows.length
       };
     })(),
     respiratoryRate: (() => {
@@ -4102,7 +4173,8 @@ function weeklyActivitySummary(metrics) {
 
 export function vitalsSummaryContext(snapshot, { exclude = new Set() } = {}) {
   const lines = [];
-  lines.push(`Date: ${new Date().toISOString().slice(0, 10)}`);
+  const today = new Date();
+  lines.push(`Date: ${dateOnly(today)} (${WEEKDAY_NAMES[isoWeekdayOf(today)]})`);
 
   // Training context
   const cutoff = new Date();
@@ -4144,18 +4216,10 @@ export function vitalsSummaryContext(snapshot, { exclude = new Set() } = {}) {
   const prog = snapshot.currentProgram ?? activeProgram(snapshot);
   if (prog) {
     lines.push(`Current program: ${prog.name}.`);
-    const currentDayIndex = prog.currentDayIndex ?? 0;
-    const nextSessionWeekday = (prog.trainingWeekdays ?? [])[currentDayIndex];
-    if (nextSessionWeekday != null) {
-      const jsDay = new Date().getDay();
-      const todayIso = jsDay === 0 ? 7 : jsDay;
-      let daysUntil = nextSessionWeekday - todayIso;
-      if (daysUntil < 0) daysUntil += 7;
-      const dayNames = ['', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
-      const whenLabel = daysUntil === 0 ? 'today' : daysUntil === 1 ? 'tomorrow' : `in ${daysUntil} days`;
-      const nextDayTitle = (prog.days ?? [])[currentDayIndex]?.title ?? `Day ${currentDayIndex + 1}`;
-      lines.push(`Next scheduled session: ${nextDayTitle} on ${dayNames[nextSessionWeekday]} (${whenLabel}).`);
-    }
+    for (const line of completedThisCycleLines(prog)) lines.push(line);
+    const schedule = resolveProgramSchedule(prog, today);
+    const scheduleLine = formatScheduleLine(schedule);
+    if (scheduleLine) lines.push(scheduleLine);
   }
 
   const vitals = healthSummary(snapshot, 14);
@@ -4453,19 +4517,25 @@ export function executeReadCommand(snapshot, normalizedCommand, options = {}) {
 // ---------- Weekly Coach Check-in ----------
 // Builds a rolling 7-day context for the Sunday Coach Check-in.
 // See docs/plans/2026-04-23-001-feat-sunday-coach-checkin-plan-deepened.md.
-export function weeklyCheckinContext(snapshot, accountId) {
+// `now` (optional, in options) anchors the 7-day window to a caller-provided
+// reference time instead of real time. The cron uses this to pin the window
+// to `row.week_start_date` so a late catch-up run still reports the canonical
+// Sun→Sun week rather than a Tue→Tue rolling slice. Defaults to new Date().
+export function weeklyCheckinContext(snapshot, accountId, { now: providedNow } = {}) {
   if (!snapshot) return null;
   const sessions = Array.isArray(snapshot.sessions) ? snapshot.sessions : [];
-  const now = new Date();
+  const now = providedNow instanceof Date && !Number.isNaN(providedNow.getTime())
+    ? providedNow
+    : new Date();
   const todayIso = now.toISOString().slice(0, 10);
-  const cutoff = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-  const program = activeProgram(snapshot);
-
+  const cutoff = new Date(now);
+  cutoff.setUTCHours(0, 0, 0, 0);
+  cutoff.setUTCDate(cutoff.getUTCDate() - 7);
   const weekSessions = sessions.filter((s) => {
     const d = completionDateForSession(s);
     if (!d) return false;
     const dt = new Date(d);
-    return !Number.isNaN(dt.getTime()) && dt >= cutoff;
+    return !Number.isNaN(dt.getTime()) && dt >= cutoff && dt < now;
   });
 
   // Sessions prior to this week for stall/PR comparison.
@@ -4532,6 +4602,7 @@ export function weeklyCheckinContext(snapshot, accountId) {
   }
 
   // Stalled exercises: e1RM hasn't increased in 3+ consecutive weeks.
+  // Bounded by `now` so anchored windows ignore sessions after the reference.
   const stalled = [];
   const byExercise = new Map();
   for (const s of sessions) {
@@ -4539,6 +4610,7 @@ export function weeklyCheckinContext(snapshot, accountId) {
     if (!d) continue;
     const dt = new Date(d);
     if (Number.isNaN(dt.getTime())) continue;
+    if (dt >= now) continue;
     for (const ex of s.exercises ?? []) {
       if (!ex.name) continue;
       let top = 0;
@@ -4576,7 +4648,10 @@ export function weeklyCheckinContext(snapshot, accountId) {
       .slice()
       .filter((e) => e && e.date && Number.isFinite(Number(e.value ?? e.weight)))
       .sort((a, b) => String(a.date).localeCompare(String(b.date)));
-    const recent = sorted.filter((e) => new Date(e.date) >= cutoff);
+    const recent = sorted.filter((e) => {
+      const dt = new Date(e.date);
+      return !Number.isNaN(dt.getTime()) && dt >= cutoff && dt < now;
+    });
     if (recent.length >= 2) {
       const first = Number(recent[0].value ?? recent[0].weight);
       const last = Number(recent[recent.length - 1].value ?? recent[recent.length - 1].weight);
@@ -4584,38 +4659,6 @@ export function weeklyCheckinContext(snapshot, accountId) {
     }
   }
 
-  // Goal trajectory: read from active StrengthPlan liftGoals.
-  let goalProgress = [];
-  const plans = Array.isArray(snapshot.strengthPlans) ? snapshot.strengthPlans : [];
-  const activePlan = program
-    ? activeStrengthPlanForProgram(snapshot, program.id)
-    : plans.find((p) => p?.status === 'active');
-  if (activePlan && Array.isArray(activePlan.liftGoals)) {
-    for (const goal of activePlan.liftGoals) {
-      const start = Number(goal.startingE1RM ?? 0);
-      const target = Number(goal.targetE1RM ?? 0);
-      const current = Number(goal.currentBestE1RM ?? 0);
-      if (target <= 0 || target === start) continue;
-      const pct = Math.max(0, Math.min(100, Math.round(((current - start) / (target - start)) * 100)));
-      goalProgress.push({
-        exerciseName: goal.exerciseDisplayName ?? goal.exerciseName ?? 'goal',
-        progressPercent: pct,
-        currentE1RM: Math.round(current * 10) / 10,
-        targetE1RM: target,
-        finishDate: activePlan.finishDate ?? null,
-      });
-    }
-  }
-
-  const programPhase = program
-    ? programPhaseWindowContext(
-      program,
-      activeStrengthPlanForProgram(snapshot, program.id),
-      { start: cutoff, end: now },
-      now
-    )
-    : null;
-
   // Prior commitment from typed coach_commitments storage (caller may inject).
   const context = {
     accountId,
@@ -4629,10 +4672,121 @@ export function weeklyCheckinContext(snapshot, accountId) {
     prsThisWeek: prs,
     stalledExercises: stalled.slice(0, 5),
     bodyweightDeltaKg: bodyweightDelta,
-    goalProgress,
-    programPhase,
     // Placeholder for injection by the handler; not a secret, just coherent.
     priorCommitment: null,
   };
   return context;
 }
+
+// ---------- Weekly score digest (onemore-3s7j) ----------
+// Pure derivation: given the existing weekly check-in context (sessions,
+// volume, adherence, PRs, stalled lifts, bodyweight delta) plus the last week
+// of score_snapshots rows from the DB, build the row that backs the iOS
+// digest card. The card is glanceable and rule-based — no LLM call here.
+//
+// scoreSnapshots argument: array of { snapshotAt, score, components } rows,
+// ordered DESC by snapshotAt (i.e. listScoreSnapshots default ordering).
+export function buildWeeklyScoreDigest(weeklyContext, scoreSnapshots) {
+  if (!weeklyContext) return null;
+  const rows = Array.isArray(scoreSnapshots) ? scoreSnapshots : [];
+  if (rows.length === 0) return null;
+
+  const weekStart = weeklyContext.weekRangeIso?.start;
+  const weekEnd = weeklyContext.weekRangeIso?.end;
+  if (!weekStart || !weekEnd) return null;
+
+  const inWeek = (iso) => {
+    const d = String(iso ?? '').slice(0, 10);
+    return d >= weekStart && d <= weekEnd;
+  };
+
+  const latestInWeek = rows.find((r) => inWeek(r.snapshotAt));
+  if (!latestInWeek) return null;
+
+  // Earliest prior row to compute a delta against. "Prior" means strictly
+  // before the start of the digest week, capped at the most recent such row.
+  const priorRow = rows.find((r) => String(r.snapshotAt ?? '').slice(0, 10) < weekStart);
+
+  const components = latestInWeek.components ?? {};
+  const priorComponents = priorRow?.components ?? {};
+  const componentsDelta = {};
+  const keys = new Set([...Object.keys(components), ...Object.keys(priorComponents)]);
+  for (const key of keys) {
+    const now = scoreComponentNumber(components[key]);
+    const before = scoreComponentNumber(priorComponents[key]);
+    if (Number.isFinite(now) && Number.isFinite(before)) {
+      componentsDelta[key] = Math.round((now - before) * 10) / 10;
+    }
+  }
+
+  const scoreDelta = priorRow && Number.isFinite(Number(priorRow.score))
+    ? Math.round(Number(latestInWeek.score) - Number(priorRow.score))
+    : null;
+
+  const signals = {
+    sessionCount: weeklyContext.sessionCount ?? 0,
+    totalVolume: weeklyContext.totalVolume ?? 0,
+    adherencePct: weeklyContext.adherencePct ?? null,
+    prCount: Array.isArray(weeklyContext.prsThisWeek) ? weeklyContext.prsThisWeek.length : 0,
+    topPr: Array.isArray(weeklyContext.prsThisWeek) && weeklyContext.prsThisWeek.length > 0
+      ? weeklyContext.prsThisWeek[0]
+      : null,
+    topStalledExercise: Array.isArray(weeklyContext.stalledExercises) && weeklyContext.stalledExercises.length > 0
+      ? weeklyContext.stalledExercises[0].exerciseName
+      : null,
+    bodyweightDeltaKg: weeklyContext.bodyweightDeltaKg ?? null,
+  };
+
+  return {
+    weekStart,
+    weekEnd,
+    score: Math.round(Number(latestInWeek.score)),
+    scoreDelta,
+    components,
+    componentsDelta,
+    signals,
+    observation: weeklyScoreDigestObservation({ signals, componentsDelta, scoreDelta }),
+    sourceSnapshotId: latestInWeek.id != null ? String(latestInWeek.id) : null,
+  };
+}
+
+// Rule-based observation. Picks the single most useful sentence for the card.
+// Order: no sessions logged > biggest negative component drop > top PR >
+// stalled lift > positive consistency. Templated, never references plan rituals.
+export function weeklyScoreDigestObservation({ signals, componentsDelta, scoreDelta }) {
+  const sessionCount = signals?.sessionCount ?? 0;
+  if (sessionCount === 0) {
+    return 'No sessions logged this week.';
+  }
+
+  let worstKey = null;
+  let worstValue = 0;
+  for (const [key, value] of Object.entries(componentsDelta ?? {})) {
+    if (Number.isFinite(value) && value < worstValue) {
+      worstKey = key;
+      worstValue = value;
+    }
+  }
+  if (worstKey && worstValue <= -2) {
+    return `Your ${worstKey} score dropped ${Math.abs(Math.round(worstValue))} this week — biggest drag on your overall score.`;
+  }
+
+  if (signals.topPr?.exerciseName) {
+    const weight = Number(signals.topPr.weight);
+    const reps = Number(signals.topPr.reps);
+    const repStr = Number.isFinite(weight) && Number.isFinite(reps) && weight > 0 && reps > 0
+      ? ` (${weight}×${reps})`
+      : '';
+    return `${signals.topPr.exerciseName} PR this week${repStr}.`;
+  }
+
+  if (signals.topStalledExercise) {
+    return `${signals.topStalledExercise} hasn't moved in a few weeks — the lift dragging your trajectory most.`;
+  }
+
+  if (Number.isFinite(scoreDelta) && scoreDelta >= 3) {
+    return `Score up ${scoreDelta} from last week — keep the rhythm.`;
+  }
+
+  return `${sessionCount} session${sessionCount === 1 ? '' : 's'} logged this week.`;
+}