incremnt 0.1.18 → 0.2.0

package/src/queries.js

@@ -369,18 +369,36 @@ export function programDetail(snapshot, programId) {
     days: (program.days ?? []).map((day, index) => ({
       dayIndex: index,
       title: day.title ?? null,
-      exercises: (day.exercises ?? []).map((exercise) => ({
-        name: exercise.name,
-        muscleGroup: exercise.muscleGroup ?? null,
-        sets: (exercise.sets ?? []).map((set) => ({
-          reps: set.reps ?? null,
-          weight: set.weight ?? null
-        }))
-      }))
+      exercises: (day.exercises ?? []).map((exercise) => {
+        const rec = (snapshot.exerciseRecommendations ?? {})[exercise.name];
+        return {
+          name: exercise.name,
+          muscleGroup: exercise.muscleGroup ?? null,
+          sets: (exercise.sets ?? []).map((set) => ({
+            reps: set.reps ?? null,
+            weight: set.weight ?? null
+          })),
+          ...(rec ? { recommendation: formatRecommendation(rec) } : {})
+        };
+      })
     }))
   };
 }
 
+function formatRecommendation(rec) {
+  if (!rec || !rec.kind) return null;
+  const amount = rec.amount ?? 0;
+  const unit = rec.unit === 'reps' ? 'reps' : 'kg';
+  switch (rec.kind) {
+    case 'increaseWeight': return `+${amount} ${unit}`;
+    case 'decreaseWeight': return `-${amount} ${unit}`;
+    case 'increaseReps': return rec.targetReps ? `target reps: ${rec.targetReps.join(', ')}` : `+${amount} reps`;
+    case 'deload': return amount > 0 ? `deload -${amount} ${unit}` : 'deload';
+    case 'retry': return 'retry same weight';
+    default: return rec.kind;
+  }
+}
+
 export function goalsList(snapshot) {
   return (snapshot.strengthPlans ?? []).map(plan => ({
     planId: plan.id,
@@ -469,7 +487,7 @@ export function cycleSummaryShow(snapshot, summaryId) {
   };
 }
 
-export function cycleSummaryContext(snapshot, programId) {
+export function cycleSummaryContext(snapshot, programId, { exclude = new Set() } = {}) {
   const programs = snapshot.programs ?? [];
   const program = programId
     ? programs.find((p) => p.id === programId)
@@ -624,10 +642,16 @@ export function cycleSummaryContext(snapshot, programId) {
     const totalVolume = weekSessions.reduce((sum, s) => sum + (s.summary?.totalVolume ?? s.volume ?? 0), 0);
     const matchingCycleSummary = programCycleSummaries[idx] ?? null;
 
+    const sessionVolumes = weekSessions.map((s) => ({
+      dayName: s.dayName ?? null,
+      volume: s.summary?.totalVolume ?? s.volume ?? 0
+    }));
+
     return {
       weekNumber: wk,
       sessionCount: weekSessions.length,
       totalVolume: Math.round(totalVolume),
+      sessionVolumes,
       previousAISummary: matchingCycleSummary?.aiSummary ?? null
     };
   });
@@ -705,11 +729,21 @@ export function cycleSummaryContext(snapshot, programId) {
     (p) => p.status === 'active' && p.programId === program.id
   );
   if (activePlan) {
-    goalProgress = (activePlan.liftGoals ?? []).map((g) => {
+    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.round((gained / range) * 100) : null;
+        range > 0 ? Math.max(0, Math.round((gained / range) * 100)) : null;
       return {
         exerciseName: g.exerciseDisplayName,
         progressPercent: progressPct,
@@ -736,15 +770,15 @@ export function cycleSummaryContext(snapshot, programId) {
   const cycleStart = String(cycleSessions[0] ? completionDateForSession(cycleSessions[0]) : '');
   const cycleEnd = String(cycleSessions[cycleSessions.length - 1]
     ? completionDateForSession(cycleSessions[cycleSessions.length - 1]) : '');
-  const cycleCardio = (snapshot.healthMetrics?.otherWorkouts ?? [])
+  const cycleCardio = exclude.has('otherWorkouts') ? [] : (snapshot.healthMetrics?.otherWorkouts ?? [])
     .filter((w) => w.date >= cycleStart && w.date <= cycleEnd);
-  const cycleRestingHR = (snapshot.healthMetrics?.restingHR ?? [])
+  const cycleRestingHR = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.restingHR ?? [])
     .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
-  const cycleHRV = (snapshot.healthMetrics?.hrv ?? [])
+  const cycleHRV = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.hrv ?? [])
     .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
-  const cycleVO2Max = (snapshot.healthMetrics?.vo2Max ?? [])
+  const cycleVO2Max = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.vo2Max ?? [])
     .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
-  const cycleSleep = (snapshot.healthMetrics?.sleep ?? [])
+  const cycleSleep = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.sleep ?? [])
     .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
 
   const avgRestingHR = cycleRestingHR.length > 0
@@ -759,7 +793,7 @@ export function cycleSummaryContext(snapshot, programId) {
   const avgSleepMins = cycleSleep.length > 0
     ? Math.round(cycleSleep.reduce((s, m) => s + m.durationMins, 0) / cycleSleep.length)
     : null;
-  const cycleBodyWeight = (snapshot.healthMetrics?.bodyWeight ?? [])
+  const cycleBodyWeight = exclude.has('bodyWeight') ? [] : (snapshot.healthMetrics?.bodyWeight ?? [])
     .filter((m) => m.date >= cycleStart && m.date <= cycleEnd);
   const latestBodyWeightKg = cycleBodyWeight.length > 0
     ? Math.round(cycleBodyWeight.at(-1).value * 10) / 10
@@ -859,11 +893,12 @@ export function cycleSummaryContext(snapshot, programId) {
     latestVO2Max,
     avgSleepMins,
     latestBodyWeightKg,
-    prioritySignals: rankPrioritySignals(cycleSignals)
+    prioritySignals: rankPrioritySignals(cycleSignals),
+    excludeNote: buildExcludeNote(exclude)
   };
 }
 
-export function checkpointContext(snapshot, programId, checkpointWeek) {
+export function checkpointContext(snapshot, programId, checkpointWeek, { exclude = new Set() } = {}) {
   const programs = snapshot.programs ?? [];
   const program = programId
     ? programs.find((p) => p.id === programId)
@@ -948,11 +983,12 @@ export function checkpointContext(snapshot, programId, checkpointWeek) {
     checkpointWeek,
     totalWeeks,
     exercises,
-    previousCycleNotes
+    previousCycleNotes,
+    excludeNote: buildExcludeNote(exclude)
   };
 }
 
-export function workoutSummaryContext(snapshot, sessionId) {
+export function workoutSummaryContext(snapshot, sessionId, { exclude = new Set() } = {}) {
   const sessions = snapshot.sessions ?? [];
   const session = sessions.find((s) => s.id === sessionId);
   if (!session) return null;
@@ -999,7 +1035,8 @@ export function workoutSummaryContext(snapshot, sessionId) {
       muscleGroup: exercise.muscleGroup ?? null,
       completedSets: completeSets.length,
       isBodyweight: bw,
-      topSet: topSet ? { weight: topSet.weight, reps: topSet.reps } : null
+      topSet: topSet ? { weight: topSet.weight, reps: topSet.reps } : null,
+      allSets: completeSets.map((s) => ({ weight: Number(s.weight), reps: Number(s.reps) }))
     };
   });
 
@@ -1025,6 +1062,7 @@ export function workoutSummaryContext(snapshot, sessionId) {
   const priorBestBWReps = new Map(); // key -> best reps for bodyweight exercises
   const exerciseSessionCounts = new Map();
   const priorBestReps = new Map(); // key -> Map(weight -> bestReps)
+  const exerciseRecentWeights = new Map(); // key -> [{date, topWeight}], last 3 sessions
   for (const s of sessions) {
     if (s.id === sessionId) continue;
     const sDate = String(completionDateForSession(s));
@@ -1053,13 +1091,32 @@ export function workoutSummaryContext(snapshot, sessionId) {
         const currentBest = repsMap.get(w);
         if (!currentBest || r > currentBest) repsMap.set(w, r);
       }
+      // Track per-session top weight for recent weight history (non-bodyweight only)
+      const exerciseCompleteSets = (exercise.sets ?? []).filter((s) => s.isComplete);
+      const maxWeight = exerciseCompleteSets.reduce((max, s) => Math.max(max, Number(s.weight)), 0);
+      if (maxWeight > 0) {
+        if (!exerciseRecentWeights.has(key)) exerciseRecentWeights.set(key, []);
+        const history = exerciseRecentWeights.get(key);
+        if (!history.find((h) => h.date === sDate)) {
+          history.push({ date: sDate, topWeight: maxWeight });
+        }
+      }
     }
   }
 
-  // Attach prior session count to each exercise
+  // Sort recent weight histories by date descending, keep last 3 sessions
+  for (const [, history] of exerciseRecentWeights) {
+    history.sort((a, b) => b.date.localeCompare(a.date));
+    if (history.length > 3) history.length = 3;
+  }
+
+  // Attach prior session count and recent weights to each exercise
   for (const ex of exercises) {
     const key = normalizeExerciseName(ex.exerciseName);
     ex.priorSessions = exerciseSessionCounts.get(key) ?? 0;
+    if (!ex.isBodyweight) {
+      ex.recentWeights = exerciseRecentWeights.get(key) ?? [];
+    }
   }
 
   // Detect PRs — skip first-time exercises (every set is trivially a "PR")
@@ -1130,46 +1187,101 @@ export function workoutSummaryContext(snapshot, sessionId) {
     }
   }
 
-  // Plan comparison — prefer the logged point-in-time prescription snapshot.
-  let planComparison;
+  // Resolve planned exercise list — prefer the logged point-in-time prescription snapshot.
+  let plannedExerciseList = [];
   if (session.prescriptionSnapshot?.exercises?.length > 0) {
-    planComparison = buildPlanComparison(session, exercises, session.prescriptionSnapshot.exercises);
+    plannedExerciseList = session.prescriptionSnapshot.exercises;
   } else if (session.programId) {
     const program = (snapshot.programs ?? []).find(p => p.id === session.programId);
     const matchingDay = Number.isInteger(session.programDayIndex)
       ? program?.days?.[session.programDayIndex]
       : program?.days?.find(d => d.title === dayName);
     if (matchingDay) {
-      planComparison = buildPlanComparison(session, exercises, matchingDay.exercises ?? []);
+      plannedExerciseList = matchingDay.exercises ?? [];
+    }
+  }
+
+  // Plan comparison
+  const planComparison = plannedExerciseList.length > 0
+    ? buildPlanComparison(session, exercises, plannedExerciseList)
+    : undefined;
+
+  // Attach planned weight/reps to each exercise for the AI coach context
+  if (plannedExerciseList.length > 0) {
+    const plannedByName = new Map(
+      plannedExerciseList.map((ex) => [normalizeExerciseName(ex.exerciseName ?? ex.name), ex])
+    );
+    for (const ex of exercises) {
+      const planned = plannedByName.get(normalizeExerciseName(ex.exerciseName));
+      if (!planned) continue;
+      const sets = planned.targetSets ?? planned.sets ?? [];
+      const firstWeightedSet = sets.find((s) => s.weight != null && Number(s.weight) > 0);
+      if (firstWeightedSet) {
+        ex.plannedWeight = firstWeightedSet.weight;
+        ex.plannedReps = firstWeightedSet.reps ?? null;
+        ex.plannedSetCount = sets.length;
+      }
     }
   }
 
   const isAdhoc = !session.programId;
 
-  // Include other workouts from the 7 days before this session for coach context
+  // Include cardio from the 3 days before this session — only the immediately preceding
+  // window has meaningful acute recovery relevance.
   const sessionDateStr = String(sessionDate);
-  const weekBefore = new Date(new Date(sessionDateStr).getTime() - 7 * 24 * 60 * 60 * 1000)
+  const threeDaysBefore = new Date(new Date(sessionDateStr).getTime() - 3 * 24 * 60 * 60 * 1000)
     .toISOString().slice(0, 10);
-  const nearbyCardio = (snapshot.healthMetrics?.otherWorkouts ?? [])
-    .filter((w) => w.date >= weekBefore && w.date <= sessionDateStr);
+  const nearbyCardio = exclude.has('otherWorkouts') ? [] : (snapshot.healthMetrics?.otherWorkouts ?? [])
+    .filter((w) => w.date >= threeDaysBefore && w.date <= sessionDateStr);
 
-  const restingHROnDay = (snapshot.healthMetrics?.restingHR ?? [])
+  const restingHROnDay = exclude.has('recovery') ? null : (snapshot.healthMetrics?.restingHR ?? [])
     .find((m) => m.date === sessionDateStr);
-  const hrvOnDay = (snapshot.healthMetrics?.hrv ?? [])
+  const hrvOnDay = exclude.has('recovery') ? null : (snapshot.healthMetrics?.hrv ?? [])
     .find((m) => m.date === sessionDateStr);
-  const sleepNight = (snapshot.healthMetrics?.sleep ?? [])
+  const sleepNight = exclude.has('recovery') ? null : (snapshot.healthMetrics?.sleep ?? [])
     .find((m) => m.date === sessionDateStr);
-  const vo2MaxRecent = (snapshot.healthMetrics?.vo2Max ?? [])
-    .filter((m) => m.date >= weekBefore && m.date <= sessionDateStr);
+
+  // 14-day baselines for contextualising session-day vitals
+  const fourteenDaysBefore = new Date(new Date(sessionDateStr).getTime() - 14 * 24 * 60 * 60 * 1000)
+    .toISOString().slice(0, 10);
+  const recentHRVReadings = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.hrv ?? [])
+    .filter((m) => m.date >= fourteenDaysBefore && m.date < sessionDateStr);
+  const hrvBaseline = recentHRVReadings.length >= 3
+    ? Math.round(recentHRVReadings.reduce((s, m) => s + m.value, 0) / recentHRVReadings.length)
+    : null;
+  const recentRestingHRReadings = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.restingHR ?? [])
+    .filter((m) => m.date >= fourteenDaysBefore && m.date < sessionDateStr);
+  const restingHRBaseline = recentRestingHRReadings.length >= 3
+    ? Math.round(recentRestingHRReadings.reduce((s, m) => s + m.value, 0) / recentRestingHRReadings.length)
+    : null;
+
+  const vo2MaxRecent = exclude.has('recovery') ? [] : (snapshot.healthMetrics?.vo2Max ?? [])
+    .filter((m) => m.date >= threeDaysBefore && m.date <= sessionDateStr);
   const vo2MaxLatest = vo2MaxRecent.length > 0
     ? Math.round(vo2MaxRecent.at(-1).value * 10) / 10
     : null;
-  const bodyWeightOnDay = (snapshot.healthMetrics?.bodyWeight ?? [])
-    .find((m) => m.date === sessionDateStr);
-  const bodyWeightKg = bodyWeightOnDay
-    ? Math.round(bodyWeightOnDay.value * 10) / 10
+  const sevenDaysBefore = new Date(new Date(sessionDateStr).getTime() - 7 * 24 * 60 * 60 * 1000)
+    .toISOString().slice(0, 10);
+  const recentBodyWeight = exclude.has('bodyWeight') ? null : (snapshot.healthMetrics?.bodyWeight ?? [])
+    .filter((m) => m.date >= sevenDaysBefore && m.date <= sessionDateStr)
+    .sort((a, b) => b.date.localeCompare(a.date))[0] ?? null;
+  const bodyWeightKg = recentBodyWeight
+    ? Math.round(recentBodyWeight.value * 10) / 10
     : null;
 
+  // Readiness context (gated on recovery exclusion)
+  const readinessContext = exclude.has('recovery') ? null : (() => {
+    const snap = session.readinessBandSnapshot;
+    if (!snap) return null;
+    return {
+      band: snap.band,
+      dominantSignal: snap.dominantSignal,
+      adaptationApplied: snap.adaptationApplied,
+      userOverrode: snap.userOverrode ?? false,
+      tsbValue: snap.tsbValue ?? null
+    };
+  })();
+
   const isFirstWorkout = earlierSessions.length === 0;
 
   const result = {
@@ -1187,10 +1299,13 @@ export function workoutSummaryContext(snapshot, sessionId) {
     repPrs: repPrs.length > 0 ? repPrs : [],
     nearbyCardio: nearbyCardio.length > 0 ? nearbyCardio : null,
     restingHROnDay: restingHROnDay?.value ?? null,
+    restingHRBaseline,
     hrvOnDay: hrvOnDay?.value ?? null,
+    hrvBaseline,
     vo2MaxLatest,
     sleepNight: sleepNight ?? null,
-    bodyWeightKg
+    bodyWeightKg,
+    readiness: readinessContext
   };
   if (programChange) result.programChange = programChange;
   if (planComparison) result.planComparison = planComparison;
@@ -1290,16 +1405,37 @@ export function workoutSummaryContext(snapshot, sessionId) {
     });
   }
   result.prioritySignals = rankPrioritySignals(workoutSignals);
+  result.excludeNote = buildExcludeNote(exclude);
 
   return result;
 }
 
-export function askContext(snapshot) {
+export function askContext(snapshot, { exclude = new Set() } = {}) {
   const sessions = snapshot.sessions ?? [];
   const lines = [];
 
+  lines.push(`Today's date: ${new Date().toISOString().slice(0, 10)}.`);
   lines.push(`Training overview: ${sessions.length} total workouts logged.`);
 
+  // Recovery context — hours since last session
+  const sortedRecent = sessions
+    .slice()
+    .sort((a, b) => String(completionDateForSession(b)).localeCompare(String(completionDateForSession(a))));
+  const lastSessionDate = sortedRecent[0] ? completionDateForSession(sortedRecent[0]) : null;
+  if (lastSessionDate) {
+    const lastSessionTime = new Date(String(lastSessionDate)).getTime();
+    const hoursSinceLast = Number.isNaN(lastSessionTime) ? -1 : Math.round((Date.now() - lastSessionTime) / (1000 * 60 * 60));
+    if (hoursSinceLast >= 0 && hoursSinceLast < 72) {
+      const recoveryLabel =
+        hoursSinceLast < 12
+          ? 'less than 12 hours ago'
+          : hoursSinceLast < 24
+            ? 'less than 24 hours ago'
+            : `${Math.floor(hoursSinceLast / 24)} day${Math.floor(hoursSinceLast / 24) === 1 ? '' : 's'} ago`;
+      lines.push(`Last session: ${recoveryLabel} (${lastSessionDate}).`);
+    }
+  }
+
   // Training frequency (last 4 weeks)
   const fourWeeksAgo = new Date(Date.now() - 28 * 24 * 60 * 60 * 1000).toISOString();
   const recentCount = sessions.filter((s) => String(completionDateForSession(s)) >= fourWeeksAgo).length;
@@ -1308,10 +1444,68 @@ export function askContext(snapshot) {
     lines.push(`Recent frequency: ${perWeek} sessions/week (last 4 weeks).`);
   }
 
-  // Current program
+  // Current program + week phase (derived from most recent session's stamped context,
+  // not from completedCyclesCount which advances immediately on cycle completion)
   const program = activeProgram(snapshot);
   if (program) {
-    lines.push(`Current program: ${program.name}, ${program.daysPerWeek} days/week, equipment: ${program.equipmentTier ?? 'unknown'}.`);
+    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 currentWeek = latestSession?.historicalContext?.programWeekNumber ?? (Number(program.completedCyclesCount ?? 0) + 1);
+    const weekPhase = 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.');
+    }
+
+    // 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 todayIso = jsDay === 0 ? 7 : jsDay; // 1=Mon … 7=Sun
+      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 = (program.days ?? [])[currentDayIndex]?.title ?? `Day ${currentDayIndex + 1}`;
+      lines.push(`Next session: ${nextDayTitle} on ${dayNames[nextSessionWeekday]} (${whenLabel}).`);
+    }
+
+    // Program days with planned sets
+    const days = program.days ?? [];
+    if (days.length > 0) {
+      lines.push('');
+      lines.push('Program schedule (planned sets):');
+      for (let i = 0; i < days.length; i++) {
+        const day = days[i];
+        const upNext = i === currentDayIndex ? ' [UP NEXT]' : '';
+        lines.push(`  ${day.title ?? `Day ${i + 1}`}${upNext}:`);
+        for (const exercise of day.exercises ?? []) {
+          const sets = exercise.sets ?? [];
+          if (sets.length === 0) continue;
+          // Group identical sets for compact display: e.g. "4×10 @ 100kg"
+          const groups = [];
+          let run = 1;
+          for (let j = 1; j <= sets.length; j++) {
+            const prev = sets[j - 1];
+            const curr = sets[j];
+            if (curr && curr.weight === prev.weight && curr.reps === prev.reps) {
+              run++;
+            } else {
+              groups.push(`${run}×${prev.reps}${prev.weight > 0 ? ` @ ${prev.weight}kg` : ''}`);
+              run = 1;
+            }
+          }
+          const rec = (snapshot.exerciseRecommendations ?? {})[exercise.name];
+          const recLabel = rec ? formatRecommendation(rec) : null;
+          const recSuffix = recLabel ? ` → next: ${recLabel}` : '';
+          lines.push(`    ${exercise.name}: ${groups.join(', ')}${recSuffix}`);
+        }
+      }
+    }
   }
 
   // Best e1RM records (top 15)
@@ -1453,90 +1647,99 @@ export function askContext(snapshot) {
     }
   }
 
