incremnt 0.5.0 → 0.6.1

package/src/queries.js

@@ -1,11 +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();
@@ -1100,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) => ({
@@ -1235,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,
@@ -1275,7 +1347,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
     sessions,
     prsThisCycle,
     bwPrsThisCycle,
-    goalProgress,
     progressionDecisions,
     setCompletionRate,
     swapPatterns,
@@ -1290,7 +1361,6 @@ export function cycleSummaryContext(snapshot, programId, { exclude = new Set() }
     avgSleepMins,
     latestBodyWeightKg,
     prioritySignals: rankPrioritySignals(cycleSignals),
-    programPhase,
     excludeNote: buildExcludeNote(exclude)
   };
 }
@@ -1372,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)
   };
 }
@@ -1401,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
@@ -1714,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
+        };
       }
     }
   }
@@ -1996,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) => {
@@ -2037,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}`);
@@ -2883,53 +2916,150 @@ export function getRecords(snapshot, { exercises = [], limit = 15 } = {}) {
   });
 }
 
-export function getIncrementScore(snapshot, { historyDays = 14 } = {}) {
-  const raw = snapshot?.incrementScore;
+function scoreComponentNumber(value) {
+  const num = typeof value === 'number' ? value : value?.score;
+  return typeof num === 'number' && Number.isFinite(num) ? num : null;
+}
+
+function scoreDriverLabels(list, limit = 5) {
+  if (!Array.isArray(list)) return [];
+  return list.slice(0, limit).map((d) => d?.label ?? d?.message ?? d?.id ?? d?.driver).filter(Boolean);
+}
+
+function normalizeScoreHistory(raw) {
   const history = Array.isArray(raw?.history) ? raw.history : Array.isArray(raw) ? raw : [];
   const latest = raw?.latest ?? history[0] ?? null;
+  const first = history[0] ?? null;
+  const sameFirst = latest && first && (
+    (latest.snapshotAt && first.snapshotAt && latest.snapshotAt === first.snapshotAt) ||
+    (latest === first)
+  );
+  const mergedHistory = latest && sameFirst
+    ? [{ ...first, ...latest }, ...history.slice(1)]
+    : latest
+      ? [latest, ...history]
+      : history;
+  return enrichScoreSnapshots(mergedHistory);
+}
+
+export function incrementScoreSummary(snapshot, { historyDays = 14 } = {}) {
+  const raw = snapshot?.incrementScore;
+  const history = normalizeScoreHistory(raw);
+  const latest = history[0] ?? null;
+  const boundedHistoryDays = boundedInteger(historyDays, { defaultValue: 14, min: 1, max: 60 });
 
   if (!latest || typeof latest.score !== 'number') {
-    return coachToolResult('get_increment_score', { historyDays }, {
-      facts: {},
+    return {
+      available: false,
+      score: null,
+      snapshotAt: null,
+      formulaVersion: null,
+      dataTier: null,
+      components: {},
+      topPositiveDrivers: [],
+      topNegativeDrivers: [],
+      dayOverDayDelta: null,
+      recentTrend: [],
+      dataQualityNotes: ['No Increment Score snapshots found.'],
       missingDataFlags: ['no_increment_score']
-    });
+    };
   }
 
   const components = {};
   if (latest.components && typeof latest.components === 'object') {
     for (const [name, value] of Object.entries(latest.components)) {
-      const num = typeof value === 'number' ? value : value?.score;
-      if (typeof num === 'number') components[name] = num;
+      const num = scoreComponentNumber(value);
+      if (num != null) components[name] = num;
     }
   }
 
-  const trimmedHistory = history.slice(0, Math.min(Math.max(Number(historyDays) || 14, 1), 60));
-  const recentScores = trimmedHistory
-    .map((entry) => (typeof entry?.score === 'number' ? entry.score : null))
-    .filter((s) => s != null);
-
+  const trimmedHistory = history.slice(0, boundedHistoryDays);
   const prior = trimmedHistory[1];
   const dayOverDayDelta = (typeof prior?.score === 'number')
     ? latest.score - prior.score
     : null;
 
-  const driverLabels = (list) => {
-    if (!Array.isArray(list)) return [];
-    return list.slice(0, 5).map((d) => d?.label ?? d?.id ?? d?.driver).filter(Boolean);
+  const missingDataFlags = [];
+  const dataQualityNotes = [];
+  if (Object.keys(components).length === 0) {
+    missingDataFlags.push('no_components');
+    dataQualityNotes.push('Component scores are missing for this snapshot.');
+  }
+  if (!latest.dataTier) {
+    missingDataFlags.push('no_data_tier');
+    dataQualityNotes.push('Data tier is missing for this snapshot.');
+  }
+  if (!latest.formulaVersion) {
+    missingDataFlags.push('no_formula_version');
+    dataQualityNotes.push('Formula version is missing for this snapshot.');
+  }
+
+  const recentTrend = trimmedHistory
+    .filter((entry) => typeof entry?.score === 'number')
+    .map((entry) => ({
+      snapshotAt: entry.snapshotAt ?? null,
+      score: entry.score,
+      dataTier: entry.dataTier ?? null,
+      formulaVersion: entry.formulaVersion ?? null
+    }));
+
+  return {
+    available: true,
+    score: latest.score,
+    snapshotAt: latest.snapshotAt ?? null,
+    formulaVersion: latest.formulaVersion ?? null,
+    dataTier: latest.dataTier ?? null,
+    components,
+    topPositiveDrivers: scoreDriverLabels(latest.topPositiveDrivers),
+    topNegativeDrivers: scoreDriverLabels(latest.topNegativeDrivers),
+    dayOverDayDelta,
+    recentTrend,
+    dataQualityNotes,
+    missingDataFlags,
+    scoreBand: latest.scoreBand ?? null,
+    summaryText: latest.summaryText ?? null
   };
+}
+
+export function incrementScoreCurrent(snapshot, options = {}) {
+  return incrementScoreSummary(snapshot, options);
+}
+
+export function incrementScoreHistory(snapshot, options = {}) {
+  const raw = snapshot?.incrementScore;
+  const history = normalizeScoreHistory(raw);
+  const limit = boundedInteger(options.limit, { defaultValue: 200, min: 1, max: 1000 });
+  const from = options.from ? new Date(options.from) : null;
+  const to = options.to ? new Date(options.to) : null;
+  const filtered = history.filter((entry) => {
+    if (!entry?.snapshotAt) return true;
+    const date = new Date(entry.snapshotAt);
+    if (Number.isNaN(date.getTime())) return true;
+    if (from && !Number.isNaN(from.getTime()) && date < from) return false;
+    if (to && !Number.isNaN(to.getTime()) && date > to) return false;
+    return true;
+  });
+
+  return { snapshots: filtered.slice(0, limit) };
+}
+
+export function getIncrementScore(snapshot, { historyDays = 14 } = {}) {
+  const summary = incrementScoreSummary(snapshot, { historyDays });
+
+  if (!summary.available) {
+    return coachToolResult('get_increment_score', { historyDays }, {
+      facts: {},
+      missingDataFlags: summary.missingDataFlags
+    });
+  }
 
   return coachToolResult('get_increment_score', { historyDays }, {
     facts: {
-      score: latest.score,
-      dataTier: latest.dataTier ?? null,
-      components,
-      topPositiveDrivers: driverLabels(latest.topPositiveDrivers),
-      topNegativeDrivers: driverLabels(latest.topNegativeDrivers),
-      dayOverDayDelta,
-      recentScores
+      ...summary,
+      recentScores: summary.recentTrend.map((entry) => entry.score)
     },
-    sourceTimestamp: latest.snapshotAt ?? null,
-    missingDataFlags: Object.keys(components).length === 0 ? ['no_components'] : []
+    sourceTimestamp: summary.snapshotAt,
+    missingDataFlags: summary.missingDataFlags
   });
 }
 
@@ -4004,7 +4134,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();
@@ -4046,18 +4177,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);
@@ -4308,6 +4431,14 @@ export function executeReadCommand(snapshot, normalizedCommand, options = {}) {
     return { ok: true, payload: trainingLoad(snapshot) };
   }
 
+  if (normalizedCommand === 'increment-score-current') {
+    return { ok: true, payload: incrementScoreCurrent(snapshot, options) };
+  }
+
+  if (normalizedCommand === 'increment-score-history') {
+    return { ok: true, payload: incrementScoreHistory(snapshot, options) };
+  }
+
   if (normalizedCommand === 'ask-history') {
     const conversations = Array.isArray(snapshot.askConversations)
       ? snapshot.askConversations
@@ -4347,19 +4478,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.
@@ -4426,6 +4563,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) {
@@ -4433,6 +4571,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;
@@ -4470,7 +4609,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);
@@ -4478,38 +4620,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,
@@ -4523,10 +4633,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.`;
+}