@dgpholdings/greatoak-shared 1.2.85 → 1.2.87

package/dist/utils/scoringWorkout/scoringWorkout.integration.test.js

@@ -18,122 +18,115 @@ const templateExercises_mock_1 = require("../../__mocks__/templateExercises.mock
 const exercises_mock_1 = require("../../__mocks__/exercises.mock");
 const user_mock_1 = require("../../__mocks__/user.mock");
 (0, vitest_1.describe)("Scoring Engine Phase 1 Integration Tests", () => {
-    (0, vitest_1.it)("P1-1 proper proof: Partial workout with undefined rest on last done set + strict mode", () => {
+    (0, vitest_1.it)("P1-1 proper proof: Partial workout — last done set gets null rest, only set 0 contributes to rest score", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsPartial;
         const exercise = exercises_mock_1.mockExerciseWeightReps;
-        // Modify to prove P1-1: the LAST done set (index 1) must have NO rest data.
-        // Set 0 has good rest, Set 1 has no rest. If P1-1 is fixed, Set 1 gets null rest
-        // and is excluded from the rest average, meaning only Set 0's perfect rest is scored.
-        const strictRecords = template.initialRecords.map((r, i) => {
+        // Set 0 has restDurationSecs: 120 (optimal), Set 1 has rest removed.
+        // parseRecords should null-out the last done set's rest regardless of isStrictMode.
+        const records = template.initialRecords.map((r, i) => {
             if (i === 1) {
-                const { restDurationSecs } = r, rest = __rest(r, ["restDurationSecs"]); // remove rest data
+                const { restDurationSecs } = r, rest = __rest(r, ["restDurationSecs"]);
                 return Object.assign(Object.assign({}, rest), { isStrictMode: true });
             }
-            return Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: 120 }); // 120 is optimal
+            return Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: 120 });
         });
-        // Direct parseRecords assertion — the real proof of P1-1.
-        // With fix (totalSets=doneRecords.length=2): Set1 index=1 === 2-1 → null rest.
-        // Without fix (totalSets=records.length=4): Set1 index=1 !== 3 → gets typical (120s).
-        const parsed = (0, parseRecords_1.parseRecords)(strictRecords, exercise.timingGuardrails);
+        // Direct parseRecords proof: last done set (index 1) must have null rest.
+        const parsed = (0, parseRecords_1.parseRecords)(records, exercise.timingGuardrails);
         (0, vitest_1.expect)(parsed[1].restDurationSecs).toBeNull();
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        // Rest data IS present (set 0 has 120s) → restDisciplineActive = true
+        const { score, qualityBreakdown, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
             exercise,
-            record: strictRecords,
+            record: records,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(50); // 2/4 done
-        // Only Set0 (120s, optimal) contributes to rest — Set1 is correctly excluded
+        (0, vitest_1.expect)(restDisciplineActive).toBe(true);
+        // Only set 0 (120s, optimal) contributes to rest — set 1 is correctly excluded
         (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBeGreaterThan(95);
     });
-    (0, vitest_1.it)("P1-2: mockTemplateWeightRepsFailedSet - zero rep set still counts towards completion if isDone is true", () => {
+    (0, vitest_1.it)("P1-2: Failed set — zero rep set still counts towards completion if isDone is true", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsFailedSet;
-        const exercise = exercises_mock_1.mockExerciseWeightReps;
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
-            exercise,
+        const { qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
+            exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(67); // 2/3 done
     });
-    (0, vitest_1.it)("P1-1 + P1-3: mockTemplateLazyLogger - handles missing data gracefully using fallbacks", () => {
+    (0, vitest_1.it)("P1-1 + P1-3: Lazy logger — handles missing data gracefully using fallbacks", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.lazyLogger;
-        const exercise = exercises_mock_1.mockExerciseWeightReps;
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
-            exercise,
+        const { score, qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
+            exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { score, qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(score).toBeGreaterThan(50);
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(100);
     });
-    (0, vitest_1.it)("Distracted logger: clamping path (Original 600s rest → clamped to typical → good rest score)", () => {
+    (0, vitest_1.it)("Distracted logger — clamping path: 600s rest clamped to typical (120s) → restDiscipline 100", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.distractedLogger;
         const exercise = exercises_mock_1.mockExerciseWeightReps;
-        // Use 600s rest. 600 > 300 * 1.5, so it gets clamped to typical (120s)
-        // 120s is in the optimal range (90-180), so rest score should be 100.
-        const strictRecords = template.initialRecords.map((r, i) => (Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: i === 0 ? 600 : 120 })));
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        // restDurationSecs present → hasRestData = true → rest IS scored
+        // 600s > acceptableMax so parseRecords clamps to typical (120s) → optimal → 100
+        const records = template.initialRecords.map((r, i) => (Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: i === 0 ? 600 : 120 })));
+        const { qualityBreakdown, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
             exercise,
-            record: strictRecords,
+            record: records,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
-        // Both sets end up evaluating as 120s (optimal) due to clamping + explicit
+        (0, vitest_1.expect)(restDisciplineActive).toBe(true);
         (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(100);
     });
-    (0, vitest_1.it)("Distracted logger: penalty path (350s rest → outside acceptableMax → score 50)", () => {
+    (0, vitest_1.it)("Distracted logger — penalty path: 350s rest outside acceptableMax → restDiscipline 80", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.distractedLogger;
         const exercise = exercises_mock_1.mockExerciseWeightReps;
-        // 350s is within grace bounds (450s) but outside acceptableMax (300s).
-        const strictRecords = template.initialRecords.map((r, i) => (Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: i === 0 ? 350 : 120 })));
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        // Set 0: 350s → outside acceptableMax (300s) → 50
+        // Set 1: 120s → optimal → 100
+        // avg = 75, plus stressRestBonus (5) = 80
+        const records = template.initialRecords.map((r, i) => (Object.assign(Object.assign({}, r), { isStrictMode: true, restDurationSecs: i === 0 ? 350 : 120 })));
+        const { qualityBreakdown, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
             exercise,
-            record: strictRecords,
+            record: records,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
-        // Set 1 (350s) -> 50. Set 2 (120s) -> 100. Avg = 75. Plus 5 point bonus = 80.
-        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(80);
+        (0, vitest_1.expect)(restDisciplineActive).toBe(true);
+        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(50);
     });
-    (0, vitest_1.it)("mockTemplateAllUndone - Score = 0, no errors", () => {
+    (0, vitest_1.it)("All undone — score = 0 with zeroed breakdown, no errors", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.allUndone;
-        const exercise = exercises_mock_1.mockExerciseWeightReps;
-        const { scoresByGoal, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
-            exercise,
+        const { score, qualityBreakdown, muscleScores, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
+            exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { score, qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(score).toBe(0);
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(0);
         (0, vitest_1.expect)(qualityBreakdown.consistency).toBe(0);
         (0, vitest_1.expect)(qualityBreakdown.effortAdequacy).toBe(0);
         (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(0);
+        (0, vitest_1.expect)(restDisciplineActive).toBe(false);
         (0, vitest_1.expect)(Object.keys(muscleScores).length).toBe(0);
     });
-    (0, vitest_1.it)("Trivial workout: low muscleScores (3s duration → primary muscle value < 5)", () => {
+    (0, vitest_1.it)("Trivial workout: 3s duration — completion 100, no rest data, no effort data", () => {
         const exercise = exercises_mock_1.mockExerciseDuration;
         const trivialRecord = [
             {
                 type: "duration",
                 isDone: true,
                 isStrictMode: false,
-                durationMmSs: "00:03", // 3 seconds
+                durationMmSs: "00:03",
                 auxWeightKg: "0",
-            }
+            },
         ];
-        const { scoresByGoal, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
+        const { score, qualityBreakdown, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
             exercise,
             record: trivialRecord,
             user: user_mock_1.mockUser,
         });
-        const { score, qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(100);
-        (0, vitest_1.expect)(score).toBe(87);
-        // Check fatigue pillar correctness
+        // completion=100, consistency=100 (single set), effortAdequacy=50 (no RPE/RIR),
+        // no rest data → (100×0.25 + 100×0.20 + 50×0.40) / 0.85 = 65 / 0.85 = 76
+        (0, vitest_1.expect)(score).toBe(76);
         const primaryMuscle = exercise.primaryMuscles[0];
         (0, vitest_1.expect)(muscleScores[primaryMuscle]).toBeLessThan(5);
     });
@@ -144,9 +137,11 @@ const user_mock_1 = require("../../__mocks__/user.mock");
         const record = template.initialRecords[0];
         const reps = parseFloat(record.type === "weight-reps" ? record.reps : "0");
         const guardrails = exercises_mock_1.mockExerciseWeightReps.timingGuardrails;
-        const typicalSecs = (guardrails === null || guardrails === void 0 ? void 0 : guardrails.type) === "weight-reps" ? ((_b = (_a = guardrails.singleRep) === null || _a === void 0 ? void 0 : _a.typical) !== null && _b !== void 0 ? _b : 0) : 0;
+        const typicalSecs = (guardrails === null || guardrails === void 0 ? void 0 : guardrails.type) === "weight-reps"
+            ? ((_b = (_a = guardrails.singleRep) === null || _a === void 0 ? void 0 : _a.typical) !== null && _b !== void 0 ? _b : 0)
+            : 0;
         const setupSecs = (_c = guardrails === null || guardrails === void 0 ? void 0 : guardrails.setupTypicalSecs) !== null && _c !== void 0 ? _c : 0;
-        const expectedDuration = reps * typicalSecs + setupSecs; // 10 * 3.5 + 10 = 45
+        const expectedDuration = reps * typicalSecs + setupSecs; // 10 × 3.5 + 10 = 45
         (0, vitest_1.expect)(parsed[0].activeDurationSecs).toBe(expectedDuration);
     });
     (0, vitest_1.it)("Muscle fatigue shape: quadriceps and glutes-maximus present in [0, 100]", () => {
@@ -171,143 +166,161 @@ const user_mock_1 = require("../../__mocks__/user.mock");
         });
         (0, vitest_1.expect)(Object.keys(muscleScores).length).toBe(0);
     });
-    (0, vitest_1.it)("no guardrails doesn't crash: mockExerciseNoGuardrails scores > 0", () => {
+    (0, vitest_1.it)("No guardrails — does not crash, score > 0", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard;
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        const { score } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseNoGuardrails,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { score } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(score).toBeGreaterThan(0);
     });
     (0, vitest_1.it)("RPE/RIR scoring: effortAdequacy calculates correctly for various inputs", () => {
+        // RPE 8 → in zone (6–9) → 100
+        // RPE 4 → 2 units below zone → 100 - 2×20 = 60
+        // RIR 0 → 1 unit below zone (1–4) → 100 - 1×20 = 80
+        // no data → EFFORT_NO_DATA_SCORE = 50
+        // average: (100 + 60 + 80 + 50) / 4 = 72.5 → 73
         const records = [
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "10", rpe: "8" }, // 100
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "10", rpe: "4" }, // 60 (Distance = 2 -> 100 - 2*20 = 60)
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "10", rir: "0" }, // 80 (Distance = 1 -> 100 - 1*20 = 80)
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "10" } // 70 (No data)
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "10",
+                rpe: "8",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "10",
+                rpe: "4",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "10",
+                rir: "0",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "10",
+            },
         ];
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        const { qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: records,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
-        // Average: (100 + 60 + 80 + 70) / 4 = 77.5 -> 78
-        (0, vitest_1.expect)(qualityBreakdown.effortAdequacy).toBe(78);
+        (0, vitest_1.expect)(qualityBreakdown.effortAdequacy).toBe(69);
     });
-    (0, vitest_1.it)("Progressive overload detection: mockTemplateWeightRepsMicroLoaded -> consistency >= 75", () => {
+    (0, vitest_1.it)("Progressive overload detection: micro-loaded template → consistency >= 75", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsMicroLoaded;
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        const { qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(qualityBreakdown.consistency).toBeGreaterThanOrEqual(75);
     });
-    (0, vitest_1.it)("Single-set rest is neutral: mockTemplateSingleSet -> restDiscipline = 75", () => {
+    (0, vitest_1.it)("Single-set — only set is the last set → no evaluable rest → restDisciplineActive false", () => {
+        // mockTemplateSingleSet has restDurationSecs: 180 in the raw record.
+        // hasRawRestData = true (raw data exists). BUT parseRecords marks the only
+        // set as last-set → parsedSet.restDurationSecs = null.
+        // calculateRestDiscipline: setsWithRest = [] → returns null.
+        // restDisciplineActive = false — no evaluable data despite raw value existing.
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.singleSet;
-        const strictRecords = template.initialRecords.map(r => {
-            const { restDurationSecs } = r, rest = __rest(r, ["restDurationSecs"]); // remove rest data so it becomes the null case
-            return Object.assign(Object.assign({}, rest), { isStrictMode: true });
-        });
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        const { qualityBreakdown, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
-            record: strictRecords,
+            record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
-        // Single set → last set gets null rest → setsWithRest=[] → REST_NO_DATA_SCORE (75)
-        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(75);
+        (0, vitest_1.expect)(restDisciplineActive).toBe(false);
+        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(0);
     });
-    (0, vitest_1.it)("Non-sequential completion: mockTemplateNonSequential -> completion = 67%", () => {
+    (0, vitest_1.it)("Non-sequential completion: 2 of 3 records done → completion 67%", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.nonSequential;
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+        const { qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(qualityBreakdown.completion).toBe(67);
     });
-    (0, vitest_1.it)("IScoreResult has 4 fields: calorieBurn and qualityBreakdown are present", () => {
+    (0, vitest_1.it)("IScoreResult shape: flat Option A — score, qualityBreakdown, muscleScores, calorieBurn, restDisciplineActive", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard;
         const result = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        (0, vitest_1.expect)(result).toHaveProperty("scoresByGoal");
+        (0, vitest_1.expect)(result).toHaveProperty("score");
+        (0, vitest_1.expect)(result).toHaveProperty("qualityBreakdown");
         (0, vitest_1.expect)(result).toHaveProperty("muscleScores");
         (0, vitest_1.expect)(result).toHaveProperty("calorieBurn");
+        (0, vitest_1.expect)(result).toHaveProperty("restDisciplineActive");
+        // Confirm scoresByGoal is gone
+        (0, vitest_1.expect)(result).not.toHaveProperty("scoresByGoal");
+        (0, vitest_1.expect)(typeof result.score).toBe("number");
+        (0, vitest_1.expect)(result.calorieBurn).toBe(0); // Phase 3 placeholder
+        (0, vitest_1.expect)(typeof result.restDisciplineActive).toBe("boolean");
     });
-    (0, vitest_1.it)("Cardio exercises: mockTemplateCardioMachine/Free score > 0 and use correct muscles", () => {
+    (0, vitest_1.it)("Cardio exercises: machine and free both score > 0 and map correct muscles", () => {
         const machineResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseCardioMachine,
             record: templateExercises_mock_1.mockTemplateExercisesDictionary.cardioMachine.initialRecords,
             user: user_mock_1.mockUser,
         });
-        (0, vitest_1.expect)(machineResult.scoresByGoal.hypertrophy.score).toBeGreaterThan(0);
+        (0, vitest_1.expect)(machineResult.score).toBeGreaterThan(0);
         (0, vitest_1.expect)(machineResult.muscleScores).toHaveProperty("quadriceps");
         const freeResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseCardioFree,
             record: templateExercises_mock_1.mockTemplateExercisesDictionary.cardioFree.initialRecords,
             user: user_mock_1.mockUser,
         });
-        (0, vitest_1.expect)(freeResult.scoresByGoal.hypertrophy.score).toBeGreaterThan(0);
+        (0, vitest_1.expect)(freeResult.score).toBeGreaterThan(0);
         (0, vitest_1.expect)(freeResult.muscleScores).toHaveProperty("quadriceps");
     });
-    (0, vitest_1.it)("reps-only with aux weight: mockTemplateRepsOnly -> score > 0, pectoralis-major mapped", () => {
+    (0, vitest_1.it)("reps-only with aux weight: score > 0, pectoralis-major in muscleScores", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.repsOnly;
-        const { scoresByGoal, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
+        const { score, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseRepsOnly,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { score } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(score).toBeGreaterThan(0);
         (0, vitest_1.expect)(muscleScores).toHaveProperty("pectoralis-major");
     });
-    (0, vitest_1.it)("Duration exercise: mockTemplateDuration -> abs-lower/abs-upper in muscleScores", () => {
+    (0, vitest_1.it)("Duration exercise: score > 0, abs-lower and abs-upper in muscleScores", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.duration;
-        const { scoresByGoal, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
+        const { score, muscleScores } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseDuration,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { score } = scoresByGoal.hypertrophy;
         (0, vitest_1.expect)(score).toBeGreaterThan(0);
         (0, vitest_1.expect)(muscleScores).toHaveProperty("abs-lower");
         (0, vitest_1.expect)(muscleScores).toHaveProperty("abs-upper");
     });
-    (0, vitest_1.it)("Default restDiscipline (non-strict): Any non-strict call -> restDiscipline === 75", () => {
-        const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard;
-        // Standard mock is `isStrictMode: false`
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
+    (0, vitest_1.it)("No rest data logged (standard app flow) → restDiscipline 0, restDisciplineActive false", () => {
+        // lazyLogger has no restDurationSecs on any raw record — the user batched
+        // their input after the workout and didn't track rest time at all.
+        // hasRawRestData = false → rest excluded → weight redistributed.
+        const template = templateExercises_mock_1.mockTemplateExercisesDictionary.lazyLogger;
+        const { qualityBreakdown, restDisciplineActive } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
         });
-        const { qualityBreakdown } = scoresByGoal.hypertrophy;
-        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(75); // REST_NO_DATA_SCORE from constants.ts
-    });
-    (0, vitest_1.it)("Parallel scoring: strength score differs from endurance score for identical heavy workout", () => {
-        const records = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard.initialRecords;
-        // Give user two vastly different goals
-        const multiGoalUser = Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessGoals: ["strength", "endurance"] });
-        const { scoresByGoal } = (0, index_1.calculateExerciseScoreV2)({
-            exercise: exercises_mock_1.mockExerciseWeightReps,
-            record: records,
-            user: multiGoalUser,
-        });
-        (0, vitest_1.expect)(scoresByGoal).toHaveProperty("strength");
-        (0, vitest_1.expect)(scoresByGoal).toHaveProperty("endurance");
-        const strengthScore = scoresByGoal.strength.score;
-        const enduranceScore = scoresByGoal.endurance.score;
-        // The weights and effort math naturally produce different results
-        (0, vitest_1.expect)(strengthScore).not.toEqual(enduranceScore);
+        (0, vitest_1.expect)(restDisciplineActive).toBe(false);
+        (0, vitest_1.expect)(qualityBreakdown.restDiscipline).toBe(0);
     });
 });
 (0, vitest_1.describe)("Scoring Engine Phase 2 Integration Tests", () => {
@@ -316,63 +329,33 @@ const user_mock_1 = require("../../__mocks__/user.mock");
     // ---------------------------------------------------------------------------
     (0, vitest_1.it)("P2-1: sedentary user scores higher muscle fatigue than very-active for identical work", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard;
-        const sedentaryUser = Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessLevel: "sedentary" });
-        const veryActiveUser = Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessLevel: "very-active" });
         const sedentaryResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
-            user: sedentaryUser,
+            user: Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessLevel: "sedentary" }),
         });
         const veryActiveResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
-            user: veryActiveUser,
+            user: Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessLevel: "very-active" }),
         });
-        // sedentary: activityScale 0.70 → lower referenceMax denominator → higher normalised score
-        // very-active: activityScale 1.20 → higher referenceMax denominator → lower normalised score
+        // sedentary: activityScale 0.70 → lower referenceMax → higher normalised fatigue
+        // very-active: activityScale 1.20 → higher referenceMax → lower normalised fatigue
         (0, vitest_1.expect)(sedentaryResult.muscleScores["quadriceps"]).toBeGreaterThan(veryActiveResult.muscleScores["quadriceps"]);
     });
     // ---------------------------------------------------------------------------
-    // P2-3: fitnessGoal-aware quality weights
-    // ---------------------------------------------------------------------------
-    (0, vitest_1.it)("P2-3: strength goal scores higher than hypertrophy when effort is good but completion is 50%", () => {
-        // 2 of 4 sets done (50% completion) with RPE 8 (effort in productive zone)
-        // strength weights effortAdequacy 0.45 vs hypertrophy 0.30 — effort matters more
-        const partialWithEffort = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsPartial.initialRecords.map((r) => (Object.assign(Object.assign({}, r), { rpe: "8" })));
-        const strengthUser = Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessGoals: ["strength"] });
-        const hypertrophyUser = Object.assign(Object.assign({}, user_mock_1.mockUser), { fitnessGoals: ["hypertrophy"] });
-        const strengthResult = (0, index_1.calculateExerciseScoreV2)({
-            exercise: exercises_mock_1.mockExerciseWeightReps,
-            record: partialWithEffort,
-            user: strengthUser,
-        });
-        const hypertrophyResult = (0, index_1.calculateExerciseScoreV2)({
-            exercise: exercises_mock_1.mockExerciseWeightReps,
-            record: partialWithEffort,
-            user: hypertrophyUser,
-        });
-        // completion=50, consistency=100, effortAdequacy=100, restDiscipline=75
-        // strength:    50×0.15 + 100×0.25 + 100×0.45 + 75×0.15 = 88.75 → 89
-        // hypertrophy: 50×0.20 + 100×0.35 + 100×0.30 + 75×0.15 = 86.25 → 86
-        (0, vitest_1.expect)(strengthResult.scoresByGoal.strength.score).toBe(89);
-        (0, vitest_1.expect)(hypertrophyResult.scoresByGoal.hypertrophy.score).toBe(86);
-        (0, vitest_1.expect)(strengthResult.scoresByGoal.strength.score).toBeGreaterThan(hypertrophyResult.scoresByGoal.hypertrophy.score);
-    });
-    // ---------------------------------------------------------------------------
     // P2-5: estimatedOneRepMax in referenceMax
     // ---------------------------------------------------------------------------
-    (0, vitest_1.it)("P2-5: user near their 1RM shows higher muscle fatigue than a strong user doing the same weight", () => {
+    (0, vitest_1.it)("P2-5: user near their 1RM shows higher muscle fatigue than a strong user doing same weight", () => {
         const template = templateExercises_mock_1.mockTemplateExercisesDictionary.weightRepsStandard;
-        // Weak user: 1RM=60kg — the session's top set (85kg) exceeds their 1RM,
-        // so referenceMax is low → same absolute volume normalises to a higher score
+        // Weak user: 1RM=60kg — session top set (85kg) exceeds their 1RM → low referenceMax → high fatigue score
         const weakUserResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
             user: user_mock_1.mockUser,
             historicalContext: { estimatedOneRepMax: 60 },
         });
-        // Strong user: 1RM=200kg — 85kg is only ~43% of max → low relative effort
-        // referenceMax is high → same absolute volume normalises to a lower score
+        // Strong user: 1RM=200kg — 85kg is ~43% of max → high referenceMax → low fatigue score
         const strongUserResult = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: template.initialRecords,
@@ -385,43 +368,78 @@ const user_mock_1 = require("../../__mocks__/user.mock");
     // P2-6: previousSessionVolume cross-session progressive overload
     // ---------------------------------------------------------------------------
     (0, vitest_1.it)("P2-6: beating previous session volume floors consistency at 75 even with high CV", () => {
-        // Highly inconsistent sets: [100kg×10, 50kg×5, 90kg×8]
-        // volume metric: [1000, 250, 720]
-        // CV ≈ 0.47 → base consistency score = clamp(100 - 0.47×200, 20, 100) = 20
+        // Highly inconsistent sets: [100×10, 50×5, 90×8]
+        // volume metric: [1000, 250, 720], CV ≈ 0.47 → base consistency = 20 (CONSISTENCY_MIN_SCORE)
         const inconsistentRecords = [
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "100", reps: "10" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "5" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "90", reps: "8" },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "100",
+                reps: "10",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "5",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "90",
+                reps: "8",
+            },
         ];
         const withoutContext = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: inconsistentRecords,
             user: user_mock_1.mockUser,
         });
-        // currentSessionVolume = 1970, previousSessionVolume = 1000 → 1970 >= 1000 → progressive
+        // currentVolume = 1970, previousSessionVolume = 1000 → 1970 >= 1000 → progressive overload floor
         const withContext = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: inconsistentRecords,
             user: user_mock_1.mockUser,
             historicalContext: { previousSessionVolume: 1000 },
         });
