incremnt 0.1.10 → 0.1.12

package/package.json

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

package/src/contract.js

@@ -98,6 +98,23 @@ export const commandSchema = [
     options: [
       { name: 'id', type: 'string', required: true, description: 'Plan ID' }
     ]
+  },
+  {
+    command: 'cycles list',
+    id: 'cycle-summary-list',
+    description: 'List cycle summaries',
+    options: [
+      { name: 'program-id', type: 'string', required: false, description: 'Filter by program ID' }
+    ]
+  },
+  {
+    command: 'cycles show',
+    id: 'cycle-summary-show',
+    description: 'Show cycle summary details',
+    usage: 'cycles show --id <summary-id>',
+    options: [
+      { name: 'id', type: 'string', required: true, description: 'Cycle summary ID' }
+    ]
   }
 ];
 

package/src/format.js

@@ -145,6 +145,14 @@ function formatSessionShow(payload) {
     lines.push(keyValue('Calories', `${payload.activeCalories} kcal`));
   }
 
+  if (payload.aiCoachNotes) {
+    lines.push('');
+    lines.push(` ${chalk.bold('AI Summary')}`);
+    for (const line of payload.aiCoachNotes.split('\n')) {
+      lines.push(`   ${line}`);
+    }
+  }
+
   return lines.join('\n');
 }
 
@@ -403,6 +411,58 @@ function formatProposalsList(payload) {
   return lines.join('\n');
 }
 
