refactor(exercises): route pipeline through exercise objects

README.md

@@ -21,7 +21,7 @@ tags:
 
 Pozify is a Gradio + uv base project for a video-based workout form review app.
 
-The current implementation contains the full application pipeline, step inputs/outputs, and JSON data contracts. The model and computer-vision steps are intentionally mocked so the team can replace each step with real implementations without changing the pipeline interface.
+The current implementation contains the full application pipeline, step inputs/outputs, and JSON data contracts. Uploaded videos use real video QC, MediaPipe pose extraction, and real rep segmentation by default; no-video/demo runs still use mock pose data.
 
 ## Run The App
 
@@ -37,15 +37,15 @@ uv run gradio app.py
 
 The app runs at `http://127.0.0.1:7860` by default.
 
-The pipeline runs in mock mode by default. To be explicit in scripts, call
-`run_pipeline(..., mock=True)` or set:
+The pipeline runs with real pose extraction by default when a video path is provided. No-video runs
+default to mock mode. To force mock mode in scripts, call `run_pipeline(..., mock=True)` or set:
 
 ```bash
 POZIFY_MOCK_MODE=1 uv run python app.py
 ```
 
-To run the end-to-end app with real video QC, MediaPipe pose extraction, real rep segmentation, and
-annotated video rendering, set:
+To force the end-to-end app to use real video QC, MediaPipe pose extraction, real rep segmentation,
+and annotated video rendering even when `POZIFY_MOCK_MODE` is set elsewhere, set:
 
 ```bash
 POZIFY_MOCK_MODE=0 uv run python app.py
@@ -92,8 +92,9 @@ user profile + input video
 -> final report
 ```
 
-After classification, the pipeline creates one object for the detected exercise class and passes that
-object through rep counting, rep analysis, variation detection, and issue marking.
+After classification, the pipeline creates one object for the detected exercise class with the video
+manifest, cleaned pose sequence, and user profile. Rep counting, rep analysis, variation detection,
+and issue marking then run as methods on that exercise object.
 
 ## Project Structure
 
@@ -119,15 +120,12 @@ src/pozify/
     shared/
       analyzer.py
       issue_marker.py
+      rep_counter.py
   steps/
     video_qc.py
     pose_landmarker.py
     pose_cleaning.py
     exercise_classifier.py
-    rep_counter.py
-    rep_analysis.py
-    variation_detector.py
-    issue_marker.py
     annotated_renderer.py
     coach_summary.py
     verifier.py
@@ -210,21 +208,22 @@ Recommended replacement order:
 1. `video_qc.py`: read real video metadata with OpenCV.
 2. `pose_backends/`: add or refine pose model adapters such as MediaPipe or MMPose.
 3. `exercise_classifier.py`: load the exercise router model.
-4. `rep_counter.py`: implement exercise-specific state machines.
-5. `issue_marker.py`: compute real issue scores and intervals from rep metrics.
-6. `annotated_renderer.py`: render skeleton overlays and issue highlights.
-7. `coach_summary.py`: call the selected small language model with retrieved knowledge cards.
+4. `exercises/<exercise>/strategy.py`: implement exercise-specific rep signals and variation logic.
+5. `exercises/<exercise>/analyzer.py`: compute per-rep metrics.
+6. `exercises/<exercise>/issue_markers.py`: compute real issue scores and intervals.
+7. `annotated_renderer.py`: render skeleton overlays and issue highlights.
+8. `coach_summary.py`: call the selected small language model with retrieved knowledge cards.
 
 ## Development Checks
 
 ```bash
 uv run python -m unittest discover -s tests
-python3 -m py_compile app.py src/pozify/*.py src/pozify/steps/*.py
+python3 -m py_compile app.py src/pozify/*.py src/pozify/steps/*.py src/pozify/exercises/*.py src/pozify/exercises/*/*.py
 uv run python -c "import app; from pozify.pipeline import run_pipeline; print('ok')"
 ```
 
-The unit tests run the full mocked pipeline with no video input and with a small fixture path, then
-assert deterministic top-level keys for each JSON artifact.
+The unit tests run the full mocked pipeline explicitly, then assert deterministic top-level keys for
+each JSON artifact.
 
 ## Git Hooks
 

src/pozify/exercises/base.py

@@ -1,12 +1,55 @@
 from __future__ import annotations
 
-from pozify.contracts import PoseFrame, RepAnalysis
-from pozify.exercises.shared.analyzer import ExerciseMetricResult
-from pozify.exercises.shared.issue_marker import IssueRule
-from pozify.steps.rep_counters.base import ExerciseRepCounter
+from statistics import mean, pstdev
+from typing import Any
+
+from pozify.contracts import (
+    IssueMarker,
+    IssueMarkers,
+    PoseFrame,
+    PoseSequence,
+    Rep,
+    RepAnalysis,
+    RepAnalysisItem,
+    Reps,
+    UserProfile,
+    VideoManifest,
+    Variation,
+)
+from pozify.exercise_catalog import get_exercise_spec
+from pozify.exercises.shared.analyzer import (
+    ExerciseMetricResult,
+    mean_optional,
+    round_optional,
+    safe_ratio,
+    score,
+    usable,
+    value_series,
+)
+from pozify.exercises.shared.issue_marker import (
+    IssueRule,
+    frame_scores_for_rule,
+    frames_for_rep,
+    group_violations,
+    marker_from_group,
+    minimum_run_length,
+)
+from pozify.exercises.shared.rep_counter import ExerciseRepCounter
+from pozify.steps.rep_signals import average_axis
 
 
 class ExerciseStrategy(ExerciseRepCounter):
+    def __init__(
+        self,
+        *,
+        video_manifest: VideoManifest,
+        pose_sequence: PoseSequence,
+        profile: UserProfile,
+    ) -> None:
+        self.video_manifest = video_manifest
+        self.pose_sequence = pose_sequence
+        self.profile = profile
+
     def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
         raise NotImplementedError
 
@@ -19,6 +62,249 @@ class ExerciseStrategy(ExerciseRepCounter):
     def issue_rules(self) -> tuple[IssueRule, ...]:
         return ()
 