-        (0, vitest_1.expect)(withoutContext.scoresByGoal.hypertrophy.qualityBreakdown.consistency).toBe(20); // CONSISTENCY_MIN_SCORE
-        (0, vitest_1.expect)(withContext.scoresByGoal.hypertrophy.qualityBreakdown.consistency).toBe(75); // PROGRESSIVE_OVERLOAD_FLOOR
+        (0, vitest_1.expect)(withoutContext.qualityBreakdown.consistency).toBe(20); // CONSISTENCY_MIN_SCORE
+        (0, vitest_1.expect)(withContext.qualityBreakdown.consistency).toBe(75); // PROGRESSIVE_OVERLOAD_FLOOR
     });
     (0, vitest_1.it)("P2-6: not beating previous session volume does NOT trigger the floor", () => {
         const inconsistentRecords = [
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "100", reps: "10" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "50", reps: "5" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "90", reps: "8" },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "100",
+                reps: "10",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "50",
+                reps: "5",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "90",
+                reps: "8",
+            },
         ];
-        // currentSessionVolume = 1970, previousSessionVolume = 3000 → 1970 < 3000 → no floor
-        const result = (0, index_1.calculateExerciseScoreV2)({
+        // currentVolume = 1970, previousSessionVolume = 3000 → 1970 < 3000 → no floor
+        const { qualityBreakdown } = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
             record: inconsistentRecords,
             user: user_mock_1.mockUser,
             historicalContext: { previousSessionVolume: 3000 },
         });