-  appendHealthMetricsContext(lines, snapshot.healthMetrics, { recentDays: 14 });
+  appendHealthMetricsContext(lines, snapshot.healthMetrics, { recentDays: 14, exclude });
+  appendExcludeNote(lines, exclude);
 
   return lines.join('\n');
 }
 
-function appendHealthMetricsContext(lines, metrics, { recentDays = 14 } = {}) {
+function appendHealthMetricsContext(lines, metrics, { recentDays = 14, exclude = new Set() } = {}) {
   if (!metrics) return;
 
   const cutoff = new Date(Date.now() - recentDays * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
 
-  const recentWorkouts = (metrics.otherWorkouts ?? []).filter((w) => w.date >= cutoff);
-  if (recentWorkouts.length > 0) {
-    lines.push('');
-    lines.push(`Other workouts (last ${recentDays} days):`);
-    for (const w of recentWorkouts) {
-      const parts = [`${w.durationSecs ? Math.round(w.durationSecs / 60) : '?'} min`];
-      if (w.distanceKm) parts.push(`${w.distanceKm.toFixed(1)} km`);
-      if (w.avgHR) parts.push(`avg HR ${w.avgHR} bpm`);
-      if (w.calories) parts.push(`${w.calories} kcal`);
-      if (w.effortScore) parts.push(`effort ${w.effortScore}/10`);
-      lines.push(`  ${w.date} ${w.workoutType}: ${parts.join(', ')}`);
+  if (!exclude.has('otherWorkouts')) {
+    const recentWorkouts = (metrics.otherWorkouts ?? []).filter((w) => w.date >= cutoff);
+    if (recentWorkouts.length > 0) {
+      lines.push('');
+      lines.push(`Other workouts (last ${recentDays} days):`);
+      for (const w of recentWorkouts) {
+        const parts = [`${w.durationSecs ? Math.round(w.durationSecs / 60) : '?'} min`];
+        if (w.distanceKm) parts.push(`${w.distanceKm.toFixed(1)} km`);
+        if (w.avgHR) parts.push(`avg HR ${w.avgHR} bpm`);
+        if (w.calories) parts.push(`${w.calories} kcal`);
+        if (w.effortScore) parts.push(`effort ${w.effortScore}/10`);
+        lines.push(`  ${w.date} ${w.workoutType}: ${parts.join(', ')}`);
+      }
     }
-  }
 
-  // Weekly cardio volume summary (always last 7 days regardless of recentDays)
-  const sevenDayCutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
-  const weekCardio = (metrics.otherWorkouts ?? []).filter((w) => w.date >= sevenDayCutoff);
-  if (weekCardio.length > 0) {
-    const totalSecs = weekCardio.reduce((sum, w) => sum + (w.durationSecs ?? 0), 0);
-    const totalMins = Math.round(totalSecs / 60);
-    const totalKm = weekCardio.reduce((sum, w) => sum + (w.distanceKm ?? 0), 0);
-    const distPart = totalKm > 0 ? `, ${totalKm.toFixed(1)} km total` : '';
-    lines.push(`Cardio last 7 days: ${weekCardio.length} sessions, ${totalMins} min${distPart}`);
+    // Weekly cardio volume summary (always last 7 days regardless of recentDays)
+    const sevenDayCutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    const weekCardio = (metrics.otherWorkouts ?? []).filter((w) => w.date >= sevenDayCutoff);
+    if (weekCardio.length > 0) {
+      const totalSecs = weekCardio.reduce((sum, w) => sum + (w.durationSecs ?? 0), 0);
+      const totalMins = Math.round(totalSecs / 60);
+      const totalKm = weekCardio.reduce((sum, w) => sum + (w.distanceKm ?? 0), 0);
+      const distPart = totalKm > 0 ? `, ${totalKm.toFixed(1)} km total` : '';
+      lines.push(`Cardio last 7 days: ${weekCardio.length} sessions, ${totalMins} min${distPart}`);
+    }
   }
 
-  const recentRestingHR = (metrics.restingHR ?? []).filter((m) => m.date >= cutoff);
-  if (recentRestingHR.length > 0) {
-    const avg = Math.round(recentRestingHR.reduce((s, m) => s + m.value, 0) / recentRestingHR.length);
-    const latest = recentRestingHR[recentRestingHR.length - 1];
-    lines.push('');
-    lines.push(`Resting HR (last ${recentDays} days): avg ${avg} bpm, latest ${Math.round(latest.value)} bpm (${latest.date})`);
-  }
+  if (!exclude.has('recovery')) {
+    const recentRestingHR = (metrics.restingHR ?? []).filter((m) => m.date >= cutoff);
+    if (recentRestingHR.length > 0) {
+      const avg = Math.round(recentRestingHR.reduce((s, m) => s + m.value, 0) / recentRestingHR.length);
+      const latest = recentRestingHR[recentRestingHR.length - 1];
+      lines.push('');
+      lines.push(`Resting HR (last ${recentDays} days): avg ${avg} bpm, latest ${Math.round(latest.value)} bpm (${latest.date})`);
+    }
 
-  const recentHRV = (metrics.hrv ?? []).filter((m) => m.date >= cutoff);
-  if (recentHRV.length > 0) {
-    const avg = Math.round(recentHRV.reduce((s, m) => s + m.value, 0) / recentHRV.length);
-    const latest = recentHRV[recentHRV.length - 1];
-    lines.push(`HRV (last ${recentDays} days): avg ${avg} ms, latest ${Math.round(latest.value)} ms (${latest.date})`);
-  }
+    const recentHRV = (metrics.hrv ?? []).filter((m) => m.date >= cutoff);
+    if (recentHRV.length > 0) {
+      const avg = Math.round(recentHRV.reduce((s, m) => s + m.value, 0) / recentHRV.length);
+      const latest = recentHRV[recentHRV.length - 1];
+      lines.push(`HRV (last ${recentDays} days): avg ${avg} ms, latest ${Math.round(latest.value)} ms (${latest.date})`);
+    }
 
-  const recentVO2Max = (metrics.vo2Max ?? []).filter((m) => m.date >= cutoff);
-  if (recentVO2Max.length > 0) {
-    const latest = recentVO2Max[recentVO2Max.length - 1];
-    lines.push(`VO2 Max: ${Math.round(latest.value * 10) / 10} ml/kg/min (${latest.date})`);
-  }
+    const recentVO2Max = (metrics.vo2Max ?? []).filter((m) => m.date >= cutoff);
+    if (recentVO2Max.length > 0) {
+      const latest = recentVO2Max[recentVO2Max.length - 1];
+      lines.push(`VO2 Max: ${Math.round(latest.value * 10) / 10} ml/kg/min (${latest.date})`);
+    }
 
-  const recentSleep = (metrics.sleep ?? []).filter((m) => m.date >= cutoff);
-  if (recentSleep.length > 0) {
-    const avgMins = Math.round(recentSleep.reduce((s, m) => s + m.durationMins, 0) / recentSleep.length);
-    const avgHours = (avgMins / 60).toFixed(1);
-    lines.push(`Sleep (last ${recentDays} days): avg ${avgHours}h/night`);
-  }
+    const recentSleep = (metrics.sleep ?? []).filter((m) => m.date >= cutoff);
+    if (recentSleep.length > 0) {
+      const avgMins = Math.round(recentSleep.reduce((s, m) => s + m.durationMins, 0) / recentSleep.length);
+      const avgHours = (avgMins / 60).toFixed(1);
+      const latest = recentSleep[recentSleep.length - 1];
+      const latestHours = (latest.durationMins / 60).toFixed(1);
+      lines.push(`Sleep (last ${recentDays} days): avg ${avgHours}h/night, last night ${latestHours}h (${latest.date})`);
+    }
 
-  const recentBodyWeight = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
-  if (recentBodyWeight.length > 0) {
-    const latest = recentBodyWeight[recentBodyWeight.length - 1];
-    const earliest = recentBodyWeight[0];
-    const delta = (latest.value - earliest.value).toFixed(1);
-    const trend = delta > 0 ? `+${delta}` : delta;
-    lines.push(`Body weight (last ${recentDays} days): latest ${latest.value.toFixed(1)} kg (${latest.date}), ${recentBodyWeight.length} readings, trend ${trend} kg`);
-  }
+    const recentRespiratoryRate = (metrics.respiratoryRate ?? []).filter((m) => m.date >= cutoff);
+    if (recentRespiratoryRate.length > 0) {
+      const avg = recentRespiratoryRate.reduce((s, m) => s + m.value, 0) / recentRespiratoryRate.length;
+      const latest = recentRespiratoryRate[recentRespiratoryRate.length - 1];
+      lines.push(`Respiratory rate (last ${recentDays} days): avg ${avg.toFixed(1)} rpm, latest ${latest.value.toFixed(1)} rpm (${latest.date})`);
+    }
 
-  const recentRespiratoryRate = (metrics.respiratoryRate ?? []).filter((m) => m.date >= cutoff);
-  if (recentRespiratoryRate.length > 0) {
-    const avg = recentRespiratoryRate.reduce((s, m) => s + m.value, 0) / recentRespiratoryRate.length;
-    const latest = recentRespiratoryRate[recentRespiratoryRate.length - 1];
-    lines.push(`Respiratory rate (last ${recentDays} days): avg ${avg.toFixed(1)} rpm, latest ${latest.value.toFixed(1)} rpm (${latest.date})`);
+    const recentBodyTemp = (metrics.bodyTemperature ?? []).filter((m) => m.date >= cutoff);
+    if (recentBodyTemp.length > 0) {
+      const avg = recentBodyTemp.reduce((s, m) => s + m.value, 0) / recentBodyTemp.length;
+      const latest = recentBodyTemp[recentBodyTemp.length - 1];
+      lines.push(`Body temperature (last ${recentDays} days): avg ${avg.toFixed(1)}°C, latest ${latest.value.toFixed(1)}°C (${latest.date})`);
+    }
   }
 
-  const recentBodyTemp = (metrics.bodyTemperature ?? []).filter((m) => m.date >= cutoff);
-  if (recentBodyTemp.length > 0) {
-    const avg = recentBodyTemp.reduce((s, m) => s + m.value, 0) / recentBodyTemp.length;
-    const latest = recentBodyTemp[recentBodyTemp.length - 1];
-    lines.push(`Body temperature (last ${recentDays} days): avg ${avg.toFixed(1)}°C, latest ${latest.value.toFixed(1)}°C (${latest.date})`);
+  if (!exclude.has('bodyWeight')) {
+    const recentBodyWeight = (metrics.bodyWeight ?? []).filter((m) => m.date >= cutoff);
+    if (recentBodyWeight.length > 0) {
+      const latest = recentBodyWeight[recentBodyWeight.length - 1];
+      const earliest = recentBodyWeight[0];
+      const delta = (latest.value - earliest.value).toFixed(1);
+      const trend = delta > 0 ? `+${delta}` : delta;
+      lines.push(`Body weight (last ${recentDays} days): latest ${latest.value.toFixed(1)} kg (${latest.date}), ${recentBodyWeight.length} readings, trend ${trend} kg`);
+    }
   }
 }
 
@@ -1625,7 +1828,7 @@ function computeReadiness(dailyLoads, earliestDate, today, historyDays) {
   };
 }
 
-function trainingLoad(snapshot) {
+export function trainingLoad(snapshot) {
   const metrics = snapshot.healthMetrics;
   const sessions = snapshot.sessions ?? [];
 
@@ -1774,7 +1977,7 @@ function trainingLoad(snapshot) {
   };
 }
 
-function healthSummary(snapshot, days = 14) {
+export function healthSummary(snapshot, days = 14) {
   const metrics = snapshot.healthMetrics;
   const trainingLoadSummary = (() => {
     const tl = trainingLoad(snapshot);
@@ -1826,6 +2029,7 @@ function healthSummary(snapshot, days = 14) {
     },
     sleep: {
       avgHours: recentSleep.length > 0 ? Math.round(recentSleep.reduce((s, m) => s + m.durationMins, 0) / recentSleep.length / 60 * 10) / 10 : null,
+      latestNight: recentSleep.length > 0 ? { hours: Math.round(recentSleep.at(-1).durationMins / 60 * 10) / 10, date: recentSleep.at(-1).date } : null,
       nights: recentSleep.length
     },
     bodyWeight: (() => {
@@ -1859,7 +2063,7 @@ function healthSummary(snapshot, days = 14) {
   };
 }
 
-export function vitalsSummaryContext(snapshot) {
+export function vitalsSummaryContext(snapshot, { exclude = new Set() } = {}) {
   const lines = [];
   lines.push(`Date: ${new Date().toISOString().slice(0, 10)}`);
 
@@ -1899,15 +2103,27 @@ export function vitalsSummaryContext(snapshot) {
     lines.push('No training sessions in the last 7 days.');
   }
 
-  // Current program phase
+  // Current program phase and schedule
   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}).`);
+    }
   }
 
   const vitals = healthSummary(snapshot, 14);
   const vitalsSignals = [];
-  if (vitals.trainingLoad?.available) {
+  if (!exclude.has('trainingLoad') && vitals.trainingLoad?.available) {
     const load = vitals.trainingLoad;
     vitalsSignals.push({
       id: 'training-load',
@@ -1920,34 +2136,51 @@ export function vitalsSummaryContext(snapshot) {
       actionability: 9
     });
   }
-  if (vitals.restingHR?.avg != null && vitals.restingHR.latest?.value != null) {
-    const drift = vitals.restingHR.latest.value - vitals.restingHR.avg;
-    if (Math.abs(drift) >= 3) {
-      vitalsSignals.push({
-        id: 'resting-hr-drift',
-        category: 'recovery',
-        summary: `Resting HR drift ${drift > 0 ? '+' : ''}${drift} bpm vs 14d average`,
-        detail: `Latest ${vitals.restingHR.latest.value} bpm on ${vitals.restingHR.latest.date}, avg ${vitals.restingHR.avg}`,
-        impact: drift > 0 ? 8 : 6,
-        confidence: 8,
-        novelty: 7,
-        actionability: 8
-      });
+  if (!exclude.has('recovery')) {
+    if (vitals.restingHR?.avg != null && vitals.restingHR.latest?.value != null) {
+      const drift = vitals.restingHR.latest.value - vitals.restingHR.avg;
+      if (Math.abs(drift) >= 3) {
+        vitalsSignals.push({
+          id: 'resting-hr-drift',
+          category: 'recovery',
+          summary: `Resting HR drift ${drift > 0 ? '+' : ''}${drift} bpm vs 14d average`,
+          detail: `Latest ${vitals.restingHR.latest.value} bpm on ${vitals.restingHR.latest.date}, avg ${vitals.restingHR.avg}`,
+          impact: drift > 0 ? 8 : 6,
+          confidence: 8,
+          novelty: 7,
+          actionability: 8
+        });
+      }
     }
-  }
-  if (vitals.hrv?.avg != null && vitals.hrv.latest?.value != null) {
-    const drift = vitals.hrv.latest.value - vitals.hrv.avg;
-    if (Math.abs(drift) >= 5) {
-      vitalsSignals.push({
-        id: 'hrv-drift',
-        category: 'recovery',
-        summary: `HRV drift ${drift > 0 ? '+' : ''}${drift} ms vs 14d average`,
-        detail: `Latest ${vitals.hrv.latest.value} ms on ${vitals.hrv.latest.date}, avg ${vitals.hrv.avg}`,
-        impact: drift < 0 ? 8 : 6,
-        confidence: 8,
-        novelty: 7,
-        actionability: 8
-      });
+    if (vitals.hrv?.avg != null && vitals.hrv.latest?.value != null) {
+      const drift = vitals.hrv.latest.value - vitals.hrv.avg;
+      if (Math.abs(drift) >= 5) {
+        vitalsSignals.push({
+          id: 'hrv-drift',
+          category: 'recovery',
+          summary: `HRV drift ${drift > 0 ? '+' : ''}${drift} ms vs 14d average`,
+          detail: `Latest ${vitals.hrv.latest.value} ms on ${vitals.hrv.latest.date}, avg ${vitals.hrv.avg}`,
+          impact: drift < 0 ? 8 : 6,
+          confidence: 8,
+          novelty: 7,
+          actionability: 8
+        });
+      }
+    }
+    if (vitals.sleep?.latestNight != null && vitals.sleep.avgHours != null) {
+      const drift = vitals.sleep.latestNight.hours - vitals.sleep.avgHours;
+      if (Math.abs(drift) >= 1) {
+        vitalsSignals.push({
+          id: 'sleep-drift',
+          category: 'recovery',
+          summary: `Last night's sleep ${drift > 0 ? '+' : ''}${drift.toFixed(1)}h vs 14d average`,
+          detail: `Last night ${vitals.sleep.latestNight.hours}h (${vitals.sleep.latestNight.date}), avg ${vitals.sleep.avgHours}h`,
+          impact: drift < 0 ? 8 : 6,
+          confidence: 9,
+          novelty: 7,
+          actionability: 7
+        });
+      }
     }
   }
   const rankedVitalsSignals = rankPrioritySignals(vitalsSignals);
@@ -1963,12 +2196,33 @@ export function vitalsSummaryContext(snapshot) {
   // Health metrics
   const metrics = snapshot.healthMetrics;
   if (metrics) {
-    appendHealthMetricsContext(lines, metrics, { recentDays: 14 });
+    appendHealthMetricsContext(lines, metrics, { recentDays: 14, exclude });
   }
 
+  appendExcludeNote(lines, exclude);
+
   return lines.join('\n');
 }
 
+function buildExcludeNote(exclude) {
+  if (!exclude || exclude.size === 0) return null;
+  const labels = [];
+  if (exclude.has('recovery')) labels.push('recovery metrics (HR, HRV, sleep, VO2 max)');
+  if (exclude.has('otherWorkouts')) labels.push('non-strength workouts');
+  if (exclude.has('bodyWeight')) labels.push('body weight');
+  if (exclude.has('trainingLoad')) labels.push('training load');
+  if (labels.length === 0) return null;
+  return `Note: The user has opted out of sharing ${labels.join(', ')} with the AI coach. Do not mention these data types or their absence. Instead, go deeper on the training data that is available — more detail on exercise progression, volume trends, and technique cues.`;
+}
+
+function appendExcludeNote(lines, exclude) {
+  const note = buildExcludeNote(exclude);
+  if (note) {
+    lines.push('');
+    lines.push(note);
+  }
+}
+
 function requiredOption(options, primaryKey, legacyKey = null) {
   return options[primaryKey] ?? (legacyKey ? options[legacyKey] : undefined);
 }