+    def analyze_reps(self, reps: Reps) -> RepAnalysis:
+        draft_items: list[tuple[Rep, dict[str, Any], float, float, float, list[str]]] = []
+        for rep in reps.reps:
+            rep_frames = self.frames_for_rep(rep)
+            primary_signal = self.primary_signal(rep_frames)
+            common_metrics = self.common_rep_metrics(rep, rep_frames, primary_signal)
+            exercise_metrics, rom_score, stability_score, symmetry_score, hints = self.metrics(rep_frames)
+            metrics = {**common_metrics, **exercise_metrics}
+            draft_items.append((rep, metrics, rom_score, stability_score, symmetry_score, hints))
+
+        average_duration = (
+            mean(item[1]["rep_duration_sec"] for item in draft_items)
+            if draft_items
+            else 0.0
+        )
+        items: list[RepAnalysisItem] = []
+        for rep, metrics, rom_score, stability_score, symmetry_score, hints in draft_items:
+            duration = metrics["rep_duration_sec"]
+            metrics["tempo_consistency_score"] = (
+                score(1.0 - abs(duration - average_duration) / max(average_duration, 0.1))
+                if average_duration
+                else 0.0
+            )
+            items.append(
+                RepAnalysisItem(
+                    rep_id=rep.rep_id,
+                    duration_sec=duration,
+                    range_of_motion_score=rom_score,
+                    stability_score=stability_score,
+                    symmetry_score=symmetry_score,
+                    metrics=metrics,
+                    variation_hints=sorted(set(hints)),
+                )
+            )
+
+        aggregate_metrics = {
+            "avg_rom_score": (
+                round(mean(item.range_of_motion_score for item in items), 2) if items else 0.0
+            ),
+            "avg_stability_score": (
+                round(mean(item.stability_score for item in items), 2) if items else 0.0
+            ),
+            "avg_symmetry_score": (
+                round(mean(item.symmetry_score for item in items), 2) if items else 0.0
+            ),
+            "avg_rep_duration_sec": (
+                round(mean(item.duration_sec for item in items), 2) if items else 0.0
+            ),
+            "avg_tempo_consistency_score": self.aggregate_numeric(items, "tempo_consistency_score")
+            or 0.0,
+            "avg_landmark_confidence": (
+                self.aggregate_numeric(items, "landmark_confidence") or self.pose_sequence.pose_valid_ratio
+            ),
+            "fatigue_trend_rom_delta": self.fatigue_trend(items),
+            "pose_valid_ratio": self.pose_sequence.pose_valid_ratio,
+        }
+
+        for metric_name in (
+            "hand_width_ratio",
+            "stance_width_ratio",
+            "bottom_pause_sec",
+            "lockout_quality",
+            "wrist_height_asymmetry",
+            "wrist_travel",
+            "knee_support_score",
+        ):
+            aggregate_value = self.aggregate_numeric(items, metric_name)
+            if aggregate_value is not None:
+                aggregate_metrics[f"avg_{metric_name}"] = aggregate_value
+
+        return RepAnalysis(
+            exercise=self.exercise,
+            items=items,
+            aggregate_metrics=aggregate_metrics,
+        )
+
+    def resolve_variation(self, analysis: RepAnalysis) -> Variation:
+        if self.profile.intended_variation:
+            variation = self.profile.intended_variation
+            confidence = 0.95
+            not_issues = self.profile_not_issues(variation)
+        else:
+            variation, confidence, not_issues = self.detect_variation(analysis)
+
+        if analysis.aggregate_metrics.get("avg_rom_score", 1.0) < 0.7:
+            not_issues.append("low_rom_requires_user_intent_check")
+        if analysis.aggregate_metrics.get("pose_valid_ratio", 1.0) < 0.8:
+            not_issues.append("low_pose_confidence_limits_variation_call")
+
+        return Variation(
+            exercise=self.exercise,
+            detected_variation=variation,
+            variation_confidence=confidence,
+            not_issues=sorted(set(not_issues)),
+        )
+
+    def mark_issues(
+        self,
+        reps: Reps,
+        analysis: RepAnalysis,
+        variation: Variation,
+    ) -> IssueMarkers:
+        rep_by_id = {rep.rep_id: rep for rep in reps.reps}
+        issues: list[IssueMarker] = []
+
+        for item in analysis.items:
+            rep = rep_by_id.get(item.rep_id)
+            if rep is None:
+                continue
+
+            rep_frames = frames_for_rep(self.pose_sequence, rep)
+            if not rep_frames:
+                fallback = self.fallback_rep_marker(reps, item, variation)
+                if fallback is not None:
+                    issues.append(fallback)
+                continue
+
+            min_run_length = minimum_run_length(rep_frames)
+            for rule in self.issue_rules():
+                if set(rule.suppress_when_not_issue) & set(variation.not_issues):
+                    continue
+
+                scores = frame_scores_for_rule(rep_frames, self.exercise, rule)
+                for group in group_violations(scores, min_run_length):
+                    issues.append(marker_from_group(rule, group, item, variation))
+
+        return IssueMarkers(
+            issues=sorted(
+                issues,
+                key=lambda issue: (issue.start_frame, issue.end_frame, issue.rep_id, issue.issue),
+            )
+        )
+
+    def frames_for_rep(self, rep: Rep) -> list[PoseFrame]:
+        rep_frames = [
+            frame
+            for frame in self.pose_sequence.frames
+            if rep.start_frame <= frame.frame_index <= rep.end_frame
+        ]
+        if rep_frames:
+            return rep_frames
+
+        if not self.pose_sequence.frames:
+            return []
+        closest = min(
+            self.pose_sequence.frames,
+            key=lambda frame: min(
+                abs(frame.frame_index - rep.start_frame),
+                abs(frame.frame_index - rep.mid_frame),
+                abs(frame.frame_index - rep.end_frame),
+            ),
+        )
+        return [closest]
+
+    def primary_signal(self, frames: list[PoseFrame]) -> list[float | None]:
+        if self.exercise == "shoulder_press":
+            return value_series(
+                frames,
+                lambda frame: average_axis(frame, ("left_wrist", "right_wrist"), "y"),
+            )
+        if self.exercise == "push_up":
+            return value_series(
+                frames,
+                lambda frame: mean_optional(
+                    [
+                        average_axis(frame, ("left_shoulder", "right_shoulder"), "y"),
+                        average_axis(frame, ("left_hip", "right_hip"), "y"),
+                    ]
+                ),
+            )
+        return value_series(frames, lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"))
+
+    def common_rep_metrics(
+        self,
+        rep: Rep,
+        frames: list[PoseFrame],
+        primary_signal: list[float | None],
+    ) -> dict[str, Any]:
+        eccentric_duration = round(max(0.0, rep.mid_sec - rep.start_sec), 2)
+        concentric_duration = round(max(0.0, rep.end_sec - rep.mid_sec), 2)
+        duration = round(max(0.0, rep.end_sec - rep.start_sec), 2)
+        smoothness_score, jerk_score = self.smoothness_score(primary_signal)
+        stability_axis = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_hip", "right_hip"), "x"),
+        )
+        stability_noise = self.std(stability_axis) or 0.0
+
+        return {
+            "rep_duration_sec": duration,
+            "eccentric_duration_sec": eccentric_duration,
+            "concentric_duration_sec": concentric_duration,
+            "tempo_ratio": round_optional(safe_ratio(eccentric_duration, concentric_duration), 2),
+            "top_pause_sec": self.pause_duration(frames, primary_signal, target="top"),
+            "bottom_pause_sec": self.pause_duration(frames, primary_signal, target="bottom"),
+            "smoothness_score": smoothness_score,
+            "jerk_score": round_optional(jerk_score, 4),
+            "landmark_confidence": self.mean_visibility(frames),
+            "hip_lateral_drift": round_optional(stability_noise, 4),
+        }
+
+    def fallback_rep_marker(
+        self,
+        reps: Reps,
+        item: RepAnalysisItem,
+        variation: Variation,
+    ) -> IssueMarker | None:
+        exercise_spec = get_exercise_spec(reps.exercise)
+        if item.stability_score >= 0.78 or exercise_spec.mock_issue is None:
+            return None
+
+        rep = next((rep for rep in reps.reps if rep.rep_id == item.rep_id), None)
+        if rep is None:
+            return None
+
+        issue_spec = exercise_spec.mock_issue
+        metric_value = (
+            item.range_of_motion_score
+            if issue_spec.evidence_metric == "range_of_motion_score"
+            else item.metrics.get(issue_spec.evidence_metric)
+        )
+        return IssueMarker(
+            rep_id=item.rep_id,
+            issue=issue_spec.issue,
+            severity=round(1.0 - item.stability_score, 2),
+            start_frame=rep.mid_frame,
+            end_frame=rep.end_frame,
+            start_sec=rep.mid_sec,
+            end_sec=rep.end_sec,
+            affected_joints=list(issue_spec.affected_joints),
+            evidence={
+                issue_spec.evidence_metric: metric_value,
+                "threshold": issue_spec.threshold,
+                "confidence": round(max(0.0, min(1.0, 1.0 - item.stability_score)), 2),
+                "variation_context": {
+                    "detected_variation": variation.detected_variation,
+                    "variation_confidence": variation.variation_confidence,
+                    "not_issues": list(variation.not_issues),
+                },
+                "fallback": "rep_level_metrics",
+            },
+        )
+
     def metric(self, analysis: RepAnalysis, name: str) -> float | None:
         value = analysis.aggregate_metrics.get(name)
         if isinstance(value, (int, float)):
