incremnt 0.8.1 → 0.8.2

package/src/promptfoo-evals.js

@@ -25,6 +25,7 @@ function envList(name) {
 
 export function buildPromptfooTestCase(testCase, { caseSet = testCase.caseSet ?? 'synthetic', fixtureFile = testCase.fixtureFile ?? null } = {}) {
   const question = testCase.context?.question ?? testCase.question ?? testCase.name;
+  const today = testCase.context?.today ?? testCase.today ?? null;
 
   return {
     description: `${testCase.surface}: ${testCase.name ?? testCase.id}`,
@@ -35,6 +36,7 @@ export function buildPromptfooTestCase(testCase, { caseSet = testCase.caseSet ??
       snapshotFile: testCase.snapshotFile ?? null,
       surface: testCase.surface,
       question,
+      ...(today ? { today } : {}),
       output: testCase.output,
       shouldPass: testCase.shouldPass !== false
     },
@@ -83,8 +85,21 @@ async function resolvePromptfooEval(vars = {}) {
     throw new Error(`Promptfoo eval case not found: ${caseSet}/${vars.caseId ?? '(missing caseId)'}`);
   }
 
-  const snapshot = await loadSummaryEvalSnapshot(testCase);
-  return { testCase, snapshot };
+  const contextOverrides = {
+    ...(vars.question ? { question: vars.question } : {}),
+    ...(vars.today ? { today: vars.today } : {})
+  };
+  const resolvedTestCase = Object.keys(contextOverrides).length > 0
+    ? {
+        ...testCase,
+        context: {
+          ...(testCase.context ?? {}),
+          ...contextOverrides
+        }
+      }
+    : testCase;
+  const snapshot = await loadSummaryEvalSnapshot(resolvedTestCase);
+  return { testCase: resolvedTestCase, snapshot };
 }
 
 function summarizeFailedChecks(result) {
@@ -98,7 +113,9 @@ function promptfooMetadataKey(vars = {}) {
   return [
     vars.caseSet ?? process.env.SUMMARY_EVAL_CASE_SET ?? 'synthetic',
     vars.fixtureFile ?? '',
-    vars.caseId ?? ''
+    vars.caseId ?? '',
+    vars.question ?? '',
+    vars.today ?? ''
   ].join(':');
 }
 

package/src/queries.js

@@ -3111,9 +3111,30 @@ export function getGoalStatus(snapshot, { limit = 5 } = {}) {
   });
 }
 
+function round1(value) {
+  return Math.round(value * 10) / 10;
+}
+
+function priorBestSetBefore(sets, recordDateIso) {
+  let prior = null;
+  for (const set of sets) {
+    const setDate = normalizeDateOnly(set.date);
+    if (setDate == null || recordDateIso == null || setDate >= recordDateIso) continue;
+    if (!prior || set.e1rm > prior.e1rm) prior = set;
+  }
+  return prior;
+}
+
+function classifyRecordKind(record, priorBest) {
+  if (!priorBest) return 'first';
+  // A PR achieved by adding reps at the same (or even lower) load reads as a
+  // stall to anything reasoning on bar weight, so distinguish it explicitly.
+  return record.weight > priorBest.weight ? 'load_pr' : 'rep_pr';
+}
+
 export function getRecords(snapshot, { exercises = [], limit = 15, recentSince = null, today = new Date() } = {}) {
   const filter = exercises.length > 0 ? new Set(exercises.map((exercise) => exercise.canonical ?? canonicalExerciseName(exercise))) : null;
-  const bestByExercise = new Map();
+  const setsByExercise = new Map();
   for (const session of snapshot.sessions ?? []) {
     for (const exercise of session.exercises ?? []) {
       const key = canonicalExerciseName(exercise.name);
@@ -3121,27 +3142,85 @@ export function getRecords(snapshot, { exercises = [], limit = 15, recentSince =
       for (const set of exercise.sets ?? []) {
         if (!set.isComplete) continue;
         const e1rm = Number(set.weight) * (1 + Number(set.reps) / 30);
-        const current = bestByExercise.get(key);
-        if (!current || e1rm > current.e1rm) {
-          bestByExercise.set(key, {
-            name: exercise.name,
-            e1rm,
-            date: completionDateForSession(session),
-            sessionId: session.id ?? null
-          });
+        if (!(e1rm > 0)) continue;
+        let entry = setsByExercise.get(key);
+        if (!entry) {
+          entry = { sets: [] };
+          setsByExercise.set(key, entry);
         }
+        entry.sets.push({
+          name: exercise.name,
+          e1rm,
+          weight: Number(set.weight),
+          reps: Number(set.reps),
+          date: completionDateForSession(session),
+          sessionId: session.id ?? null
+        });
       }
     }
   }
-  const allRows = [...bestByExercise.values()]
-    .filter((record) => record.e1rm > 0)
+
+  const records = [];
+  for (const entry of setsByExercise.values()) {
+    let best = null;
+    for (const set of entry.sets) {
+      // Strictly greater keeps the earliest set that reached the best e1RM.
+      if (!best || set.e1rm > best.e1rm) best = set;
+    }
+    if (!best) continue;
+    records.push({
+      name: best.name,
+      e1rm: best.e1rm,
+      weight: best.weight,
+      reps: best.reps,
+      date: best.date,
+      sessionId: best.sessionId,
+      sets: entry.sets
+    });
+  }
+
+  const allRows = records
+    .map((record) => ({
+      name: record.name,
+      e1rm: record.e1rm,
+      weight: record.weight,
+      reps: record.reps,
+      date: record.date,
+      sessionId: record.sessionId
+    }))
     .sort((a, b) => b.e1rm - a.e1rm);
+
   const todayIso = dateOnlyString(today);
-  const recentRecords = recentSince
-    ? allRows.filter((record) => {
-      const recordDate = normalizeDateOnly(record.date);
-      return recordDate != null && recordDate >= recentSince && recordDate <= todayIso;
-    })
+  const recentSinceIso = recentSince ? normalizeDateOnly(recentSince) : null;
+  const recentRecords = recentSinceIso
+    ? records
+      .filter((record) => {
+        const recordDate = normalizeDateOnly(record.date);
+        return recordDate != null && recordDate >= recentSinceIso && recordDate <= todayIso;
+      })
+      .sort((a, b) => b.e1rm - a.e1rm)
+      .map((record) => {
+        const recordDateIso = normalizeDateOnly(record.date);
+        const priorBest = priorBestSetBefore(record.sets, recordDateIso);
+        const delta = priorBest ? round1(record.e1rm - priorBest.e1rm) : null;
+        const deltaPct = priorBest && priorBest.e1rm > 0
+          ? round1(((record.e1rm - priorBest.e1rm) / priorBest.e1rm) * 100)
+          : null;
+        return {
+          name: record.name,
+          e1rm: record.e1rm,
+          weight: record.weight,
+          reps: record.reps,
+          date: record.date,
+          sessionId: record.sessionId,
+          priorBest: priorBest
+            ? { e1rm: priorBest.e1rm, weight: priorBest.weight, reps: priorBest.reps, date: priorBest.date }
+            : null,
+          delta,
+          deltaPct,
+          kind: classifyRecordKind(record, priorBest)
+        };
+      })
     : [];
   const rows = allRows.slice(0, limit);
 
@@ -3156,7 +3235,8 @@ export function getRecords(snapshot, { exercises = [], limit = 15, recentSince =
       recordCount: rows.length,
       totalRecordCount: allRows.length,
       recentRecordCount: recentRecords.length,
-      recentRecordNames: recentRecords.map((record) => record.name)
+      recentRecordNames: recentRecords.map((record) => record.name),
+      recentRecords
     },
     sourceIds: rows.map((row) => row.sessionId),
     sourceTimestamp: latestSourceTimestampFromDates(rows.map((row) => row.date)),
@@ -3543,7 +3623,15 @@ export function incrementScoreSummary(snapshot, { historyDays = 14 } = {}) {
 
   const trimmedHistory = history.slice(0, boundedHistoryDays);
   const prior = trimmedHistory[1];
-  const dayOverDayDelta = (typeof prior?.score === 'number')
+  // Scores are only comparable within the same formula version. The Increment
+  // Score formula changed mid-2026 (it started counting recovery data it did not
+  // have before), so subtracting an older-formula score from a newer one is the
+  // "+36 / 77% up" cross-ruler artifact. Null the delta across a formula change
+  // so downstream voice cannot frame a non-comparable jump as real progress.
+  const latestFormulaVersion = latest.formulaVersion ?? null;
+  const dayOverDayComparable = (typeof prior?.score === 'number')
+    && (prior.formulaVersion ?? null) === latestFormulaVersion;
+  const dayOverDayDelta = dayOverDayComparable
     ? latest.score - prior.score
     : null;
 
@@ -3570,6 +3658,11 @@ export function incrementScoreSummary(snapshot, { historyDays = 14 } = {}) {
       dataTier: entry.dataTier ?? null,
       formulaVersion: entry.formulaVersion ?? null
     }));
+  // A multi-day trend is only meaningful if every point shares the latest
+  // formula version; otherwise the "rising/falling" steer mixes rulers.
+  const trendComparable = recentTrend.every(
+    (entry) => (entry.formulaVersion ?? null) === latestFormulaVersion
+  );
 
   return {
     available: true,
@@ -3581,6 +3674,8 @@ export function incrementScoreSummary(snapshot, { historyDays = 14 } = {}) {
     topPositiveDrivers: scoreDriverLabels(latest.topPositiveDrivers),
     topNegativeDrivers: scoreDriverLabels(latest.topNegativeDrivers),
     dayOverDayDelta,
+    dayOverDayComparable,
+    trendComparable,
     recentTrend,
     dataQualityNotes,
     missingDataFlags,

package/src/score-prelude.js

@@ -29,25 +29,25 @@ export function scoreComponentPhrase(name) {
   return SCORE_COMPONENT_PHRASES[String(name).toLowerCase()] ?? 'another training area';
 }
 
-// True when the user's question is actually about the Increment Score. Only then
-// should the prelude hand the model the bare numeric headline — otherwise the
-// model parrots "your score is 92/100" into answers about sessions, volume, or
-// plans where it was never asked for.
+// True when the user's question is actually about the Increment Score. Defensive
+// Ask profiles still use this to avoid score dashboarding in narrow decisions;
+// expansive Ask profiles intentionally get the headline for richer coaching.
 export function isScoreQuestion(question) {
   return /\b(?:increment\s+)?score\b/i.test(String(question ?? ''));
 }
 
-export function formatIncrementScorePrelude(snapshots, { question = '' } = {}) {
+export function formatIncrementScorePrelude(snapshots, { question = '', responseProfile = 'defensive' } = {}) {
   if (!Array.isArray(snapshots) || snapshots.length === 0) return null;
   const latest = snapshots[0];
   if (latest == null || typeof latest.score !== 'number') return null;
 
+  const allowsHeadline = responseProfile === 'expansive' || isScoreQuestion(question);
   const lines = [
-    '[Increment Score — context only. Speak in training reality (recovery, fatigue, consistency, density). Never recite component values, sub-scores, decimals, or daily score numbers. Do not volunteer the overall score number unless the user asked about the score.]'
+    allowsHeadline
+      ? '[Increment Score — context only. The rounded score headline and drivers may be used in rich Ask Coach answers. Never recite component values, sub-scores, decimals, or daily score numbers.]'
+      : '[Increment Score — context only. Speak in training reality (recovery, fatigue, consistency, density). Never recite component values, sub-scores, decimals, or daily score numbers. Do not volunteer the overall score number unless the user asked about the score.]'
   ];
-  // Hand over the numeric headline only when the question is score-related; the
-  // weakest/strongest area and direction below are always safe to provide.
-  if (isScoreQuestion(question)) {
+  if (allowsHeadline) {
     lines.push(`- Current: ${Math.round(latest.score)}/100`);
   }
 
@@ -90,18 +90,21 @@ export function formatIncrementScorePrelude(snapshots, { question = '' } = {}) {
   const negatives = driverLabels(latest.topNegativeDrivers);
   if (negatives) lines.push(`- Holding the score back: ${negatives}`);
 
-  // Direction words only — no delta number, no daily-score list.
+  // Direction words only — no delta number, no daily-score list. Scores are only
+  // comparable within one formula version; a formula change makes the direction a
+  // cross-ruler lie ("+36 / 77% up"), so suppress the steer across it.
+  const latestFormulaVersion = latest.formulaVersion ?? null;
   if (snapshots.length > 1) {
     const prior = snapshots[1];
-    if (typeof prior?.score === 'number') {
+    if (typeof prior?.score === 'number' && (prior.formulaVersion ?? null) === latestFormulaVersion) {
       const delta = latest.score - prior.score;
       const dir = delta > 0 ? 'up' : delta < 0 ? 'down' : 'flat';
       lines.push(`- Day-over-day: ${dir}`);
     }
     const recent = snapshots
       .slice(0, 7)
-      .map((s) => (typeof s?.score === 'number' ? s.score : null))
-      .filter((s) => s != null);
+      .filter((s) => typeof s?.score === 'number' && (s.formulaVersion ?? null) === latestFormulaVersion)
+      .map((s) => s.score);
     if (recent.length >= 3) {
       const span = recent[0] - recent[recent.length - 1];
       const trend = span > 2 ? 'rising' : span < -2 ? 'falling' : 'steady';