+function formatCycleSummaryList(payload) {
+  if (!Array.isArray(payload) || payload.length === 0) {
+    return 'No cycle summaries found.';
+  }
+
+  const lines = [header('CYCLE SUMMARIES'), ''];
+
+  for (const summary of payload) {
+    const date = formatShortDate(summary.completedDate);
+    const sets = `${summary.totalSetsCompleted}/${summary.totalSetsPlanned} sets`;
+    const progressions = summary.progressionCount > 0 ? `${summary.progressionCount} progressions` : '';
+    const ai = summary.hasAISummary ? chalk.green('AI') : '';
+    const parts = [chalk.dim(sets), progressions ? chalk.dim(progressions) : '', ai].filter(Boolean);
+
+    lines.push(` ${chalk.bold(date)}  ${summary.programName}${dimDot()}${parts.join(dimDot())}`);
+  }
+
+  return lines.join('\n');
+}
+
+function formatCycleSummaryShow(payload) {
+  if (!payload) {
+    return 'Cycle summary not found.';
+  }
+
+  const date = formatDayAndDate(payload.completedDate);
+  const lines = [` ${chalk.bold('CYCLE SUMMARY')}${dimDot()}${date}`, ''];
+
+  lines.push(keyValue('Program', payload.programName));
+  lines.push(keyValue('Sets', `${payload.totalSetsCompleted}/${payload.totalSetsPlanned}`));
+
+  if (payload.progressionUpdates.length > 0) {
+    lines.push('');
+    lines.push(` ${chalk.bold('Progressions')}`);
+
+    for (const update of payload.progressionUpdates) {
+      const icon = update.kind === 'deload' ? chalk.yellow('\u2193') : chalk.green('\u2191');
+      lines.push(`   ${icon} ${update.exerciseName.padEnd(24)} ${chalk.dim(update.change)}`);
+    }
+  }
+
+  if (payload.aiSummary) {
+    lines.push('');
+    lines.push(` ${chalk.bold('AI Summary')}`);
+    for (const line of payload.aiSummary.split('\n')) {
+      lines.push(`   ${line}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
 function formatProposalDismissed(payload) {
   if (!payload) return 'Proposal not found.';
   return ` Proposal ${chalk.bold(payload.id)} dismissed.`;
@@ -410,11 +470,16 @@ function formatProposalDismissed(payload) {
 
 // --- Main export ---
 
-export function formatHelp() {
+export function formatHelp(opts = {}) {
   const cmd = (name, desc) => `   ${chalk.bold(name.padEnd(38))} ${chalk.dim(desc)}`;
+  const authBadge = opts.isAuthenticated
+    ? chalk.green('\u25cf Authenticated')
+    : chalk.yellow("\u25cf Authentication required - run 'incremnt login'");
+
   const lines = [
     '',
     header('INCREMNT') + dimDot() + chalk.dim('strength tracking CLI'),
+    ` ${authBadge}`,
     '',
     header('USAGE'),
     `   incremnt <command> [options]`,
@@ -459,6 +524,8 @@ export function formatPretty(command, payload) {
     'program-detail': formatProgramDetail,
     'planned-vs-actual': formatPlannedVsActual,
     'why-did-this-change': formatWhyDidThisChange,
+    'cycle-summary-list': formatCycleSummaryList,
+    'cycle-summary-show': formatCycleSummaryShow,
     'programs-propose': formatProposalCreated,
     'programs-proposals': formatProposalsList,
     'proposal-dismiss': formatProposalDismissed

package/src/lib.js

@@ -12,6 +12,7 @@ import {
 import { clearSessionState, isSessionExpired, readSessionState, resolveConfigDir } from './state.js';
 import { createTransport } from './transport.js';
 import { formatPretty, formatHelp } from './format.js';
+import { printLogo } from './logo.js';
 
 function parseArgs(argv) {
   const commandTokens = [];
@@ -66,12 +67,15 @@ export async function runCli(argv, stdout, stderr) {
     dismiss: 'proposal-dismiss'
   })[command] ?? command;
 
+  const sessionState = await readSessionState();
+  const isAuthenticated = Boolean(sessionState?.session && !isSessionExpired(sessionState.session));
+
   if (!command || options.help) {
-    stdout.write(`${formatHelp()}\n`);
+    printLogo(stdout);
+    stdout.write(`${formatHelp({ isAuthenticated })}\n`);
     return 0;
   }
 
-  const sessionState = await readSessionState();
   const transport = await createTransport(options, sessionState);
 
   if (normalizedCommand === 'status') {

package/src/logo.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+
+const startColor = { r: 0, g: 255, b: 163 }; // #00ffa3
+const endColor = { r: 59, g: 130, b: 246 };  // #3b82f6
+
+function interpolateColor(start, end, factor) {
+  const r = Math.round(start.r + (end.r - start.r) * factor);
+  const g = Math.round(start.g + (end.g - start.g) * factor);
+  const b = Math.round(start.b + (end.b - start.b) * factor);
+  return { r, g, b };
+}
+
+// Extracted from figlet 'ANSI Regular' output for 'INCREMNT'
+// We use '#' in source so the ASCII art stays ASCII-only and easy to edit,
+// then render as '█' block characters at runtime.
+const rawLines = [
+  '## ###    ##  ###### ######  ####### ###    ### ###    ## ######## ',
+  '## ####   ## ##      ##   ## ##      ####  #### ####   ##    ##    ',
+  '## ## ##  ## ##      ######  #####   ## #### ## ## ##  ##    ##    ',
+  '## ##  ## ## ##      ##   ## ##      ##  ##  ## ##  ## ##    ##    ',
+  '## ##   ####  ###### ##   ## ####### ##      ## ##   ####    ##    '
+];
+
+// 3D Drop Shadow offset exactly like Gemini CLI
+const SHADOW_OFFSET_X = 1;
+const SHADOW_OFFSET_Y = 1;
+
+const totalLines = 5 + SHADOW_OFFSET_Y;
+const lineLength = rawLines[0].length + SHADOW_OFFSET_X;
+
+export function printLogo(stdout = process.stdout) {
+  // Gradient starts at the 'M' character position
+  // I: 0, N: 3, C: 14, R: 21, E: 29, M: 37
+  const gradientStartIdx = 37;
+
+  stdout.write('\n');
+  for (let r = 0; r < totalLines; r++) {
+    let lineStr = '';
+
+    for (let c = 0; c < lineLength; c++) {
+      const fgY = r;
+      const fgX = c;
+      const hasFg = (fgY >= 0 && fgY < 5 && fgX >= 0 && fgX < rawLines[0].length && rawLines[fgY][fgX] === '#');
+
+      const bgY = r - SHADOW_OFFSET_Y;
+      const bgX = c - SHADOW_OFFSET_X;
+      const hasBg = (bgY >= 0 && bgY < 5 && bgX >= 0 && bgX < rawLines[0].length && rawLines[bgY][bgX] === '#');
+
+      if (hasFg) {
+        if (fgX < gradientStartIdx) {
+          lineStr += chalk.white('█');
+        } else {
+          const factor = Math.max(0, Math.min(1, (fgX - gradientStartIdx) / (rawLines[0].length - gradientStartIdx - 2)));
+          const col = interpolateColor(startColor, endColor, factor);
+          lineStr += chalk.rgb(col.r, col.g, col.b)('█');
+        }
+      } else if (hasBg) {
+        if (bgX < gradientStartIdx) {
+          lineStr += chalk.rgb(55, 55, 65)('█');
+        } else {
+          const factor = Math.max(0, Math.min(1, (bgX - gradientStartIdx) / (rawLines[0].length - gradientStartIdx - 2)));
+          const col = interpolateColor(startColor, endColor, factor);
+          const shadowFactor = 0.35;
+          lineStr += chalk.rgb(Math.round(col.r * shadowFactor), Math.round(col.g * shadowFactor), Math.round(col.b * shadowFactor))('█');
+        }
+      } else {
+        lineStr += ' ';
+      }
+    }
+    stdout.write(lineStr + '\n');
+  }
+  stdout.write('\n');
+}

package/src/openrouter.js

@@ -1,17 +1,26 @@
 const DEFAULT_MODEL = 'meta-llama/llama-3.1-8b-instruct:free';
 const DEFAULT_TIMEOUT_MS = 15_000;
-const DEFAULT_MAX_TOKENS = 300;
+const DEFAULT_MAX_TOKENS = 500;
 
-const SYSTEM_PROMPT = `You are a strength coach writing a brief note after reviewing a trainee's week of training. Write 2-3 short paragraphs separated by blank lines.
+const CYCLE_SUMMARY_PROMPT = `You are a strength coach reviewing a trainee's completed training cycle (typically one week). Write 3-4 short paragraphs separated by blank lines.
+
+Your job is to give a cycle-level review — not a session-by-session recap. The app already shows set completion rate, individual session breakdowns, and deload adjustments — do NOT repeat any of that. Synthesize across the cycle.
+
+Cover these in order of relevance (skip any that don't apply):
+1. Overall cycle assessment: was this a build/deload/peak week? Did volume and intensity match the intent? If it was a deload, don't flag low numbers as a problem.
+2. Progression commentary: the app made auto-progression decisions listed below. Comment on whether they look right given the data.
+3. Multi-cycle trends: if previous cycle data is provided, note meaningful trends. Don't force trends where there aren't any.
+4. Goal progress: if the trainee has strength goals, comment on trajectory.
+5. One concrete thing to watch or change next cycle. Be specific.
 
 Rules:
-- Reference specific exercises, weights, and reps from the data. Use numbers, not vague praise.
+- Only state what the data shows. Never claim how something "felt."
+- Reference specific exercises, weights, and reps. Use numbers, not vague praise.
 - If there are PRs, mention them matter-of-factly. Do not celebrate or inflate them.
-- Note what went well and what lagged, with specifics.
-- End with one concrete suggestion for next week. Be specific about which exercise and what to change.
-- Write like a real person texting a training partner — short sentences, no filler, no cheerleading.
-- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, highlighting.
-- Never use -ing clauses that add fake depth ("indicating progressive overload", "demonstrating strength gains").
+- If exercises were swapped from the plan, note the pattern and ask about it if recurring.
+- Write like a training partner looking at a logbook, not a motivational coach. Short sentences, no filler, no cheerleading. Questions are good.
+- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, highlighting, smooth, controlled.
+- Never use -ing clauses that add fake depth.
 - No bullet points or lists.`;
 
 export async function generateCoachingSummary(cycleContext, { apiKey, model, timeoutMs } = {}) {
@@ -35,7 +44,7 @@ export async function generateCoachingSummary(cycleContext, { apiKey, model, tim
       body: JSON.stringify({
         model: resolvedModel,
         messages: [
-          { role: 'system', content: SYSTEM_PROMPT },
+          { role: 'system', content: CYCLE_SUMMARY_PROMPT },
           { role: 'user', content: userContent }
         ],
         max_tokens: DEFAULT_MAX_TOKENS,
@@ -61,15 +70,30 @@ export async function generateCoachingSummary(cycleContext, { apiKey, model, tim
   }
 }
 
-function formatCycleContext(ctx) {
+export function formatCycleContext(ctx) {
+  const intentLabel = ctx.cycleIntent ? ` (${ctx.cycleIntent})` : '';
   const lines = [
-    `Program: ${ctx.programName}, Week ${ctx.cycleNumber}, ${ctx.totalSessions} session(s).`
+    `Program: ${ctx.programName}, Week ${ctx.cycleNumber}${intentLabel}, ${ctx.totalSessions} session(s).`
   ];
 
+  if (ctx.setCompletionRate) {
+    const pct = ctx.setCompletionRate.planned > 0
+      ? Math.round(ctx.setCompletionRate.completed / ctx.setCompletionRate.planned * 100)
+      : 0;
+    lines.push(`Completion: ${ctx.setCompletionRate.completed}/${ctx.setCompletionRate.planned} sets (${pct}%).`);
+  }
+
+  if (ctx.adaptationNote) {
+    lines.push(`Adaptation: ${ctx.adaptationNote}`);
+  }
+
+  lines.push('');
+  lines.push('Sessions:');
   for (const session of ctx.sessions) {
     const parts = [session.dayName || 'Session'];
     if (session.totalVolume) parts.push(`${session.totalVolume} kg volume`);
     if (session.effortScore) parts.push(`effort ${session.effortScore}/10`);
+    if (session.averageHeartRate) parts.push(`avg HR ${session.averageHeartRate}`);
     lines.push(parts.join(', '));
 
     for (const ex of session.exercises) {
@@ -84,32 +108,80 @@ function formatCycleContext(ctx) {
   }
 
   if (ctx.prsThisCycle.length > 0) {
-    lines.push('PRs this week:');
+    lines.push('');
+    lines.push('PRs this cycle:');
     for (const pr of ctx.prsThisCycle) {
       lines.push(`  ${pr.exerciseName}: ${pr.weight}×${pr.reps} (e1RM ${pr.estimatedOneRM})`);
     }
   }
 
+  if (ctx.progressionDecisions?.length > 0) {
+    lines.push('');
+    lines.push('Progression decisions made by the app:');
+    for (const pd of ctx.progressionDecisions) {
+      const detail = pd.detail ? ` (${pd.detail})` : '';
+      const kind = pd.kind ? `[${pd.kind}] ` : '';
+      lines.push(`  ${pd.exerciseName}: ${kind}${pd.action}${detail}`);
+    }
+  }
+
+  if (ctx.swapPatterns?.length > 0) {
+    lines.push('');
+    lines.push('Exercise swaps:');
+    for (const sp of ctx.swapPatterns) {
+      lines.push(`  ${sp.original} → ${sp.replacement} (${sp.count} of ${ctx.totalSessions} sessions)`);
+    }
+  }
+
   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:');
+    for (const pc of ctx.previousCycles) {
+      const summaryLine = pc.previousAISummary
+        ? `\n    Coach noted: "${pc.previousAISummary.split('\n')[0].slice(0, 120)}"`
+        : '';
+      lines.push(`  Week ${pc.weekNumber}: ${pc.sessionCount} sessions, ${pc.totalVolume} kg total volume${summaryLine}`);
+    }
+  }
+
+  if (ctx.exerciseTrends?.length > 0) {
+    lines.push('');
+    lines.push('Exercise trends (last 3 cycles):');
+    for (const et of ctx.exerciseTrends) {
+      const trendStr = et.trend.map((t) => t.e1RM).join(' → ');
+      lines.push(`  ${et.exerciseName} e1RM: ${trendStr}`);
+    }
+  }
+
   return lines.join('\n');
 }
 
-export const WORKOUT_COACH_PROMPT = `You are a strength coach writing a brief note after reviewing one training session. Write 2-3 short paragraphs separated by blank lines.
+export const WORKOUT_COACH_PROMPT = `You are reviewing a training session log. Write 2-3 short paragraphs separated by blank lines.
+
+Your job is to surface things the user wouldn't notice from glancing at their workout summary. The app already shows them PRs, total volume, effort score, and exercise breakdown — do NOT repeat any of that.
+
+Focus on:
+- Plan deviations: exercises swapped, skipped, or added vs the plan. Ask why if something looks unusual.
+- Set completion: if they did fewer sets than planned on an exercise, note it and ask about it.
+- Cross-session patterns: trends across recent sessions (volume direction on specific lifts, consistent cutoffs, same weight for weeks).
+- Ask 1-2 genuine questions about choices that look interesting or unusual.
 
 Rules:
-- Reference specific exercises, weights, and reps from the data. Use numbers, not vague praise.
-- If there are PRs, mention them matter-of-factly. Do not celebrate or inflate them.
-- Compare volume or effort to recent sessions if the data is there. Just state what changed.
-- End with one concrete suggestion for next session. Be specific about which exercise and what to try.
-- Write like a real person texting a training partner — short sentences, no filler, no cheerleading.
-- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, highlighting.
+- Only state what the data shows. Never claim how something "felt" — you have numbers, not feelings.
+- Never use words like: impressive, crushed, solid, demonstrating, significant, incredible, fantastic, smooth, controlled.
 - Never use -ing clauses that add fake depth ("indicating progressive overload", "demonstrating strength gains").
+- Never say things "felt smooth", "felt controlled", "feels about average" — you cannot know this.
+- Never restate PRs, total volume, or effort score — the user already sees these in the app.
+- Write like a training partner looking at a logbook, not a motivational coach.
+- Short sentences, no filler, no cheerleading. Questions are good.
 - No bullet points or lists.`;
 
 export async function generateWorkoutCoachingSummary(workoutContext, { apiKey, model, timeoutMs } = {}) {
@@ -189,5 +261,24 @@ export function formatWorkoutContext(ctx) {
     }
   }
 
+  if (ctx.planComparison) {
+    const planLines = [];
+    if (ctx.planComparison.skipped.length > 0) {
+      planLines.push(`  Skipped: ${ctx.planComparison.skipped.join(', ')}`);
+    }
+    if (ctx.planComparison.added.length > 0) {
+      planLines.push(`  Added: ${ctx.planComparison.added.join(', ')}`);
+    }
+    for (const sc of ctx.planComparison.setsComparison) {
+      if (sc.completed !== sc.planned) {
+        planLines.push(`  ${sc.exercise}: ${sc.completed}/${sc.planned} sets`);
+      }
+    }
+    if (planLines.length > 0) {
+      lines.push('Plan comparison:');
+      lines.push(...planLines);
+    }
+  }
+
   return lines.join('\n');
 }

package/src/queries.js

@@ -2,6 +2,44 @@ function completionDateForSession(session) {
   return session.completedAt ?? session.summary?.date ?? session.date;
 }
 
+function buildPlanComparison(session, performedExercises, plannedExercises) {
+  if (!Array.isArray(plannedExercises) || plannedExercises.length === 0) {
+    return undefined;
+  }
+
+  const plannedNames = plannedExercises.map((exercise) =>
+    normalizeExerciseName(exercise.name ?? exercise.exerciseName)
+  );
+  const performedNames = performedExercises.map((exercise) =>
+    normalizeExerciseName(exercise.exerciseName)
+  );
+
+  const skipped = plannedExercises
+    .filter((exercise) => !performedNames.includes(normalizeExerciseName(exercise.name ?? exercise.exerciseName)))
+    .map((exercise) => exercise.name ?? exercise.exerciseName);
+
+  const added = (session.exercises ?? [])
+    .filter((exercise) => !plannedNames.includes(normalizeExerciseName(exercise.name)))
+    .map((exercise) => exercise.name);
+
+  const setsComparison = plannedExercises
+    .filter((exercise) => performedNames.includes(normalizeExerciseName(exercise.name ?? exercise.exerciseName)))
+    .map((planned) => {
+      const plannedName = planned.name ?? planned.exerciseName;
+      const performed = (session.exercises ?? []).find(
+        (exercise) => normalizeExerciseName(exercise.name) === normalizeExerciseName(plannedName)
+      );
+      const completedSets = (performed?.sets ?? []).filter((set) => set.isComplete).length;
+      return {
+        exercise: plannedName,
+        planned: Array.isArray(planned.sets) ? planned.sets.length : (planned.targetSets ?? []).length,
+        completed: completedSets
+      };
+    });
+
+  return { skipped, added, setsComparison };
+}
+
 function sessionSummary(session) {
   return {
     sessionId: session.id,
@@ -19,7 +57,8 @@ function sessionSummary(session) {
     exerciseCount: (session.exercises ?? []).length,
     recommendations: session.recommendations ?? {},
     historicalContext: session.historicalContext ?? null,
-    prescriptionSnapshot: session.prescriptionSnapshot ?? null
+    prescriptionSnapshot: session.prescriptionSnapshot ?? null,
+    aiCoachNotes: session.aiCoachNotes ?? null
   };
 }
 
@@ -349,6 +388,43 @@ export function goalDetail(snapshot, planId) {
   };
 }
 
+export function cycleSummaryList(snapshot, programId) {
+  const summaries = snapshot.cycleSummaries ?? [];
+  const filtered = programId
+    ? summaries.filter((s) => s.programId === programId)
+    : summaries;
+
+  return [...filtered]
+    .sort((a, b) => String(b.completedDate).localeCompare(String(a.completedDate)))
+    .map((s) => ({
+      id: s.id,
+      programId: s.programId,
+      programName: s.programName,
+      completedDate: s.completedDate,
+      totalSetsCompleted: s.totalSetsCompleted ?? 0,
+      totalSetsPlanned: s.totalSetsPlanned ?? 0,
+      progressionCount: (s.progressionUpdates ?? []).length,
+      hasAISummary: !!s.aiSummary
+    }));
+}
+
+export function cycleSummaryShow(snapshot, summaryId) {
+  const summaries = snapshot.cycleSummaries ?? [];
+  const summary = summaries.find((s) => s.id === summaryId);
+  if (!summary) return null;
+
+  return {
+    id: summary.id,
+    programId: summary.programId,
+    programName: summary.programName,
+    completedDate: summary.completedDate,
+    totalSetsCompleted: summary.totalSetsCompleted ?? 0,
+    totalSetsPlanned: summary.totalSetsPlanned ?? 0,
+    progressionUpdates: summary.progressionUpdates ?? [],
+    aiSummary: summary.aiSummary ?? null
+  };
+}
+
 export function cycleSummaryContext(snapshot, programId) {
   const programs = snapshot.programs ?? [];
   const program = programId
@@ -376,6 +452,10 @@ export function cycleSummaryContext(snapshot, programId) {
 
   if (cycleSessions.length === 0) return null;
 
+  const firstSession = cycleSessions[0];
+  const cycleIntent = firstSession?.historicalContext?.programProgressionType ?? null;
+  const adaptationNote = firstSession?.historicalContext?.latestAdaptationSummary ?? null;
+
   const priorSessions = (snapshot.sessions ?? []).filter(
     (s) =>
       s.programId === program.id &&
@@ -452,6 +532,89 @@ export function cycleSummaryContext(snapshot, programId) {
     };
   });
 
+  // Group prior sessions by week number for multi-cycle data
+  const sessionsByWeek = new Map();
+  for (const s of priorSessions) {
+    const wk = s.historicalContext?.programWeekNumber;
+    if (wk == null) continue;
+    if (!sessionsByWeek.has(wk)) sessionsByWeek.set(wk, []);
+    sessionsByWeek.get(wk).push(s);
+  }
+
+  // Build previous cycle summaries (last 2 weeks before current, most recent first)
+  const priorWeeks = [...sessionsByWeek.keys()].sort((a, b) => b - a).slice(0, 2);
+  const cycleSummariesArr = snapshot.cycleSummaries ?? [];
+  const programCycleSummaries = cycleSummariesArr
+    .filter((cs) => cs.programId === program.id)
+    .sort((a, b) => String(b.completedDate).localeCompare(String(a.completedDate)));
+
+  const previousCycles = priorWeeks.map((wk, idx) => {
+    const weekSessions = sessionsByWeek.get(wk);
+    const totalVolume = weekSessions.reduce((sum, s) => sum + (s.summary?.totalVolume ?? s.volume ?? 0), 0);
+    const matchingCycleSummary = programCycleSummaries[idx] ?? null;
+
+    return {
+      weekNumber: wk,
+      sessionCount: weekSessions.length,
+      totalVolume: Math.round(totalVolume),
+      previousAISummary: matchingCycleSummary?.aiSummary ?? null
+    };
+  });
+
+  // Build exercise e1RM trends across last 3 cycles (including current)
+  const currentExerciseKeys = new Set();
+  const exerciseDisplayNames = new Map();
+  for (const s of cycleSessions) {
+    for (const ex of s.exercises ?? []) {
+      const key = normalizeExerciseName(ex.name);
+      currentExerciseKeys.add(key);
+      if (!exerciseDisplayNames.has(key)) exerciseDisplayNames.set(key, ex.name);
+    }
+  }
+
+  const allWeeks = [...new Set([...priorWeeks, cycleWeekNumber])].sort((a, b) => a - b);
+  const trendWeeks = allWeeks.slice(-3);
+  const allSessions = [...priorSessions, ...cycleSessions];
+
+  const exerciseTrends = [];
+  for (const exKey of currentExerciseKeys) {
+    const trend = [];
+    for (const wk of trendWeeks) {
+      let bestE1RM = 0;
+      for (const s of allSessions) {
+        if ((s.historicalContext?.programWeekNumber ?? 0) !== wk) continue;
+        for (const ex of s.exercises ?? []) {
+          if (normalizeExerciseName(ex.name) !== exKey) continue;
+          for (const set of ex.sets ?? []) {
+            if (!set.isComplete) continue;
+            const score = Number(set.weight) * (1 + Number(set.reps) / 30);
+            if (score > bestE1RM) bestE1RM = score;
+          }
+        }
+      }
+      if (bestE1RM > 0) {
+        trend.push({ week: wk, e1RM: Math.round(bestE1RM * 10) / 10 });
+      }
+    }
+    if (trend.length >= 2) {
+      exerciseTrends.push({ exerciseName: exerciseDisplayNames.get(exKey), trend });
+    }
+  }
+
+  const swapCounts = new Map();
+  for (const session of cycleSessions) {
+    for (const exercise of session.exercises ?? []) {
+      if (exercise.swappedFrom) {
+        const key = `${exercise.swappedFrom}\u2192${exercise.name}`;
+        swapCounts.set(key, (swapCounts.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  const swapPatterns = [...swapCounts.entries()].map(([key, count]) => {
+    const [original, replacement] = key.split('\u2192');
+    return { original, replacement, count };
+  });
+
   let goalProgress = null;
   const plans = snapshot.strengthPlans ?? [];
   const activePlan = plans.find(
@@ -472,13 +635,33 @@ export function cycleSummaryContext(snapshot, programId) {
     });
   }
 
+  const matchingSummary = programCycleSummaries[0] ?? null;
+
+  const progressionDecisions = (matchingSummary?.progressionUpdates ?? []).map((u) => ({
+    exerciseName: u.exerciseName,
+    action: u.action ?? u.change ?? null,
+    detail: u.detail ?? null,
+    kind: u.kind ?? null
+  }));
+
+  const setCompletionRate = matchingSummary
+    ? { completed: matchingSummary.totalSetsCompleted ?? 0, planned: matchingSummary.totalSetsPlanned ?? 0 }
+    : null;
+
   return {
     programName: program.name,
     cycleNumber: cycleWeekNumber,
     totalSessions: cycleSessions.length,
     sessions,
     prsThisCycle,
-    goalProgress
+    goalProgress,
+    progressionDecisions,
+    setCompletionRate,
+    swapPatterns,
+    cycleIntent,
+    adaptationNote,
+    previousCycles,
+    exerciseTrends
   };
 }
 
@@ -563,7 +746,21 @@ export function workoutSummaryContext(snapshot, sessionId) {
     }
   }
 
-  return {
+  // Plan comparison — prefer the logged point-in-time prescription snapshot.
+  let planComparison;
+  if (session.prescriptionSnapshot?.exercises?.length > 0) {
+    planComparison = buildPlanComparison(session, exercises, 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 ?? []);
+    }
+  }
+
+  const result = {
     sessionDate,
     dayName,
     totalVolume: session.summary?.totalVolume ?? session.volume ?? 0,
@@ -572,6 +769,8 @@ export function workoutSummaryContext(snapshot, sessionId) {
     recentComparisons,
     prs
   };
+  if (planComparison) result.planComparison = planComparison;
+  return result;
 }
 
 function requiredOption(options, primaryKey, legacyKey = null) {
@@ -676,5 +875,24 @@ export function executeReadCommand(snapshot, normalizedCommand, options = {}) {
     return { ok: true, payload };
   }
 
+  if (normalizedCommand === 'cycle-summary-list') {
+    const programId = requiredOption(options, 'program-id');
+    return { ok: true, payload: cycleSummaryList(snapshot, programId ?? null) };
+  }
+
+  if (normalizedCommand === 'cycle-summary-show') {
+    const summaryId = requiredOption(options, 'id');
+    if (!summaryId) {
+      return { ok: false, error: '--id is required' };
+    }
+
+    const payload = cycleSummaryShow(snapshot, summaryId);
+    if (!payload) {
+      return { ok: false, error: `Cycle summary not found: ${summaryId}` };
+    }
+
+    return { ok: true, payload };
+  }
+
   return { ok: false, error: `Unknown read command: ${normalizedCommand}` };
 }