@@ -35,3 +321,90 @@ class ExerciseStrategy(ExerciseRepCounter):
         metric_bonus = 0.0 if supporting_metric is None else min(0.1, abs(supporting_metric) * 0.03)
         pose_bonus = min(0.08, float(analysis.aggregate_metrics.get("pose_valid_ratio", 0.0)) * 0.08)
         return round(min(0.95, base + rep_bonus + metric_bonus + pose_bonus), 2)
+
+    def std(self, values: list[float | None]) -> float | None:
+        usable_values = usable(values)
+        if len(usable_values) < 2:
+            return 0.0 if usable_values else None
+        return pstdev(usable_values)
+
+    def mean_visibility(self, frames: list[PoseFrame]) -> float:
+        values: list[float | None] = []
+        for frame in frames:
+            if "mean_visibility" in frame.pose_quality:
+                values.append(float(frame.pose_quality["mean_visibility"]))
+                continue
+            landmark_values = [
+                landmark.get("visibility")
+                for landmark in frame.landmarks.values()
+                if landmark.get("visibility") is not None
+            ]
+            values.extend(float(value) for value in landmark_values)
+        return score(mean_optional(values) if values else 0.0)
+
+    def smoothness_score(self, signal_values: list[float | None]) -> tuple[float, float | None]:
+        usable_values = usable(signal_values)
+        if len(usable_values) < 4:
+            return 0.5, None
+
+        deltas = [
+            usable_values[index] - usable_values[index - 1]
+            for index in range(1, len(usable_values))
+        ]
+        jerks = [deltas[index] - deltas[index - 1] for index in range(1, len(deltas))]
+        if not jerks:
+            return 0.5, None
+        jerk = mean(abs(value) for value in jerks)
+        return score(1.0 - jerk * 8.0), jerk
+
+    def pause_duration(
+        self,
+        frames: list[PoseFrame],
+        signal_values: list[float | None],
+        *,
+        target: str,
+    ) -> float:
+        usable_values = usable(signal_values)
+        if len(usable_values) < 3 or len(frames) < 3:
+            return 0.0
+
+        min_value = min(usable_values)
+        max_value = max(usable_values)
+        tolerance = max((max_value - min_value) * 0.08, 0.01)
+        if target == "bottom":
+            active = [value is not None and value >= max_value - tolerance for value in signal_values]
+        else:
+            active = [value is not None and value <= min_value + tolerance for value in signal_values]
+
+        longest = 0
+        current = 0
+        for item in active:
+            if item:
+                current += 1
+                longest = max(longest, current)
+            else:
+                current = 0
+
+        if longest <= 1:
+            return 0.0
+        frame_duration = (frames[-1].timestamp_sec - frames[0].timestamp_sec) / max(
+            1, len(frames) - 1
+        )
+        return round(longest * frame_duration, 2)
+
+    def aggregate_numeric(self, items: list[RepAnalysisItem], metric_name: str) -> float | None:
+        values = [
+            item.metrics.get(metric_name)
+            for item in items
+            if isinstance(item.metrics.get(metric_name), (int, float))
+        ]
+        if not values:
+            return None
+        return round(sum(float(value) for value in values) / len(values), 4)
+
+    def fatigue_trend(self, items: list[RepAnalysisItem]) -> float:
+        if len(items) < 2:
+            return 0.0
+        first = items[0].range_of_motion_score
+        last = items[-1].range_of_motion_score
+        return round(last - first, 4)

src/pozify/exercises/push_up/strategy.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence, RepAnalysis
+from pozify.contracts import RepAnalysis
 from pozify.exercises.base import ExerciseStrategy
 from pozify.exercises.push_up.analyzer import PushUpAnalyzer
 from pozify.exercises.shared.issue_marker import IssueRule
 from pozify.exercises.push_up.issue_markers import RULES as ISSUE_RULES
