@dgpholdings/greatoak-shared 1.2.86 → 1.2.87

package/dist/utils/scoringWorkout/computeMuscleFatigueMap.js

@@ -11,17 +11,22 @@
  *
  * Recovery model accounts for:
  *   P2-7  Age          — recovery slows with age (< 35 → 1.0×, > 55 → 0.85×)
- *   P2-8  Gender       — females recover slightly faster (1.05×)
  *   P2-9  fitnessLevel — sedentary 0.8× → very-active 1.15×
  *   P3-7  Weekly volume — muscles trained multiple times this week recover slower
  *   P3-8  Muscle group — small muscles (biceps) recover 1.4× faster than legs (0.80×)
  *
  * Accumulation model:
- *   P3-3  Real muscleScores → additive with diminishing returns (P3-5)
- *   Legacy (muscleScores={}) → quality score × 0.7/0.3 proxy + MAX accumulation
+ *   P3-3  Real per-session muscleScores → additive with diminishing returns (P3-5)
+ *
+ * Note: the legacy quality-score proxy path (pre-P3-1 sessions with empty
+ * muscleScores) has been removed — every session now saves real muscleScores.
+ * The P2-8 gender recovery factor has also been removed: the 1.05× female
+ * bump was within the noise of the model and not well-evidenced enough to
+ * justify a silent default-male assumption for unmentioned-gender users.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeMuscleFatigueMap = computeMuscleFatigueMap;
+const helpers_1 = require("./helpers");
 // ---------------------------------------------------------------------------
 // P2-7: Age-adjusted recovery multiplier
 // ---------------------------------------------------------------------------
@@ -29,26 +34,20 @@ function getAgeRecoveryMultiplier(age) {
     if (age < 25)
         return 1.05;
     if (age < 35)
-        return 1.00;
+        return 1.0;
     if (age < 45)
         return 0.95;
     if (age < 55)
-        return 0.90;
+        return 0.9;
     return 0.85;
 }
 // ---------------------------------------------------------------------------
-// P2-8: Gender-adjusted recovery multiplier
-// ---------------------------------------------------------------------------
-function getGenderRecoveryMultiplier(gender) {
-    return gender === "female" ? 1.05 : 1.00;
-}
-// ---------------------------------------------------------------------------
 // P2-9: Fitness-level recovery multiplier
 // ---------------------------------------------------------------------------
 const FITNESS_RECOVERY_SCALE = {
-    sedentary: 0.80,
-    "lightly-active": 0.90,
-    "moderately-active": 1.00,
+    sedentary: 0.8,
+    "lightly-active": 0.9,
+    "moderately-active": 1.0,
     "very-active": 1.15,
 };
 // ---------------------------------------------------------------------------