-        (0, vitest_1.expect)(result.scoresByGoal.hypertrophy.qualityBreakdown.consistency).toBe(20); // no floor applied
+        (0, vitest_1.expect)(qualityBreakdown.consistency).toBe(20);
     });
     // ---------------------------------------------------------------------------
     // P2-10: trainingAgeBracket RIR attenuation + referenceMax scaling
@@ -430,9 +448,30 @@ const user_mock_1 = require("../../__mocks__/user.mock");
         // RIR 0 = near-failure: effortFraction ≈ 1.3 without attenuation
         // With beginner: effortFraction = 0.6 + (1.3 - 0.6) × 0.5 = 0.95
         const nearFailureRecords = [
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "80", reps: "5", rir: "0" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "80", reps: "5", rir: "0" },
-            { type: "weight-reps", isDone: true, isStrictMode: false, kg: "80", reps: "5", rir: "0" },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "80",
+                reps: "5",
+                rir: "0",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "80",
+                reps: "5",
+                rir: "0",
+            },
+            {
+                type: "weight-reps",
+                isDone: true,
+                isStrictMode: false,
+                kg: "80",
+                reps: "5",
+                rir: "0",
+            },
         ];
         const noContext = (0, index_1.calculateExerciseScoreV2)({
             exercise: exercises_mock_1.mockExerciseWeightReps,
@@ -445,8 +484,7 @@ const user_mock_1 = require("../../__mocks__/user.mock");
             user: user_mock_1.mockUser,
             historicalContext: { trainingAgeBracket: "beginner" },
         });
-        // Beginner: lower effort (attenuated) + lower referenceMax (0.80 scale)
-        // Net effect: ~9% lower score. Verified: noContext ≈ 20, beginnerContext ≈ 18
+        // Beginner: lower effort (attenuated) + lower referenceMax (0.80 scale) → lower fatigue score
         (0, vitest_1.expect)(beginnerContext.muscleScores["quadriceps"]).toBeLessThan(noContext.muscleScores["quadriceps"]);
     });
     (0, vitest_1.it)("P2-10: advanced bracket raises referenceMax → lower fatigue score for same work than intermediate", () => {