-from pozify.steps.rep_counters.base import combine, mean_optional, normalized_samples
+from pozify.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
@@ -17,7 +17,8 @@ class PushUpExercise(PushUpAnalyzer, ExerciseStrategy):
     def issue_rules(self) -> tuple[IssueRule, ...]:
         return ISSUE_RULES
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def build_signal(self) -> tuple[list[SignalSample], dict[str, Any]]:
+        sequence = self.pose_sequence
         hip_y = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in sequence.frames]
         shoulder_y = [average_axis(frame, ("left_shoulder", "right_shoulder"), "y") for frame in sequence.frames]
         elbow_bend = [

src/pozify/exercises/registry.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pozify.contracts import PoseSequence, UserProfile, VideoManifest
 from pozify.exercises.base import ExerciseStrategy
 from pozify.exercises.push_up import PushUpExercise
 from pozify.exercises.shoulder_press import ShoulderPressExercise
@@ -15,6 +16,16 @@ EXERCISE_CLASSES: dict[str, type[ExerciseStrategy]] = {
 }
 
 
-def create_exercise_strategy(exercise: str) -> ExerciseStrategy:
+def create_exercise_strategy(
+    exercise: str,
+    *,
+    video_manifest: VideoManifest,
+    pose_sequence: PoseSequence,
+    profile: UserProfile,
+) -> ExerciseStrategy:
     exercise_class = EXERCISE_CLASSES.get(exercise, UnknownExercise)
-    return exercise_class()
+    return exercise_class(
+        video_manifest=video_manifest,
+        pose_sequence=pose_sequence,
+        profile=profile,
+    )

src/pozify/exercises/shared/__init__.py

@@ -1,4 +1,5 @@
 from pozify.exercises.shared.analyzer import ExerciseAnalyzer, ExerciseMetricResult
 from pozify.exercises.shared.issue_marker import IssueRule
+from pozify.exercises.shared.rep_counter import ExerciseRepCounter
 
-__all__ = ["ExerciseAnalyzer", "ExerciseMetricResult", "IssueRule"]
+__all__ = ["ExerciseAnalyzer", "ExerciseMetricResult", "ExerciseRepCounter", "IssueRule"]

src/pozify/{steps/rep_counters/base.py → exercises/shared/rep_counter.py}

@@ -117,17 +117,19 @@ def partial_reps(
 
 class ExerciseRepCounter(ABC):
     exercise: str
+    pose_sequence: PoseSequence
     min_cycle_frames = MIN_CYCLE_FRAMES
     min_phase_frames = MIN_PHASE_FRAMES
     min_signal_range = MIN_SIGNAL_RANGE
     min_usable_signal_samples = MIN_USABLE_SIGNAL_SAMPLES
 
     @abstractmethod
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def build_signal(self) -> tuple[list[SignalSample], dict[str, Any]]:
         """Build the exercise-specific normalized motion signal."""
 
-    def count(self, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
-        samples, debug = self.build_signal(sequence)
+    def count(self) -> tuple[Reps, dict[str, Any]]:
+        sequence = self.pose_sequence
+        samples, debug = self.build_signal()
         signal_range = debug["raw_signal_range"]
         extrema = find_local_extrema(samples)
         min_amplitude = max(self.min_signal_range, signal_range * 0.35)
@@ -177,4 +179,3 @@ class ExerciseRepCounter(ABC):
             ],
         }
         return reps, debug_payload
-

src/pozify/exercises/shoulder_press/strategy.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence, RepAnalysis
+from pozify.contracts import RepAnalysis
 from pozify.exercises.base import ExerciseStrategy
 from pozify.exercises.shoulder_press.analyzer import ShoulderPressAnalyzer
 from pozify.exercises.shared.issue_marker import IssueRule
 from pozify.exercises.shoulder_press.issue_markers import RULES as ISSUE_RULES
-from pozify.steps.rep_counters.base import combine, mean_optional, normalized_samples
+from pozify.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
@@ -17,7 +17,8 @@ class ShoulderPressExercise(ShoulderPressAnalyzer, ExerciseStrategy):
     def issue_rules(self) -> tuple[IssueRule, ...]:
         return ISSUE_RULES
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def build_signal(self) -> tuple[list[SignalSample], dict[str, Any]]:
+        sequence = self.pose_sequence
         wrist_y = [average_axis(frame, ("left_wrist", "right_wrist"), "y") for frame in sequence.frames]
         elbow_bend = [
             mean_optional(

src/pozify/exercises/squat/strategy.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence, RepAnalysis
+from pozify.contracts import RepAnalysis
 from pozify.exercises.base import ExerciseStrategy
 from pozify.exercises.squat.analyzer import SquatAnalyzer
 from pozify.exercises.shared.issue_marker import IssueRule
 from pozify.exercises.squat.issue_markers import RULES as ISSUE_RULES
-from pozify.steps.rep_counters.base import combine, mean_optional, normalized_samples
+from pozify.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
@@ -17,7 +17,8 @@ class SquatExercise(SquatAnalyzer, ExerciseStrategy):
     def issue_rules(self) -> tuple[IssueRule, ...]:
         return ISSUE_RULES
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def build_signal(self) -> tuple[list[SignalSample], dict[str, Any]]:
+        sequence = self.pose_sequence
         hip_y = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in sequence.frames]
         knee_bend = [
             mean_optional(

src/pozify/exercises/unknown/strategy.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence, RepAnalysis, Reps
+from pozify.contracts import RepAnalysis, Reps
 from pozify.exercise_catalog import get_exercise_spec
 from pozify.exercises.base import ExerciseStrategy
 from pozify.exercises.unknown.analyzer import UnknownAnalyzer
@@ -12,10 +12,10 @@ from pozify.steps.rep_signals import SignalSample
 class UnknownExercise(UnknownAnalyzer, ExerciseStrategy):
     exercise = "unknown"
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def build_signal(self) -> tuple[list[SignalSample], dict[str, Any]]:
         return [], {"selected_signal": "none", "thresholds": {}, "extrema": [], "accepted_reps": []}
 
-    def count(self, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
+    def count(self) -> tuple[Reps, dict[str, Any]]:
         reps = Reps(exercise=self.exercise, reps=[], partial_reps=[{"reason": "unknown_exercise"}])
         return reps, {"selected_signal": "none", "thresholds": {}, "extrema": [], "accepted_reps": []}
 

src/pozify/pipeline.py

@@ -13,12 +13,8 @@ from pozify.steps import (
     annotated_renderer,
     coach_summary,
     exercise_classifier,
-    issue_marker,
     pose_cleaning,
     pose_landmarker,
-    rep_analysis,
-    rep_counter,
-    variation_detector,
     verifier,
     video_qc,
 )
@@ -27,8 +23,12 @@ from pozify.steps import (
 RUNS_DIR = Path("runs")
 
 
-def _env_mock_mode() -> bool:
-    value = os.getenv("POZIFY_MOCK_MODE", "1").strip().lower()
+def _env_mock_mode(video_path: str | None) -> bool:
+    configured = os.getenv("POZIFY_MOCK_MODE")
+    if configured is None:
+        return video_path is None
+
+    value = configured.strip().lower()
     return value not in {"0", "false", "no", "off"}
 
 
@@ -38,7 +38,7 @@ def run_pipeline(
     *,
     mock: bool | None = None,
 ) -> dict[str, Any]:
-    mock_mode = _env_mock_mode() if mock is None else mock
+    mock_mode = _env_mock_mode(video_path) if mock is None else mock
 
     run_id = f"{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}-{uuid4().hex[:8]}"
     run_dir = RUNS_DIR / run_id
@@ -74,19 +74,24 @@ def run_pipeline(
     classification = exercise_classifier.run(cleaned_pose_sequence, profile)
     write_artifact("exercise_classification.json", classification)
 
-    exercise = create_exercise_strategy(classification.exercise)
+    exercise = create_exercise_strategy(
+        classification.exercise,
+        video_manifest=manifest,
+        pose_sequence=cleaned_pose_sequence,
+        profile=profile,
+    )
 
-    reps, rep_debug = rep_counter.run(exercise, cleaned_pose_sequence)
+    reps, rep_debug = exercise.count()
     write_artifact("reps.json", reps)
     write_artifact("rep_debug.json", rep_debug)
 
-    analysis = rep_analysis.run(exercise, reps, cleaned_pose_sequence)
+    analysis = exercise.analyze_reps(reps)
     write_artifact("rep_analysis.json", analysis)
 
-    variation = variation_detector.run(exercise, analysis, profile)
+    variation = exercise.resolve_variation(analysis)
     write_artifact("variation.json", variation)
 
-    issues = issue_marker.run(exercise, reps, analysis, variation, cleaned_pose_sequence)
+    issues = exercise.mark_issues(reps, analysis, variation)
     write_artifact("issue_markers.json", issues)
 
     annotated_video_path = annotated_renderer.run(manifest, cleaned_pose_sequence, reps, issues, run_dir)

src/pozify/steps/issue_marker.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-from pozify.contracts import (
-    IssueMarker,
-    IssueMarkers,
-    PoseSequence,
-    RepAnalysis,
-    RepAnalysisItem,
-    Reps,
-    Variation,
-)
-from pozify.exercise_catalog import get_exercise_spec
-from pozify.exercises import ExerciseStrategy
-from pozify.exercises.shared.issue_marker import (
-    frame_scores_for_rule,
-    frames_for_rep,
-    group_violations,
-    marker_from_group,
-    minimum_run_length,
-)
-
-
-def _fallback_rep_marker(
-    reps: Reps,
-    item: RepAnalysisItem,
-    variation: Variation,
-) -> IssueMarker | None:
-    exercise_spec = get_exercise_spec(reps.exercise)
-    if item.stability_score >= 0.78 or exercise_spec.mock_issue is None:
-        return None
-
-    rep = next((rep for rep in reps.reps if rep.rep_id == item.rep_id), None)
-    if rep is None:
-        return None
-
-    issue_spec = exercise_spec.mock_issue
-    metric_value = (
-        item.range_of_motion_score
-        if issue_spec.evidence_metric == "range_of_motion_score"
-        else item.metrics.get(issue_spec.evidence_metric)
-    )
-    return IssueMarker(
-        rep_id=item.rep_id,
-        issue=issue_spec.issue,
-        severity=round(1.0 - item.stability_score, 2),
-        start_frame=rep.mid_frame,
-        end_frame=rep.end_frame,
-        start_sec=rep.mid_sec,
-        end_sec=rep.end_sec,
-        affected_joints=list(issue_spec.affected_joints),
-        evidence={
-            issue_spec.evidence_metric: metric_value,
-            "threshold": issue_spec.threshold,
-            "confidence": round(max(0.0, min(1.0, 1.0 - item.stability_score)), 2),
-            "variation_context": {
-                "detected_variation": variation.detected_variation,
-                "variation_confidence": variation.variation_confidence,
-                "not_issues": list(variation.not_issues),
-            },
-            "fallback": "rep_level_metrics",
-        },
-    )
-
-
-def run(
-    exercise: ExerciseStrategy,
-    reps: Reps,
-    analysis: RepAnalysis,
-    variation: Variation,
-    sequence: PoseSequence | None = None,
-) -> IssueMarkers:
-    rep_by_id = {rep.rep_id: rep for rep in reps.reps}
-    rules = exercise.issue_rules()
-    issues: list[IssueMarker] = []
-
-    for item in analysis.items:
-        rep = rep_by_id.get(item.rep_id)
-        if rep is None:
-            continue
-
-        frames = frames_for_rep(sequence, rep)
-        if not frames:
-            fallback = _fallback_rep_marker(reps, item, variation)
-            if fallback is not None:
-                issues.append(fallback)
-            continue
-
-        min_run_length = minimum_run_length(frames)
-        for rule in rules:
-            if set(rule.suppress_when_not_issue) & set(variation.not_issues):
-                continue
-
-            scores = frame_scores_for_rule(frames, exercise.exercise, rule)
-            for group in group_violations(scores, min_run_length):
-                issues.append(marker_from_group(rule, group, item, variation))
-
-    return IssueMarkers(
-        issues=sorted(
-            issues,
-            key=lambda issue: (issue.start_frame, issue.end_frame, issue.rep_id, issue.issue),
-        )
-    )

src/pozify/steps/rep_analysis.py

@@ -1,266 +0,0 @@
-from __future__ import annotations
-
-from statistics import mean, pstdev
-from typing import Any, Callable
-
-from pozify.contracts import (
-    PoseFrame,
-    PoseSequence,
-    Rep,
-    RepAnalysis,
-    RepAnalysisItem,
-    Reps,
-)
-from pozify.exercises import ExerciseStrategy
-from pozify.exercises.shared.analyzer import (
-    mean_optional,
-    round_optional,
-    safe_ratio,
-    score,
-    usable,
-    value_series,
-)
-from pozify.steps.rep_signals import average_axis
-
-
-NumberGetter = Callable[[PoseFrame], float | None]
-
-
-def _std(values: list[float | None]) -> float | None:
-    usable_values = usable(values)
-    if len(usable_values) < 2:
-        return 0.0 if usable_values else None
-    return pstdev(usable_values)
-
-
-def _frames_for_rep(sequence: PoseSequence, rep: Rep) -> list[PoseFrame]:
-    frames = [
-        frame
-        for frame in sequence.frames
-        if rep.start_frame <= frame.frame_index <= rep.end_frame
-    ]
-    if frames:
-        return frames
-
-    if not sequence.frames:
-        return []
-    closest = min(
-        sequence.frames,
-        key=lambda frame: min(
-            abs(frame.frame_index - rep.start_frame),
-            abs(frame.frame_index - rep.mid_frame),
-            abs(frame.frame_index - rep.end_frame),
-        ),
-    )
-    return [closest]
-
-
-def _mean_visibility(frames: list[PoseFrame]) -> float:
-    values: list[float | None] = []
-    for frame in frames:
-        if "mean_visibility" in frame.pose_quality:
-            values.append(float(frame.pose_quality["mean_visibility"]))
-            continue
-        landmark_values = [
-            landmark.get("visibility")
-            for landmark in frame.landmarks.values()
-            if landmark.get("visibility") is not None
-        ]
-        values.extend(float(value) for value in landmark_values)
-    return score(mean_optional(values) if values else 0.0)
-
-
-def _smoothness_score(signal_values: list[float | None]) -> tuple[float, float | None]:
-    usable_values = usable(signal_values)
-    if len(usable_values) < 4:
-        return 0.5, None
-
-    deltas = [
-        usable_values[index] - usable_values[index - 1]
-        for index in range(1, len(usable_values))
-    ]
-    jerks = [deltas[index] - deltas[index - 1] for index in range(1, len(deltas))]
-    if not jerks:
-        return 0.5, None
-    jerk = mean(abs(value) for value in jerks)
-    return score(1.0 - jerk * 8.0), jerk
-
-
-def _pause_duration(
-    frames: list[PoseFrame],
-    signal_values: list[float | None],
-    *,
-    target: str,
-) -> float:
-    usable_values = usable(signal_values)
-    if len(usable_values) < 3 or len(frames) < 3:
-        return 0.0
-
-    min_value = min(usable_values)
-    max_value = max(usable_values)
-    tolerance = max((max_value - min_value) * 0.08, 0.01)
-    if target == "bottom":
-        active = [value is not None and value >= max_value - tolerance for value in signal_values]
-    else:
-        active = [value is not None and value <= min_value + tolerance for value in signal_values]
-
-    longest = 0
-    current = 0
-    for item in active:
-        if item:
-            current += 1
-            longest = max(longest, current)
-        else:
-            current = 0
-
-    if longest <= 1:
-        return 0.0
-    frame_duration = (frames[-1].timestamp_sec - frames[0].timestamp_sec) / max(1, len(frames) - 1)
-    return round(longest * frame_duration, 2)
-
-
-def _common_metrics(
-    rep: Rep,
-    frames: list[PoseFrame],
-    primary_signal: list[float | None],
-) -> dict[str, Any]:
-    eccentric_duration = round(max(0.0, rep.mid_sec - rep.start_sec), 2)
-    concentric_duration = round(max(0.0, rep.end_sec - rep.mid_sec), 2)
-    duration = round(max(0.0, rep.end_sec - rep.start_sec), 2)
-    smoothness_score, jerk_score = _smoothness_score(primary_signal)
-    stability_axis = value_series(
-        frames,
-        lambda frame: average_axis(frame, ("left_hip", "right_hip"), "x"),
-    )
-    stability_noise = _std(stability_axis) or 0.0
-
-    return {
-        "rep_duration_sec": duration,
-        "eccentric_duration_sec": eccentric_duration,
-        "concentric_duration_sec": concentric_duration,
-        "tempo_ratio": round_optional(safe_ratio(eccentric_duration, concentric_duration), 2),
-        "top_pause_sec": _pause_duration(frames, primary_signal, target="top"),
-        "bottom_pause_sec": _pause_duration(frames, primary_signal, target="bottom"),
-        "smoothness_score": smoothness_score,
-        "jerk_score": round_optional(jerk_score, 4),
-        "landmark_confidence": _mean_visibility(frames),
-        "hip_lateral_drift": round_optional(stability_noise, 4),
-    }
-
-
-def _primary_signal(exercise_key: str, frames: list[PoseFrame]) -> list[float | None]:
-    if exercise_key == "shoulder_press":
-        return value_series(
-            frames,
-            lambda frame: average_axis(frame, ("left_wrist", "right_wrist"), "y"),
-        )
-    if exercise_key == "push_up":
-        return value_series(
-            frames,
-            lambda frame: mean_optional(
-                [
-                    average_axis(frame, ("left_shoulder", "right_shoulder"), "y"),
-                    average_axis(frame, ("left_hip", "right_hip"), "y"),
-                ]
-            ),
-        )
-    return value_series(frames, lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"))
-
-
-def _aggregate_numeric(items: list[RepAnalysisItem], metric_name: str) -> float | None:
-    values = [
-        item.metrics.get(metric_name)
-        for item in items
-        if isinstance(item.metrics.get(metric_name), (int, float))
-    ]
-    if not values:
-        return None
-    return round(sum(float(value) for value in values) / len(values), 4)
-
-
-def _fatigue_trend(items: list[RepAnalysisItem]) -> float:
-    if len(items) < 2:
-        return 0.0
-    first = items[0].range_of_motion_score
-    last = items[-1].range_of_motion_score
-    return round(last - first, 4)
-
-
-def run(
-    exercise: ExerciseStrategy,
-    reps: Reps,
-    sequence: PoseSequence,
-) -> RepAnalysis:
-    draft_items: list[tuple[Rep, dict[str, Any], float, float, float, list[str]]] = []
-    for rep in reps.reps:
-        frames = _frames_for_rep(sequence, rep)
-        primary_signal = _primary_signal(exercise.exercise, frames)
-        common_metrics = _common_metrics(rep, frames, primary_signal)
-        exercise_metrics, rom_score, stability_score, symmetry_score, hints = exercise.metrics(frames)
-        metrics = {**common_metrics, **exercise_metrics}
-        draft_items.append((rep, metrics, rom_score, stability_score, symmetry_score, hints))
-
-    average_duration = (
-        mean(item[1]["rep_duration_sec"] for item in draft_items)
-        if draft_items
-        else 0.0
-    )
-    items: list[RepAnalysisItem] = []
-    for rep, metrics, rom_score, stability_score, symmetry_score, hints in draft_items:
-        duration = metrics["rep_duration_sec"]
-        metrics["tempo_consistency_score"] = (
-            score(1.0 - abs(duration - average_duration) / max(average_duration, 0.1))
-            if average_duration
-            else 0.0
-        )
-        items.append(
-            RepAnalysisItem(
-                rep_id=rep.rep_id,
-                duration_sec=duration,
-                range_of_motion_score=rom_score,
-                stability_score=stability_score,
-                symmetry_score=symmetry_score,
-                metrics=metrics,
-                variation_hints=sorted(set(hints)),
-            )
-        )
-
-    aggregate_metrics = {
-        "avg_rom_score": (
-            round(mean(item.range_of_motion_score for item in items), 2) if items else 0.0
-        ),
-        "avg_stability_score": (
-            round(mean(item.stability_score for item in items), 2) if items else 0.0
-        ),
-        "avg_symmetry_score": (
-            round(mean(item.symmetry_score for item in items), 2) if items else 0.0
-        ),
-        "avg_rep_duration_sec": (
-            round(mean(item.duration_sec for item in items), 2) if items else 0.0
-        ),
-        "avg_tempo_consistency_score": _aggregate_numeric(items, "tempo_consistency_score") or 0.0,
-        "avg_landmark_confidence": (
-            _aggregate_numeric(items, "landmark_confidence") or sequence.pose_valid_ratio
-        ),
-        "fatigue_trend_rom_delta": _fatigue_trend(items),
-        "pose_valid_ratio": sequence.pose_valid_ratio,
-    }
-
-    for metric_name in (
-        "hand_width_ratio",
-        "stance_width_ratio",
-        "bottom_pause_sec",
-        "lockout_quality",
-        "wrist_height_asymmetry",
-        "wrist_travel",
-        "knee_support_score",
-    ):
-        aggregate_value = _aggregate_numeric(items, metric_name)
-        if aggregate_value is not None:
-            aggregate_metrics[f"avg_{metric_name}"] = aggregate_value
-
-    return RepAnalysis(
-        exercise=exercise.exercise,
-        items=items,
-        aggregate_metrics=aggregate_metrics,
-    )

src/pozify/steps/rep_counter.py

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from pozify.contracts import PoseSequence, Reps
-from pozify.exercises import ExerciseStrategy
-
-
-def run(exercise: ExerciseStrategy, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
-    return exercise.count(sequence)

src/pozify/steps/rep_counters/__init__.py

@@ -1,3 +0,0 @@
-from pozify.steps.rep_counters.base import ExerciseRepCounter
-
-__all__ = ["ExerciseRepCounter"]

src/pozify/steps/variation_detector.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from pozify.contracts import RepAnalysis, UserProfile, Variation
-from pozify.exercises import ExerciseStrategy
-
-
-def run(
-    exercise: ExerciseStrategy,
-    analysis: RepAnalysis,
-    profile: UserProfile,
-) -> Variation:
-    if profile.intended_variation:
-        variation = profile.intended_variation
-        confidence = 0.95
-        not_issues = exercise.profile_not_issues(variation)
-    else:
-        variation, confidence, not_issues = exercise.detect_variation(analysis)
-
-    if analysis.aggregate_metrics.get("avg_rom_score", 1.0) < 0.7:
-        not_issues.append("low_rom_requires_user_intent_check")
-    if analysis.aggregate_metrics.get("pose_valid_ratio", 1.0) < 0.8:
-        not_issues.append("low_pose_confidence_limits_variation_call")
-
-    return Variation(
-        exercise=exercise.exercise,
-        detected_variation=variation,
-        variation_confidence=confidence,
-        not_issues=sorted(set(not_issues)),
-    )

tests/test_issue_marker.py

@@ -9,14 +9,15 @@ import unittest
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
 from pozify.contracts import (
+    IssueMarkers,
     PoseFrame,
     PoseSequence,
     Rep,
     Reps,
     UserProfile,
+    VideoManifest,
 )
 from pozify.exercises import create_exercise_strategy
-from pozify.steps import issue_marker, rep_analysis, variation_detector
 
 
 def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
@@ -52,6 +53,24 @@ def _profile(exercise: str = "auto") -> UserProfile:
     )
 
 
+def _video_manifest(sequence: PoseSequence) -> VideoManifest:
+    return VideoManifest(
+        video_path=None,
+        fps=30.0,
+        duration_sec=round(len(sequence.frames) / 30.0, 3),
+        total_frames=len(sequence.frames),
+        sampled_frames=len(sequence.frames),
+        width=720,
+        height=1280,
+        codec=None,
+        container=None,
+        brightness_mean=None,
+        blur_laplacian_var=None,
+        quality_warnings=[],
+        analysis_allowed=True,
+    )
+
+
 def _sequence(factory: Callable[[int, float], dict[str, dict[str, float]]], count: int = 30) -> PoseSequence:
     return PoseSequence(
         frames=[_frame(frame_index, factory(frame_index, _wave(frame_index, count))) for frame_index in range(count)],
@@ -122,12 +141,17 @@ def _shoulder_press_landmarks(frame_index: int, lift: float) -> dict[str, dict[s
     }
 
 
-def _run_markers(exercise: str, sequence: PoseSequence):
-    exercise_strategy = create_exercise_strategy(exercise)
+def _run_markers(exercise: str, sequence: PoseSequence) -> IssueMarkers:
+    exercise_strategy = create_exercise_strategy(
+        exercise,
+        video_manifest=_video_manifest(sequence),
+        pose_sequence=sequence,
+        profile=_profile(exercise),
+    )
     reps = _reps(exercise, len(sequence.frames) - 1)
-    analysis = rep_analysis.run(exercise_strategy, reps, sequence)
-    variation = variation_detector.run(exercise_strategy, analysis, _profile(exercise))
-    return issue_marker.run(exercise_strategy, reps, analysis, variation, sequence)
+    analysis = exercise_strategy.analyze_reps(reps)
+    variation = exercise_strategy.resolve_variation(analysis)
+    return exercise_strategy.mark_issues(reps, analysis, variation)
 
 
 class IssueMarkerTests(unittest.TestCase):

tests/test_pipeline_contracts.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import json
+import os
 import sys
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch
 
 import cv2
 import numpy as np
@@ -227,6 +229,11 @@ class PipelineContractTests(unittest.TestCase):
                 report = result["final_report"]
                 self.assertEqual(report["exercise"]["exercise"], exercise)
 
+    def test_mock_mode_defaults_to_real_when_video_path_is_present(self) -> None:
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertFalse(pipeline._env_mock_mode("sample.mp4"))
+            self.assertTrue(pipeline._env_mock_mode(None))
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_rep_analysis_variation.py

@@ -14,9 +14,9 @@ from pozify.contracts import (
     Rep,
     Reps,
     UserProfile,
+    VideoManifest,
 )
 from pozify.exercises import create_exercise_strategy
-from pozify.steps import rep_analysis, variation_detector
 
 
 def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
@@ -189,15 +189,39 @@ def _profile() -> UserProfile:
     )
 
 
+def _video_manifest(sequence: PoseSequence) -> VideoManifest:
+    return VideoManifest(
+        video_path=None,
+        fps=30.0,
+        duration_sec=round(len(sequence.frames) / 30.0, 3),
+        total_frames=len(sequence.frames),
+        sampled_frames=len(sequence.frames),
+        width=720,
+        height=1280,
+        codec=None,
+        container=None,
+        brightness_mean=None,
+        blur_laplacian_var=None,
+        quality_warnings=[],
+        analysis_allowed=True,
+    )
+
+
+def _exercise_strategy(exercise: str, sequence: PoseSequence, profile: UserProfile | None = None):
+    return create_exercise_strategy(
+        exercise,
+        video_manifest=_video_manifest(sequence),
+        pose_sequence=sequence,
+        profile=profile or _profile(),
+    )
+
+
 class RepAnalysisVariationTests(unittest.TestCase):
     def test_push_up_metrics_detect_wide_grip_variation(self) -> None:
-        exercise = create_exercise_strategy("push_up")
-        analysis = rep_analysis.run(
-            exercise,
-            _reps("push_up"),
-            _sequence("push_up"),
-        )
-        variation = variation_detector.run(exercise, analysis, _profile())
+        sequence = _sequence("push_up")
+        exercise = _exercise_strategy("push_up", sequence)
+        analysis = exercise.analyze_reps(_reps("push_up"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertEqual(variation.detected_variation, "wide_grip_push_up")
         self.assertIn("wide_hand_placement", variation.not_issues)
@@ -205,35 +229,30 @@ class RepAnalysisVariationTests(unittest.TestCase):
         self.assertIn("body_line_score", analysis.items[0].metrics)
 
     def test_push_up_metrics_detect_knee_push_up_variation(self) -> None:
-        exercise = create_exercise_strategy("push_up")
-        analysis = rep_analysis.run(
-            exercise,
-            _reps("push_up"),
-            _custom_sequence(_knee_push_up_landmarks),
-        )
-        variation = variation_detector.run(exercise, analysis, _profile())
+        sequence = _custom_sequence(_knee_push_up_landmarks)
+        exercise = _exercise_strategy("push_up", sequence)
+        analysis = exercise.analyze_reps(_reps("push_up"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertEqual(variation.detected_variation, "knee_push_up")
         self.assertIn("knee_contact", variation.not_issues)
         self.assertGreaterEqual(analysis.aggregate_metrics["avg_knee_support_score"], 0.8)
 
     def test_straight_leg_push_up_does_not_false_positive_as_knee_push_up(self) -> None:
-        exercise = create_exercise_strategy("push_up")
-        analysis = rep_analysis.run(
-            exercise,
-            _reps("push_up"),
-            _custom_sequence(_straight_leg_push_up_landmarks),
-        )
-        variation = variation_detector.run(exercise, analysis, _profile())
+        sequence = _custom_sequence(_straight_leg_push_up_landmarks)
+        exercise = _exercise_strategy("push_up", sequence)
+        analysis = exercise.analyze_reps(_reps("push_up"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertNotEqual(variation.detected_variation, "knee_push_up")
         self.assertNotIn("knee_contact", variation.not_issues)
         self.assertLess(analysis.aggregate_metrics["avg_knee_support_score"], 0.8)
 
     def test_squat_metrics_detect_wide_stance_variation(self) -> None:
-        exercise = create_exercise_strategy("squat")
-        analysis = rep_analysis.run(exercise, _reps("squat"), _sequence("squat"))
-        variation = variation_detector.run(exercise, analysis, _profile())
+        sequence = _sequence("squat")
+        exercise = _exercise_strategy("squat", sequence)
+        analysis = exercise.analyze_reps(_reps("squat"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertEqual(variation.detected_variation, "wide_squat_stance")
         self.assertIn("wide_stance", variation.not_issues)
@@ -241,13 +260,10 @@ class RepAnalysisVariationTests(unittest.TestCase):
         self.assertIn("min_knee_angle_deg", analysis.items[0].metrics)
 
     def test_shoulder_press_metrics_detect_partial_press_variation(self) -> None:
-        exercise = create_exercise_strategy("shoulder_press")
-        analysis = rep_analysis.run(
-            exercise,
-            _reps("shoulder_press"),
-            _sequence("shoulder_press"),
-        )
-        variation = variation_detector.run(exercise, analysis, _profile())
+        sequence = _sequence("shoulder_press")
+        exercise = _exercise_strategy("shoulder_press", sequence)
+        analysis = exercise.analyze_reps(_reps("shoulder_press"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertEqual(variation.detected_variation, "partial_press")
         self.assertIn("partial_range_of_motion", variation.not_issues)
@@ -263,13 +279,10 @@ class RepAnalysisVariationTests(unittest.TestCase):
             known_limitations=[],
             equipment="bodyweight",
         )
-        exercise = create_exercise_strategy("push_up")
-        analysis = rep_analysis.run(
-            exercise,
-            _reps("push_up"),
-            _sequence("push_up"),
-        )
-        variation = variation_detector.run(exercise, analysis, profile)
+        sequence = _sequence("push_up")
+        exercise = _exercise_strategy("push_up", sequence, profile)
+        analysis = exercise.analyze_reps(_reps("push_up"))
+        variation = exercise.resolve_variation(analysis)
 
         self.assertEqual(variation.detected_variation, "close_grip_push_up")
         self.assertEqual(variation.variation_confidence, 0.95)

tests/test_rep_counter.py

@@ -7,12 +7,11 @@ import unittest
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
 
-from pozify.contracts import PoseFrame, PoseSequence
+from pozify.contracts import PoseFrame, PoseSequence, UserProfile, VideoManifest
 from pozify.exercises import create_exercise_strategy
 from pozify.exercises.push_up import PushUpExercise
 from pozify.exercises.shoulder_press import ShoulderPressExercise
 from pozify.exercises.squat import SquatExercise
-from pozify.steps import rep_counter
 
 
 def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
@@ -107,52 +106,84 @@ def _sequence_for_exercise(exercise: str, cycles: int, *, partial_tail: bool = F
     )
 
 
+def _video_manifest(sequence: PoseSequence) -> VideoManifest:
+    return VideoManifest(
+        video_path=None,
+        fps=30.0,
+        duration_sec=round(len(sequence.frames) / 30.0, 3),
+        total_frames=len(sequence.frames),
+        sampled_frames=len(sequence.frames),
+        width=720,
+        height=1280,
+        codec=None,
+        container=None,
+        brightness_mean=None,
+        blur_laplacian_var=None,
+        quality_warnings=[],
+        analysis_allowed=True,
+    )
+
+
+def _profile(exercise: str = "auto") -> UserProfile:
+    return UserProfile(
+        goal="beginner_practice",
+        experience_level="beginner",
+        intended_exercise=exercise,
+        intended_variation=None,
+        known_limitations=[],
+        equipment="bodyweight",
+    )
+
+
+def _exercise_strategy(exercise: str, sequence: PoseSequence):
+    return create_exercise_strategy(
+        exercise,
+        video_manifest=_video_manifest(sequence),
+        pose_sequence=sequence,
+        profile=_profile(exercise),
+    )
+
+
 class RepCounterTests(unittest.TestCase):
     def test_segments_squat_reps(self) -> None:
-        reps, debug = rep_counter.run(create_exercise_strategy("squat"), _sequence_for_exercise("squat", 3))
+        sequence = _sequence_for_exercise("squat", 3)
+        reps, debug = _exercise_strategy("squat", sequence).count()
         self.assertEqual(len(reps.reps), 3)
         self.assertEqual(reps.reps[0].start_frame, 0)
         self.assertTrue(debug["accepted_reps"])
 
     def test_segments_push_up_reps(self) -> None:
-        reps, _debug = rep_counter.run(
-            create_exercise_strategy("push_up"),
-            _sequence_for_exercise("push_up", 3),
-        )
+        sequence = _sequence_for_exercise("push_up", 3)
+        reps, _debug = _exercise_strategy("push_up", sequence).count()
         self.assertEqual(len(reps.reps), 3)
         self.assertEqual(reps.partial_reps, [])
 
     def test_segments_shoulder_press_reps(self) -> None:
-        reps, _debug = rep_counter.run(
-            create_exercise_strategy("shoulder_press"),
-            _sequence_for_exercise("shoulder_press", 3),
-        )
+        sequence = _sequence_for_exercise("shoulder_press", 3)
+        reps, _debug = _exercise_strategy("shoulder_press", sequence).count()
         self.assertEqual(len(reps.reps), 3)
         self.assertEqual(reps.reps[0].mid_frame, 12)
 
     def test_reports_partial_last_rep(self) -> None:
-        reps, _debug = rep_counter.run(
-            create_exercise_strategy("push_up"),
-            _sequence_for_exercise("push_up", 2, partial_tail=True),
-        )
+        sequence = _sequence_for_exercise("push_up", 2, partial_tail=True)
+        reps, _debug = _exercise_strategy("push_up", sequence).count()
         self.assertEqual(len(reps.reps), 2)
         self.assertIn("ends_mid_rep", {item["reason"] for item in reps.partial_reps})
 
     def test_unknown_exercise_is_not_segmented(self) -> None:
-        reps, debug = rep_counter.run(
-            create_exercise_strategy("unknown"),
-            _sequence_for_exercise("push_up", 1),
-        )
+        sequence = _sequence_for_exercise("push_up", 1)
+        reps, debug = _exercise_strategy("unknown", sequence).count()
         self.assertEqual(reps.reps, [])
         self.assertEqual(reps.partial_reps, [{"reason": "unknown_exercise"}])
         self.assertEqual(debug["selected_signal"], "none")
 
     def test_exercises_resolve_to_specific_strategies(self) -> None:
-        push_up = create_exercise_strategy("push_up")
+        sequence = _sequence_for_exercise("push_up", 1)
+        push_up = _exercise_strategy("push_up", sequence)
         self.assertIsInstance(push_up, PushUpExercise)
-        self.assertIsInstance(create_exercise_strategy("shoulder_press"), ShoulderPressExercise)
-        self.assertIsInstance(create_exercise_strategy("squat"), SquatExercise)
-        self.assertIsNot(push_up, create_exercise_strategy("push_up"))
+        self.assertIsInstance(_exercise_strategy("shoulder_press", sequence), ShoulderPressExercise)
+        self.assertIsInstance(_exercise_strategy("squat", sequence), SquatExercise)
+        self.assertIsNot(push_up, _exercise_strategy("push_up", sequence))
 
 
 if __name__ == "__main__":