incremnt 0.6.0 → 0.6.1

package/README.md

@@ -59,11 +59,8 @@ incremnt login --session-file ~/Downloads/session.json
 | `programs current` | Active program state |
 | `programs list` | All programs |
 | `programs show --id <id>` | Full program detail |
-| `cycles list [--program-id <id>]` | Completed cycle summaries |
-| `cycles show --id <id>` | Details for a completed cycle summary |
 | `exercises history --name <name>` | Set-by-set history for an exercise |
 | `records` | Personal records (best e1RM per exercise) |
-| `goals list` / `goals show --id <id>` | Strength plan goals |
 | `health summary` / `health ai` | Health metrics and AI summary |
 | `training load` | ATL/CTL/TSB and workload context |
 | `ask history` / `ask show --id <id>` | Coach conversation history |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incremnt",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Command-line tool for querying your incremnt strength training data",
   "license": "MIT",
   "type": "module",

package/src/auth.js

@@ -275,7 +275,11 @@ async function fetchRemoteContract(baseUrl, token) {
 
   const payload = await response.json();
   if (payload.contractVersion !== contractVersion) {
-    const error = new Error(`Remote incremnt sync service is incompatible with this CLI. Expected contract v${contractVersion}, got v${payload.contractVersion}.`);
+    const cliBehind = typeof payload.contractVersion === 'number' && payload.contractVersion > contractVersion;
+    const hint = cliBehind
+      ? ' Your CLI is out of date — run `npm install -g incremnt@latest` to upgrade.'
+      : ' The sync service is older than this CLI — wait for the service to redeploy, or use an older CLI version.';
+    const error = new Error(`Remote incremnt sync service is incompatible with this CLI. Expected contract v${contractVersion}, got v${payload.contractVersion}.${hint}`);
     error.code = 'REMOTE_CONTRACT_MISMATCH';
     throw error;
   }

package/src/contract.js

@@ -87,13 +87,15 @@ export const commandSchema = [
   {
     command: 'goals list',
     id: 'goals-list',
-    description: 'List strength plans and lift goals',
+    description: 'Legacy read-only strength plan and lift goal data',
+    hidden: true,
     options: []
   },
   {
     command: 'goals show',
     id: 'goals-show',
-    description: 'Show strength plan goal details',
+    description: 'Legacy read-only strength plan goal details',
+    hidden: true,
     usage: 'goals show --id <plan-id>',
     options: [
       { name: 'id', type: 'string', required: true, description: 'Plan ID' }
@@ -102,7 +104,8 @@ export const commandSchema = [
   {
     command: 'cycles list',
     id: 'cycle-summary-list',
-    description: 'List cycle summaries',
+    description: 'Legacy read-only cycle summaries',
+    hidden: true,
     options: [
       { name: 'program-id', type: 'string', required: false, description: 'Filter by program ID' }
     ]
@@ -110,7 +113,8 @@ export const commandSchema = [
   {
     command: 'cycles show',
     id: 'cycle-summary-show',
-    description: 'Show cycle summary details',
+    description: 'Legacy read-only cycle summary details',
+    hidden: true,
     usage: 'cycles show --id <summary-id>',
     options: [
       { name: 'id', type: 'string', required: true, description: 'Cycle summary ID' }

package/src/format.js

@@ -755,7 +755,7 @@ export function formatHelp(opts = {}) {
     `   incremnt <command> [options]`,
     '',
     header('COMMANDS'),
-    ...commandSchema.map((c) => cmd(c.usage ?? c.command, c.description)),
+    ...commandSchema.filter((c) => !c.hidden).map((c) => cmd(c.usage ?? c.command, c.description)),
     '',
     header('WRITE COMMANDS'),
     ...writeCommandSchema.map((c) => cmd(c.usage ?? c.command, c.description)),

package/src/lib.js

@@ -73,7 +73,15 @@ export async function runCli(argv, stdout, stderr) {
   })[command] ?? command;
 
   const sessionState = await readSessionState();
-  const isAuthenticated = Boolean(sessionState?.session && !isSessionExpired(sessionState.session));
+  const hasTransport = Boolean(
+    sessionState?.session?.transport?.baseUrl
+    || sessionState?.session?.transport?.fixturePath
+  );
+  const isAuthenticated = Boolean(
+    sessionState?.session
+    && !isSessionExpired(sessionState.session)
+    && hasTransport
+  );
 
   if (!command || options.help) {
     await printLogo(stdout);

package/src/openrouter.js

@@ -70,8 +70,7 @@ function exerciseNamesFromContext(source) {
     source.exercises?.map((exercise) => exercise.exerciseName ?? exercise.name),
     source.sessions?.flatMap((session) => session.exercises?.map((exercise) => exercise.exerciseName ?? exercise.name) ?? []),
     source.prsThisWeek?.map((pr) => pr.exerciseName),
-    source.stalledExercises?.map((exercise) => exercise.exerciseName),
-    source.goalProgress?.map((goal) => goal.exerciseName)
+    source.stalledExercises?.map((exercise) => exercise.exerciseName)
   ]);
 }
 
@@ -108,8 +107,7 @@ function includedSectionsForSurface(surface, source) {
     return [
       'week',
       hasItems(source.prsThisWeek) ? 'prs' : null,
-      hasItems(source.stalledExercises) ? 'stalled_exercises' : null,
-      hasItems(source.goalProgress) ? 'goal_progress' : null
+      hasItems(source.stalledExercises) ? 'stalled_exercises' : null
     ].filter(Boolean);
   default:
     return [];
@@ -713,12 +711,6 @@ export function formatCycleContext(ctx) {
     `Program: ${ctx.programName}, Week ${ctx.cycleNumber}${intentLabel}, ${ctx.totalSessions} session(s).`
   ];
 
-  const phaseLines = formatProgramPhaseContext(ctx.programPhase);
-  if (phaseLines.length > 0) {
-    lines.push('');
-    lines.push(...phaseLines);
-  }
-
   if (ctx.prioritySignals?.length > 0) {
     lines.push('');
     lines.push('Priority signals (ranked):');
@@ -798,14 +790,6 @@ export function formatCycleContext(ctx) {
     }
   }
 
-  if (ctx.goalProgress) {
-    lines.push('');
-    lines.push('Goal progress:');
-    for (const g of ctx.goalProgress) {
-      lines.push(`  ${g.exerciseName}: ${g.progressPercent ?? '?'}% toward ${g.targetE1RM} e1RM`);
-    }
-  }
-
   if (ctx.previousCycles?.length > 0) {
     lines.push('');
     lines.push('Previous cycles:');
@@ -963,10 +947,6 @@ export function formatWorkoutContext(ctx) {
     const timeOfDay = hour < 12 ? 'morning' : hour < 17 ? 'afternoon' : 'evening';
     lines.push(`Completed: ${dayNames[d.getUTCDay()]}, ${timeOfDay}.`);
   }
-  if (ctx.programWeekNumber) {
-    const phase = ctx.programProgressionType ? ` (${ctx.programProgressionType})` : '';
-    lines.push(`Program week: ${ctx.programWeekNumber}${phase}.`);
-  }
   if (ctx.sessionsThisWeek) {
     lines.push(`Sessions this week: ${ctx.sessionsThisWeek}.`);
   }
@@ -1201,12 +1181,6 @@ export function formatCheckpointContext(ctx) {
     `Program: ${ctx.programName}, Checkpoint at week ${ctx.checkpointWeek} of ${ctx.totalWeeks}.`
   ];
 
-  const phaseLines = formatProgramPhaseContext(ctx.programPhase);
-  if (phaseLines.length > 0) {
-    lines.push('');
-    lines.push(...phaseLines);
-  }
-
   lines.push('');
   lines.push('Exercise targets:');
   for (const ex of ctx.exercises) {
@@ -1419,10 +1393,6 @@ function formatWeeklyCheckinContext(context) {
   const lines = [];
   lines.push(`Today: ${context.todayIso}`);
   lines.push(`Week range: ${context.weekRangeIso?.start} to ${context.weekRangeIso?.end}`);
-  const phaseLines = formatProgramPhaseContext(context.programPhase);
-  if (phaseLines.length > 0) {
-    lines.push(...phaseLines);
-  }
   lines.push(`Sessions this week: ${context.sessionCount}`);
   if (context.adherencePct != null) {
     lines.push(`Adherence: ${context.completedSets}/${context.plannedSets} sets (${context.adherencePct}%)`);
@@ -1446,47 +1416,9 @@ function formatWeeklyCheckinContext(context) {
     const sign = context.bodyweightDeltaKg >= 0 ? '+' : '';
     lines.push(`Bodyweight 7d delta: ${sign}${context.bodyweightDeltaKg}kg`);
   }
-  if (Array.isArray(context.goalProgress) && context.goalProgress.length > 0) {
-    lines.push('Goal progress:');
-    for (const g of context.goalProgress) {
-      const deadline = g.finishDate ? ` (finish ${g.finishDate})` : '';
-      lines.push(`  - ${g.exerciseName}: ${g.progressPercent}% toward ${g.targetE1RM}kg${deadline}`);
-    }
-  }
   return lines.join('\n');
 }
 
-export function formatProgramPhaseContext(programPhase) {
-  if (!programPhase || typeof programPhase !== 'object') return [];
-  const current = programPhase.current;
-  if (!current?.phase || typeof current.displayWeek !== 'number') return [];
-
-  const describe = (phase) => {
-    if (!phase?.phase) return null;
-    const week = typeof phase.displayWeek === 'number' ? `week ${phase.displayWeek}` : 'week ?';
-    return `${week} ${phase.phase}${phase.isDeload ? ' (deload)' : ''}`;
-  };
-  const describeList = (phases) => {
-    if (!Array.isArray(phases) || phases.length === 0) return null;
-    return phases.map(describe).filter(Boolean).join(', ');
-  };
-
-  const lines = ['Program phase:'];
-  lines.push(`  Current: ${describe(current)}`);
-  const previous = describe(programPhase.previousWeek);
-  if (previous) lines.push(`  Previous: ${previous}`);
-  const next = describe(programPhase.nextWeek);
-  if (next) lines.push(`  Next: ${next}`);
-  if (programPhase.isPostDeloadReturn === true) {
-    lines.push('  Post-deload return: yes');
-  }
-  const range = describeList(programPhase.phasesInRange);
-  if (range) lines.push(`  Range phases: ${range}`);
-  const previousRange = describeList(programPhase.previousRangePhases);
-  if (previousRange) lines.push(`  Previous range phases: ${previousRange}`);
-  return lines;
-}
-
 export async function generateWeeklyCheckinRecap(context, { apiKey, model, timeoutMs, priorCommitment, user, sessionId, contextMetadata } = {}) {
   const contextText = formatWeeklyCheckinContext(context);
   const userLines = [fenceContent('training_data', contextText)];

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}`);
@@ -4102,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();
@@ -4144,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);
@@ -4453,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.
@@ -4532,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) {
@@ -4539,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;
@@ -4576,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);
@@ -4584,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,
@@ -4629,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.`;
+}

package/src/remote.js

@@ -4,8 +4,8 @@ import { executeCoachReadTool as executeLocalCoachReadTool, executeReadCommand }
 import { resolveServiceUrl } from './service-url.js';
 
 function notImplementedError() {
-  const error = new Error('Remote read mode is not implemented yet. Use --input or INCREMNT_SNAPSHOT for now.');
-  error.code = 'REMOTE_NOT_IMPLEMENTED';
+  const error = new Error('No transport configured for this session. Run `incremnt login` to authenticate, or pass --input <file> / set INCREMNT_SNAPSHOT to use a local snapshot. If login keeps failing with a contract-mismatch error, run `npm install -g incremnt@latest` to upgrade the CLI.');
+  error.code = 'NO_TRANSPORT_CONFIGURED';
   return error;
 }
 

package/src/summary-evals.js

@@ -733,6 +733,45 @@ function hasFatigueLanguage(output) {
   return /\b(fatigue|fatigued|underrecovered|recovery debt|fatigue ceiling|limited by recovery|limited by fatigue|accumulated fatigue)\b/i.test(output);
 }
 
+function hasAskFatigueRecoveryLanguage(output) {
+  return hasFatigueLanguage(output)
+    || /\b(?:poor|low|bad|incomplete)\s+recovery\b/i.test(output)
+    || /\bunder[-\s]?recovery\b/i.test(output)
+    || /\brecovery\s+(?:limited|held back|caused|explains|drove|deficit|issue|problem)\b/i.test(output);
+}
+
+function hasAskFatigueRecoveryUncertaintyLanguage(output) {
+  const missingRecoveryData = /\b(?:no|not enough|without|missing|lack(?:ing)?|insufficient)\s+(?:\w+\s+){0,4}?(?:recovery|readiness|vitals?|sleep|hrv|heart rate|data|info|signals?|metrics?)\b/i.test(output);
+  const refusesInference = /\b(?:cannot|can't|do not|don't|does not|doesn't|would not|wouldn't|not enough|isn't enough|is not enough|no basis to|hard to)\s+(?:\w+\s+){0,12}?(?:infer|tie|connect|attribute|blame|claim|say|show|prove|know|call)\s+(?:\w+\s+){0,12}?(?:fatigue|recovery|readiness|why)\b/i.test(output);
+  const recoveryDoesNotExplain = /\b(?:fatigue|recovery|readiness)\b\s+(?:\w+\s+){0,10}?(?:cannot|can't|does not|doesn't|would not|wouldn't|isn't|is not)\s+(?:\w+\s+){0,10}?(?:explain|prove|show|tell|account for)\b/i.test(output);
+  return missingRecoveryData || refusesInference || recoveryDoesNotExplain;
+}
+
+function hasAskPositiveFatigueRecoveryAttribution(output) {
+  const concept = String.raw`(?:fatigue|fatigued|under[-\s]?recovered|under[-\s]?recovery|poor recovery|low recovery|incomplete recovery|recovery debt|fatigue ceiling|accumulated fatigue)`;
+  const causeVerb = String.raw`(?:because|due to|caused by|from|reflects?|suggests?|indicates?|points? to|explains?|limited|held back|drove|contributed to|tied to|tie\s+\w+\s+to)`;
+  const patterns = [
+    new RegExp(String.raw`\b${causeVerb}\b.{0,80}\b${concept}\b`, 'gi'),
+    new RegExp(String.raw`\b${concept}\b.{0,80}\b(?:caused|limited|held back|explains?|drove|led to|contributed to|accounts? for)\b`, 'gi')
+  ];
+  for (const pattern of patterns) {
+    for (const match of output.matchAll(pattern)) {
+      const start = Math.max(0, (match.index ?? 0) - 40);
+      const window = output.slice(start, (match.index ?? 0) + match[0].length);
+      if (!/\b(?:not|no|cannot|can't|doesn't|does not|would not|wouldn't|isn't|is not)\b/i.test(window)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function hasUnsupportedAskFatigueRecoveryClaim(output) {
+  if (!hasAskFatigueRecoveryLanguage(output)) return false;
+  if (hasAskPositiveFatigueRecoveryAttribution(output)) return true;
+  return !hasAskFatigueRecoveryUncertaintyLanguage(output);
+}
+
 function matchesHistoricalFamilyName(claimName, actualName) {
   const claimVariants = new Set(historicalExerciseVariants(claimName));
   const actualVariants = new Set(historicalExerciseVariants(actualName));
@@ -1182,7 +1221,7 @@ function evaluateAskClaims(output, snapshot, testCase) {
     }
   }
 
-  if (hasFatigueLanguage(normalized) && !hasAskFatigueSupport(snapshot)) {
+  if (hasUnsupportedAskFatigueRecoveryClaim(normalized) && !hasAskFatigueSupport(snapshot)) {
     failures.push('Ask answer uses fatigue/recovery language but the snapshot has no recent vitals, sleep, or rep-dropoff signals to support it.');
   }
 

package/src/sync-service.js

@@ -21,6 +21,7 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'weekly-checkin-current': 30,
   'weekly-checkin-ack': 30,
   'weekly-checkin-start': 10,
+  'weekly-digest-current': 30,
   'dev-login': 10,
   'device-start': 20,
   'device-poll': 300,
@@ -1050,6 +1051,10 @@ function routeRequest(url, method) {
     return { command: 'weekly-checkin-start', options: {} };
   }
 
+  if (pathname === '/cli/weekly-digest/current') {
+    return { command: 'weekly-digest-current', options: {} };
+  }
+
   if (pathname === '/cli/health/ai') {
     return {
       command: 'health-ai',
@@ -1434,41 +1439,6 @@ function routeRequest(url, method) {
   return null;
 }
 
-/// Formats a `ProgramPhaseWindowContext` (sent by iOS in the request body) as
-/// a short text prelude prepended to the AI context. Without this the model
-/// would have to infer "is this a deload week / was last week deload?" from
-/// session prose; with it the structured phase facts are explicit.
-function formatProgramPhasePrelude(programPhase) {
-  if (!programPhase || typeof programPhase !== 'object') return null;
-  const current = programPhase.current;
-  const previous = programPhase.previousWeek;
-  const next = programPhase.nextWeek;
-  if (!current?.phase || typeof current.displayWeek !== 'number') return null;
-  const describe = (phase) => {
-    if (!phase?.phase) return null;
-    const week = typeof phase.displayWeek === 'number' ? `week ${phase.displayWeek}` : 'week ?';
-    return `${week} (${phase.phase})${phase.isDeload ? ' · deload week' : ''}`;
-  };
-  const describeList = (phases) => {
-    if (!Array.isArray(phases) || phases.length === 0) return null;
-    return phases.map(describe).filter(Boolean).join(', ');
-  };
-  const lines = [
-    '[Program phase]',
-    `- Current: ${describe(current)}`
-  ];
-  if (previous?.phase) lines.push(`- Previous: ${describe(previous)}`);
-  if (next?.phase) lines.push(`- Next: ${describe(next)}`);
-  if (programPhase.isPostDeloadReturn === true) {
-    lines.push('- Post-deload return: yes (last week was deload, this week is build)');
-  }
-  const range = describeList(programPhase.phasesInRange);
-  if (range) lines.push(`- Range phases: ${range}`);
-  const previousRange = describeList(programPhase.previousRangePhases);
-  if (previousRange) lines.push(`- Previous range phases: ${previousRange}`);
-  return lines.join('\n');
-}
-
 export function formatIncrementScorePrelude(snapshots) {
   if (!Array.isArray(snapshots) || snapshots.length === 0) return null;
   const latest = snapshots[0];
@@ -2021,6 +1991,7 @@ export function createSyncServiceRequestHandler({
   pushMobileSyncChangesForAccount = null,
   insertScoreSnapshotsForAccount = null,
   listScoreSnapshotsForAccount = null,
+  getCurrentWeeklyScoreDigestForAccount = null,
   // Social
   social = null,
   onError = null
@@ -3488,6 +3459,43 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
+      if (route.command === 'weekly-digest-current') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/weekly-digest/current.');
+          return;
+        }
+        if (!getCurrentWeeklyScoreDigestForAccount) {
+          json(response, 503, { error: 'Weekly digest not available' });
+          return;
+        }
+        try {
+          const row = await getCurrentWeeklyScoreDigestForAccount(account);
+          if (!row) {
+            response.writeHead(204);
+            response.end();
+            return;
+          }
+          json(response, 200, {
+            id: row.id,
+            weekStartDate: row.weekStartDate,
+            status: row.status,
+            score: row.score,
+            scoreDelta: row.scoreDelta,
+            components: row.components,
+            componentsDelta: row.componentsDelta,
+            signals: row.signals,
+            observation: row.observation,
+            formulaVersion: row.formulaVersion,
+            generatedAt: row.generatedAt,
+            seenAt: row.seenAt,
+          });
+        } catch (err) {
+          console.error('Weekly digest read error:', err.message);
+          json(response, 500, { error: 'Failed to read weekly digest' });
+        }
+        return;
+      }
+
       let snapshot;
       try {
         snapshot = loadSnapshotForAccount
@@ -3707,7 +3715,10 @@ export function createSyncServiceRequestHandler({
             if (openrouterKey && generateWeeklyCheckinRecapImpl && generateCheckinQuestionsImpl) {
               try {
                 const { weeklyCheckinContext } = await import('./queries.js');
-                const ctx = weeklyCheckinContext(snapshot, account.id, {});
+                // Anchor to row.weekStartDate so lazy-gen describes the
+                // canonical week, matching cron behaviour (onemore-8oc5).
+                const referenceNow = new Date(`${row.weekStartDate}T23:59:59.999Z`);
+                const ctx = weeklyCheckinContext(snapshot, account.id, { now: referenceNow });
                 if (ctx) {
                   let priorCommitmentRow = null;
                   if (listActiveCoachCommitmentsForAccount) {
@@ -4160,13 +4171,9 @@ export function createSyncServiceRequestHandler({
           ? queries.askRoutedContext(snapshot, question, { exclude, coachFacts })
           : { context: queries.askContext(snapshot, { exclude }), metadata: { route: 'legacy' } };
         const persistedKind = persistedConversation?.kind ?? (conversationId?.startsWith('weekly-checkin:') ? 'weekly-checkin' : 'ask');
-        const serverProgramPhase = persistedKind === 'weekly-checkin'
-          ? queries.weeklyCheckinContext?.(snapshot, account.id)?.programPhase
-          : null;
-        const programPhasePrelude = formatProgramPhasePrelude(body?.programPhase ?? serverProgramPhase);
         const incrementScorePrelude = formatIncrementScorePrelude(scoreSnapshots);
 
-        const preludes = [programPhasePrelude, incrementScorePrelude].filter(Boolean);
+        const preludes = [incrementScorePrelude].filter(Boolean);
         const ctx = preludes.length > 0
           ? `${preludes.join('\n\n')}\n\n${routedContext.context}`
           : routedContext.context;