@@ -57,22 +56,34 @@ const FITNESS_RECOVERY_SCALE = {
 // ---------------------------------------------------------------------------
 const MUSCLE_RECOVERY_RATE = {
     // Core — very fast
-    "abs-upper": 1.8, "abs-lower": 1.8, "obliques": 1.8,
+    "abs-upper": 1.8,
+    "abs-lower": 1.8,
+    obliques: 1.8,
     // Small arm muscles — fast
-    "bicep-short-inner": 1.4, "bicep-long-outer": 1.4,
-    "tricep-brachii-long": 1.4, "tricep-brachii-lateral": 1.4,
-    "fore-arm-inner": 1.5, "fore-arm-outer": 1.5,
+    "bicep-short-inner": 1.4,
+    "bicep-long-outer": 1.4,
+    "tricep-brachii-long": 1.4,
+    "tricep-brachii-lateral": 1.4,
+    "fore-arm-inner": 1.5,
+    "fore-arm-outer": 1.5,
     // Calves — fast
-    "calf-inner": 1.3, "calf-outer": 1.3,
+    "calf-inner": 1.3,
+    "calf-outer": 1.3,
     // Shoulders / upper back — moderate
-    "deltoids-anterior": 1.1, "deltoids-middle": 1.1,
-    "trapezius": 1.0, "rhomboids": 1.0,
+    "deltoids-anterior": 1.1,
+    "deltoids-middle": 1.1,
+    trapezius: 1.0,
+    rhomboids: 1.0,
     // Chest — moderate
-    "pectoralis-major": 1.0, "pectoralis-minor": 1.0,
+    "pectoralis-major": 1.0,
+    "pectoralis-minor": 1.0,
     // Large compound — slow
     "latissimus-dorsi": 0.85,
-    "quadriceps": 0.80, "hamstrings": 0.80, "adductors": 0.80,
-    "glutes-maximus": 0.80, "glutes-medius": 0.85,
+    quadriceps: 0.8,
+    hamstrings: 0.8,
+    adductors: 0.8,
+    "glutes-maximus": 0.8,
+    "glutes-medius": 0.85,
     "lower-back": 0.75,
 };
 function getMuscleRecoveryRate(muscle) {
@@ -98,7 +109,7 @@ function getMuscleRecoveryRate(muscle) {
 const WEEKLY_VOLUME_BASELINE = 80; // ~1 normal session score
 const WEEKLY_VOLUME_STEP = 80; // score units per step
 const WEEKLY_VOLUME_REDUCTION_PER_STEP = 0.05; // 5% per additional session
-const WEEKLY_VOLUME_MAX_REDUCTION = 0.40;
+const WEEKLY_VOLUME_MAX_REDUCTION = 0.4;
 function getWeeklyVolumeMultiplier(muscle, weeklyVolume) {
     var _a;
     const total = (_a = weeklyVolume[muscle]) !== null && _a !== void 0 ? _a : 0;
@@ -127,14 +138,11 @@ function calculateRecoveryFatigue(originalFatigue, hoursSinceWorkout, recoveryMu
     const recovered = originalFatigue * ((recoveryRatePerHour * hoursSinceWorkout) / 100);
     return Math.max(0, originalFatigue - recovered);
 }
-function updateEntry(map, muscle, remainingFatigue, workoutDate, useAdditive) {
+function updateEntry(map, muscle, remainingFatigue, workoutDate) {
     var _a;
     const existing = (_a = map.get(muscle)) !== null && _a !== void 0 ? _a : { fatigue: 0, lastWorked: workoutDate };
-    // P3-5: additive with diminishing returns for real muscleScores
-    // Legacy sessions keep MAX to avoid overcorrection with the proxy
-    const newFatigue = useAdditive
-        ? existing.fatigue + remainingFatigue * (1 - existing.fatigue / 100)
-        : Math.max(existing.fatigue, remainingFatigue);
+    // P3-5: additive with diminishing returns.
+    const newFatigue = existing.fatigue + remainingFatigue * (1 - existing.fatigue / 100);
     map.set(muscle, {
         fatigue: Math.min(100, newFatigue),
         lastWorked: existing.lastWorked > workoutDate ? existing.lastWorked : workoutDate,
@@ -154,17 +162,15 @@ const RECOVERY_WINDOW_HOURS = 168; // 7 days
  * @returns              Record<muscleKey, { fatigue 0–100, lastWorked }>
  */
 function computeMuscleFatigueMap(exercises, scoreHistory, user, currentDate = new Date()) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    // Build combined user recovery multiplier (P2-7, P2-8, P2-9)
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    // Build combined user recovery multiplier (P2-7, P2-9).
+    // Age uses the shared deriveAge helper so it is never computed two ways.
     let userRecoveryMultiplier = 1.0;
     if (user) {
-        const age = user.dob
-            ? currentDate.getFullYear() - new Date(user.dob).getFullYear()
-            : 30;
+        const age = (0, helpers_1.deriveAge)(user.dob, currentDate);
         userRecoveryMultiplier =
             getAgeRecoveryMultiplier(age) *
-                getGenderRecoveryMultiplier((_a = user.gender) !== null && _a !== void 0 ? _a : "unmentioned") *
-                ((_c = FITNESS_RECOVERY_SCALE[(_b = user.fitnessLevel) !== null && _b !== void 0 ? _b : "moderately-active"]) !== null && _c !== void 0 ? _c : 1.0);
+                ((_b = FITNESS_RECOVERY_SCALE[(_a = user.fitnessLevel) !== null && _a !== void 0 ? _a : "moderately-active"]) !== null && _b !== void 0 ? _b : 1.0);
     }
     const cutoffTime = currentDate.getTime() - RECOVERY_WINDOW_HOURS * 3600000;
     const weekCutoff = currentDate.getTime() - 7 * 24 * 3600000; // same as RECOVERY_WINDOW_HOURS
@@ -180,12 +186,12 @@ function computeMuscleFatigueMap(exercises, scoreHistory, user, currentDate = ne
             .reduce((sum, r) => sum + r.score, 0);
         if (weeklyScore === 0)
             continue;
-        for (const muscle of (_d = exercise.primaryMuscles) !== null && _d !== void 0 ? _d : []) {
-            weeklyVolume[muscle] = ((_e = weeklyVolume[muscle]) !== null && _e !== void 0 ? _e : 0) + weeklyScore;
+        for (const muscle of (_c = exercise.primaryMuscles) !== null && _c !== void 0 ? _c : []) {
+            weeklyVolume[muscle] = ((_d = weeklyVolume[muscle]) !== null && _d !== void 0 ? _d : 0) + weeklyScore;
         }
-        for (const muscle of (_f = exercise.secondaryMuscles) !== null && _f !== void 0 ? _f : []) {
+        for (const muscle of (_e = exercise.secondaryMuscles) !== null && _e !== void 0 ? _e : []) {
             // Secondary muscles receive 35% of the stimulus
-            weeklyVolume[muscle] = ((_g = weeklyVolume[muscle]) !== null && _g !== void 0 ? _g : 0) + weeklyScore * 0.35;
+            weeklyVolume[muscle] = ((_f = weeklyVolume[muscle]) !== null && _f !== void 0 ? _f : 0) + weeklyScore * 0.35;
         }
     }
     const internalMap = new Map();
@@ -197,58 +203,36 @@ function computeMuscleFatigueMap(exercises, scoreHistory, user, currentDate = ne
         for (const record of relevantRecords) {
             const workoutDate = new Date(record.recordDate);
             const hoursSince = (currentDate.getTime() - workoutDate.getTime()) / 3600000;
-            // P3-3: Real path when muscleScores is available (sessions saved after P3-1)
-            const hasRealMuscleScores = record.muscleScores && Object.keys(record.muscleScores).length > 0;
-            if (hasRealMuscleScores) {
-                const allMuscles = new Set([
-                    ...((_h = exercise.primaryMuscles) !== null && _h !== void 0 ? _h : []),
-                    ...((_j = exercise.secondaryMuscles) !== null && _j !== void 0 ? _j : []),
-                ]);
-                for (const muscle of allMuscles) {
-                    const baseFatigue = (_k = record.muscleScores[muscle]) !== null && _k !== void 0 ? _k : 0;
-                    if (baseFatigue <= 0)
-                        continue;
-                    // P3-7: weekly volume slows recovery for heavily-trained muscles
-                    const multiplier = userRecoveryMultiplier
-                        * getMuscleRecoveryRate(muscle)
-                        * getWeeklyVolumeMultiplier(muscle, weeklyVolume);
-                    const remaining = calculateRecoveryFatigue(baseFatigue, hoursSince, multiplier);
-                    if (remaining > 0)
-                        updateEntry(internalMap, muscle, remaining, workoutDate, true);
-                }
-            }
-            else {
-                // Legacy path: quality score × 0.7/0.3 proxy (P1-7 band-aid)
-                const MIN_MEANINGFUL_SCORE = 88;
-                const MAX_SCORE = 100;
-                const intensityFraction = record.score <= MIN_MEANINGFUL_SCORE
-                    ? (record.score / MIN_MEANINGFUL_SCORE) * 0.3
-                    : ((record.score - MIN_MEANINGFUL_SCORE) / (MAX_SCORE - MIN_MEANINGFUL_SCORE)) * 0.7 + 0.3;
-                for (const muscle of (_l = exercise.primaryMuscles) !== null && _l !== void 0 ? _l : []) {
-                    const baseFatigue = record.score * 0.7 * intensityFraction;
-                    const multiplier = userRecoveryMultiplier
-                        * getMuscleRecoveryRate(muscle)
-                        * getWeeklyVolumeMultiplier(muscle, weeklyVolume);
-                    const remaining = calculateRecoveryFatigue(baseFatigue, hoursSince, multiplier);
-                    if (remaining > 0)
-                        updateEntry(internalMap, muscle, remaining, workoutDate, false);
-                }
-                for (const muscle of (_m = exercise.secondaryMuscles) !== null && _m !== void 0 ? _m : []) {
-                    const baseFatigue = record.score * 0.3 * intensityFraction;
-                    const multiplier = userRecoveryMultiplier
-                        * getMuscleRecoveryRate(muscle)
-                        * getWeeklyVolumeMultiplier(muscle, weeklyVolume);
-                    const remaining = calculateRecoveryFatigue(baseFatigue, hoursSince, multiplier);
-                    if (remaining > 0)
-                        updateEntry(internalMap, muscle, remaining, workoutDate, false);
-                }
+            // Real per-session muscleScores is the only path. Skip records that
+            // somehow carry none (defensive — should not occur post-P3-1).
+            const muscleScores = record.muscleScores;
+            if (!muscleScores || Object.keys(muscleScores).length === 0)
+                continue;
+            const allMuscles = new Set([
+                ...((_g = exercise.primaryMuscles) !== null && _g !== void 0 ? _g : []),
+                ...((_h = exercise.secondaryMuscles) !== null && _h !== void 0 ? _h : []),
+            ]);
+            for (const muscle of allMuscles) {
+                const baseFatigue = (_j = muscleScores[muscle]) !== null && _j !== void 0 ? _j : 0;
+                if (baseFatigue <= 0)
+                    continue;
+                // P3-7: weekly volume slows recovery for heavily-trained muscles
+                const multiplier = userRecoveryMultiplier *
+                    getMuscleRecoveryRate(muscle) *
+                    getWeeklyVolumeMultiplier(muscle, weeklyVolume);
+                const remaining = calculateRecoveryFatigue(baseFatigue, hoursSince, multiplier);
+                if (remaining > 0)
+                    updateEntry(internalMap, muscle, remaining, workoutDate);
             }
         }
     }
     // Convert internal Map → plain object for the public return type
     const result = {};
     internalMap.forEach((entry, muscle) => {
-        result[muscle] = { fatigue: Math.round(entry.fatigue), lastWorked: entry.lastWorked };
+        result[muscle] = {
+            fatigue: Math.round(entry.fatigue),
+            lastWorked: entry.lastWorked,
+        };
     });
     return result;
 }

package/dist/utils/scoringWorkout/constants.d.ts

@@ -169,8 +169,12 @@ export declare const REFERENCE_MAX_REPS = 12;
 /** Reference effort multiplier for "fully fatigued" benchmark */
 export declare const REFERENCE_MAX_EFFORT = 1.3;
 /**
- * Weights for the four quality sub-components.
- * Must sum to 1.0.
+ * Weights for the four quality sub-components. Must sum to 1.0.
+ *
+ * Effort leads (0.40): now that RPE/RIR is captured on every set, effort is
+ * the strongest available proxy for whether a session drove adaptation.
+ * Consistency demoted (0.20): it is the weakest quality signal and mildly
+ * penalises genuine fatigue-driven rep drop-off, so it should not dominate.
  */
 export declare const QUALITY_WEIGHTS: {
     completion: number;
@@ -197,10 +201,20 @@ export declare const OPTIMAL_RIR_RANGE: [number, number];
 export declare const OPTIMAL_RPE_RANGE: [number, number];
 /** Penalty per unit of distance from the optimal effort range */
 export declare const EFFORT_DISTANCE_PENALTY = 20;
-/** Minimum effort adequacy score */
-export declare const EFFORT_MIN_SCORE = 20;
-/** Default effort adequacy score when no RPE/RIR data is available */
-export declare const EFFORT_NO_DATA_SCORE = 70;
+/**
+ * Minimum effort adequacy score.
+ * Set equal to EFFORT_NO_DATA_SCORE so that logging any RPE/RIR value
+ * is never worse than logging nothing. Honest data is always safe to log.
+ */
+export declare const EFFORT_MIN_SCORE = 50;
+/**
+ * Default effort adequacy score when no RPE/RIR data is available.
+ * RPE and RIR are optional — users may choose not to log effort intensity.
+ * Set equal to EFFORT_MIN_SCORE (50) so that omitting effort data never
+ * produces a higher score than honestly logging any RPE or RIR value.
+ * There is no incentive to withhold effort data.
+ */
+export declare const EFFORT_NO_DATA_SCORE = 50;
 /** Score when rest is within the optimal range */
 export declare const REST_OPTIMAL_SCORE = 100;
 /** Score when rest is within acceptable (min–max) but not optimal */

package/dist/utils/scoringWorkout/constants.js

@@ -205,13 +205,17 @@ exports.REFERENCE_MAX_EFFORT = 1.3;
 // Quality Score
 // ---------------------------------------------------------------------------
 /**
- * Weights for the four quality sub-components.
- * Must sum to 1.0.
+ * Weights for the four quality sub-components. Must sum to 1.0.
+ *
+ * Effort leads (0.40): now that RPE/RIR is captured on every set, effort is
+ * the strongest available proxy for whether a session drove adaptation.
+ * Consistency demoted (0.20): it is the weakest quality signal and mildly
+ * penalises genuine fatigue-driven rep drop-off, so it should not dominate.
  */
 exports.QUALITY_WEIGHTS = {
-    completion: 0.2,
-    consistency: 0.35,
-    effortAdequacy: 0.3,
+    completion: 0.25,
+    consistency: 0.2,
+    effortAdequacy: 0.4,
     restDiscipline: 0.15,
 };
 /**
@@ -233,10 +237,20 @@ exports.OPTIMAL_RIR_RANGE = [1, 4];
 exports.OPTIMAL_RPE_RANGE = [6, 9];
 /** Penalty per unit of distance from the optimal effort range */
 exports.EFFORT_DISTANCE_PENALTY = 20;
-/** Minimum effort adequacy score */
-exports.EFFORT_MIN_SCORE = 20;
-/** Default effort adequacy score when no RPE/RIR data is available */
-exports.EFFORT_NO_DATA_SCORE = 70;
+/**
+ * Minimum effort adequacy score.
+ * Set equal to EFFORT_NO_DATA_SCORE so that logging any RPE/RIR value
+ * is never worse than logging nothing. Honest data is always safe to log.
+ */
+exports.EFFORT_MIN_SCORE = 50;
+/**
+ * Default effort adequacy score when no RPE/RIR data is available.
+ * RPE and RIR are optional — users may choose not to log effort intensity.
+ * Set equal to EFFORT_MIN_SCORE (50) so that omitting effort data never
+ * produces a higher score than honestly logging any RPE or RIR value.
+ * There is no incentive to withhold effort data.
+ */
+exports.EFFORT_NO_DATA_SCORE = 50;
 /** Score when rest is within the optimal range */
 exports.REST_OPTIMAL_SCORE = 100;
 /** Score when rest is within acceptable (min–max) but not optimal */

package/dist/utils/scoringWorkout/helpers.d.ts

@@ -125,3 +125,10 @@ export declare function extractUserContext(user: {
  * Used for RIR attenuation and reference max scaling (P2-10).
  */
 export declare function deriveTrainingAgeBracket(accountAgeDays: number, totalSessionCount: number): import("./types").TTrainingAgeBracket;
+/**
+ * Derive integer age from a date of birth, accounting for whether this year's
+ * birthday has occurred yet. Sanity-clamped to 10–100; returns DEFAULT_USER_AGE
+ * on missing or invalid input. Shared by extractUserContext and the fatigue
+ * recovery model so age is never computed two different ways.
+ */
+export declare function deriveAge(dob: Date | string | undefined | null, now?: Date): number;

package/dist/utils/scoringWorkout/helpers.js

@@ -12,6 +12,7 @@ exports.rpeToEffortFraction = rpeToEffortFraction;
 exports.getEffortFraction = getEffortFraction;
 exports.extractUserContext = extractUserContext;
 exports.deriveTrainingAgeBracket = deriveTrainingAgeBracket;
+exports.deriveAge = deriveAge;
 const constants_1 = require("./constants");
 // We reference these types but don't import them to keep this module decoupled.
 // The caller passes the raw values; we just parse them.
@@ -103,7 +104,7 @@ function standardDeviation(values) {
     if (values.length < 2)
         return 0;
     const avg = mean(values);
-    const squaredDiffs = values.map((v) => Math.pow((v - avg), 2));
+    const squaredDiffs = values.map((v) => (v - avg) ** 2);
     return Math.sqrt(mean(squaredDiffs));
 }
 /**
@@ -205,23 +206,7 @@ function extractUserContext(user) {
     const heightCm = user.heightCm && user.heightCm > 100 && user.heightCm < 250
         ? user.heightCm
         : constants_1.DEFAULT_USER_HEIGHT_CM;
-    let age = constants_1.DEFAULT_USER_AGE;
-    if (user.dob) {
-        const dob = typeof user.dob === "string" ? new Date(user.dob) : user.dob;
-        if (!isNaN(dob.getTime())) {
-            const today = new Date();
-            age = today.getFullYear() - dob.getFullYear();
-            // Adjust if birthday hasn't happened yet this year
-            const monthDiff = today.getMonth() - dob.getMonth();
-            if (monthDiff < 0 ||
-                (monthDiff === 0 && today.getDate() < dob.getDate())) {
-                age--;
-            }
-            // Sanity check
-            if (age < 10 || age > 100)
-                age = constants_1.DEFAULT_USER_AGE;
-        }
-    }
+    const age = deriveAge(user.dob);
     return {
         weightKg,
         heightCm,
@@ -243,3 +228,24 @@ function deriveTrainingAgeBracket(accountAgeDays, totalSessionCount) {
         return "intermediate";
     return "advanced";
 }
+/**
+ * Derive integer age from a date of birth, accounting for whether this year's
+ * birthday has occurred yet. Sanity-clamped to 10–100; returns DEFAULT_USER_AGE
+ * on missing or invalid input. Shared by extractUserContext and the fatigue
+ * recovery model so age is never computed two different ways.
+ */
+function deriveAge(dob, now = new Date()) {
+    if (!dob)
+        return constants_1.DEFAULT_USER_AGE;
+    const birth = typeof dob === "string" ? new Date(dob) : dob;
+    if (isNaN(birth.getTime()))
+        return constants_1.DEFAULT_USER_AGE;
+    let age = now.getFullYear() - birth.getFullYear();
+    const monthDiff = now.getMonth() - birth.getMonth();
+    if (monthDiff < 0 || (monthDiff === 0 && now.getDate() < birth.getDate())) {
+        age--;
+    }
+    if (age < 10 || age > 100)
+        return constants_1.DEFAULT_USER_AGE;
+    return age;
+}

package/dist/utils/scoringWorkout/index.d.ts

@@ -3,16 +3,20 @@
  * FITFRIX EXERCISE SCORING SYSTEM
  * ============================================================================
  *
- *   calculateExerciseScoreV2({ exercise, record, user, historicalContext? }) => IScoreResult
+ *   calculateExerciseScoreV2({ exercise, record, user, historicalContext? })
+ *     => IScoreResult
  *
  *   IScoreResult = {
- *     score: number,                      // 0–100 quality of execution
- *     muscleScores: Record<string, number>, // 0–100 per muscle fatigue
- *     calorieBurn: number,                // kcal (placeholder: 0 until Phase 3)
- *     qualityBreakdown: IQualityBreakdown // completion/consistency/effort/rest sub-scores
+ *     score:                number,                 // 0–100 quality of execution
+ *     qualityBreakdown:     IQualityBreakdown,      // completion/consistency/effort/rest
+ *     muscleScores:         Record<string, number>, // 0–100 per muscle, keyed by EBodyParts
+ *     calorieBurn:          number,                 // kcal — placeholder 0 until Phase 3
+ *     restDisciplineActive: boolean,                // false when no rest data was logged
  *   }
  *
- * Internally computes muscle fatigue (Pillar 2) and quality score (Pillar 3).
+ * Internally computes:
+ *   Pillar 2: Muscle Fatigue → muscleScores
+ *   Pillar 3: Quality Score  → single score + breakdown (not per-goal)
  * Calorie burn (Pillar 1) is implemented in calculateCalories.ts but not yet
  * wired into the save flow — scheduled for Phase 3.
  */
@@ -23,10 +27,10 @@ export { calculateTotalVolume } from "./calculateTotalVolume";
 export { computeMuscleFatigueMap } from "./computeMuscleFatigueMap";
 export { deriveTrainingAgeBracket };
 export type { IHistoricalContext, TTrainingAgeBracket };
-export type { TEnrichedSessionScore, TEnrichedExerciseRecord, TMuscleFatigueEntry, TMuscleFatigueResult } from "./types";
+export type { TEnrichedSessionScore, TEnrichedExerciseRecord, TMuscleFatigueEntry, TMuscleFatigueResult, } from "./types";
 export declare const calculateExerciseScoreV2: (param: {
     exercise: TExercise;
     record: TRecord[];
     user: TUserMetric;
-    historicalContext?: import("./types").IHistoricalContext;
+    historicalContext?: IHistoricalContext;
 }) => IScoreResult;

package/dist/utils/scoringWorkout/index.js

@@ -4,22 +4,26 @@
  * FITFRIX EXERCISE SCORING SYSTEM
  * ============================================================================
  *
- *   calculateExerciseScoreV2({ exercise, record, user, historicalContext? }) => IScoreResult
+ *   calculateExerciseScoreV2({ exercise, record, user, historicalContext? })
+ *     => IScoreResult
  *
  *   IScoreResult = {
- *     score: number,                      // 0–100 quality of execution
- *     muscleScores: Record<string, number>, // 0–100 per muscle fatigue
- *     calorieBurn: number,                // kcal (placeholder: 0 until Phase 3)
- *     qualityBreakdown: IQualityBreakdown // completion/consistency/effort/rest sub-scores
+ *     score:                number,                 // 0–100 quality of execution
+ *     qualityBreakdown:     IQualityBreakdown,      // completion/consistency/effort/rest
+ *     muscleScores:         Record<string, number>, // 0–100 per muscle, keyed by EBodyParts
+ *     calorieBurn:          number,                 // kcal — placeholder 0 until Phase 3
+ *     restDisciplineActive: boolean,                // false when no rest data was logged
  *   }
  *
- * Internally computes muscle fatigue (Pillar 2) and quality score (Pillar 3).
+ * Internally computes:
+ *   Pillar 2: Muscle Fatigue → muscleScores
+ *   Pillar 3: Quality Score  → single score + breakdown (not per-goal)
  * Calorie burn (Pillar 1) is implemented in calculateCalories.ts but not yet
  * wired into the save flow — scheduled for Phase 3.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateExerciseScoreV2 = exports.deriveTrainingAgeBracket = exports.computeMuscleFatigueMap = exports.calculateTotalVolume = void 0;
-const calculateMuscleFatiue_1 = require("./calculateMuscleFatiue");
+const calculateMuscleFatigue_1 = require("./calculateMuscleFatigue");
 const calculateQualityScore_1 = require("./calculateQualityScore");
 const helpers_1 = require("./helpers");
 Object.defineProperty(exports, "deriveTrainingAgeBracket", { enumerable: true, get: function () { return helpers_1.deriveTrainingAgeBracket; } });
@@ -29,14 +33,14 @@ Object.defineProperty(exports, "calculateTotalVolume", { enumerable: true, get:
 var computeMuscleFatigueMap_1 = require("./computeMuscleFatigueMap");
 Object.defineProperty(exports, "computeMuscleFatigueMap", { enumerable: true, get: function () { return computeMuscleFatigueMap_1.computeMuscleFatigueMap; } });
 // ---------------------------------------------------------------------------
-// Main Function — existing signature
+// Main Function
 // ---------------------------------------------------------------------------
 const calculateExerciseScoreV2 = (param) => {
     const { exercise, record, user, historicalContext } = param;
     const userContext = (0, helpers_1.extractUserContext)(user);
     const parsedSets = (0, parseRecords_1.parseRecords)(record, exercise.timingGuardrails, historicalContext);
-    // Pillar 2: Muscle Fatigue → muscleScores
-    const muscleScores = (0, calculateMuscleFatiue_1.calculateMuscleFatigue)(parsedSets, {
+    // ── Pillar 2: Muscle Fatigue ─────────────────────────────────────────────
+    const muscleScores = (0, calculateMuscleFatigue_1.calculateMuscleFatigue)(parsedSets, {
         primaryMuscles: exercise.primaryMuscles,
         secondaryMuscles: exercise.secondaryMuscles,
         difficultyLevel: exercise.difficultyLevel,
@@ -47,13 +51,17 @@ const calculateExerciseScoreV2 = (param) => {
         scoringSpecialHandling: exercise.scoringSpecialHandling,
         isUnilateral: exercise.isUnilateral,
     }, userContext, exercise.timingGuardrails, historicalContext);
-    // Pillar 3: Quality Score → score
-    const isStrictTimingModeScoring = record.some((r) => r.isStrictMode);
-    const { scoresByGoal } = (0, calculateQualityScore_1.calculateQualityScore)(parsedSets, record, exercise.timingGuardrails, isStrictTimingModeScoring, userContext, historicalContext);
+    // ── Pillar 3: Quality Score ──────────────────────────────────────────────
+    // userContext is intentionally not passed — quality scoring is goal-agnostic.
+    // Goal-specific logic lives in the gate system and quick plan generator.
+    const { score, qualityBreakdown, restDisciplineActive } = (0, calculateQualityScore_1.calculateQualityScore)(parsedSets, record, exercise.timingGuardrails, historicalContext);
+    // ── Result (Option A flat shape) ─────────────────────────────────────────
     return {
+        score,
+        qualityBreakdown,
         muscleScores,
-        calorieBurn: 0, // Placeholder until Pillar 1 is fully wired in Phase 3
-        scoresByGoal,
+        calorieBurn: 0, // placeholder — Pillar 1 wired in Phase 3
+        restDisciplineActive,
     };
 };
 exports.calculateExerciseScoreV2 = calculateExerciseScoreV2;

package/dist/utils/scoringWorkout/parseRecords.js

@@ -250,9 +250,10 @@ function resolveWorkDuration(measured, estimated, guardrails) {
  */
 function resolveRestDuration(measured, setIndex, totalSets, guardrails) {
     var _a, _b, _c;
-    // 1. Last set with no rest data → null
-    if (setIndex === totalSets - 1 &&
-        (measured === undefined || measured === 0)) {
+    // 1. Last set → null. Rest after the final set is not training rest —
+    //    there is no subsequent set it prepares for. Holds whether or not a
+    //    value was logged: a measured rest on the final set is still not scorable.
+    if (setIndex === totalSets - 1) {
         return null;
     }
     // Extract exercise-specific rest config