Merge remote issue 4 updates

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,6 +92,10 @@ user profile + input video
 -> final report
 ```
 
+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
 
 ```text
@@ -100,15 +104,28 @@ src/pozify/
   contracts.py
   pipeline.py
   artifacts.py
+  exercises/
+    push_up/
+      strategy.py
+      analyzer.py
+      issue_markers.py
+    squat/
+      strategy.py
+      analyzer.py
+      issue_markers.py
+    shoulder_press/
+      strategy.py
+      analyzer.py
+      issue_markers.py
+    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
@@ -168,28 +185,34 @@ Each step lives in `src/pozify/steps/` and exposes a `run(...)` function.
 
 ## Adding Exercises
 
-Supported exercise metadata is centralized in `src/pozify/exercise_catalog.py`. To add a new mocked
+Supported exercise metadata is centralized in `src/pozify/exercise_catalog.py`. To add a new
 exercise, add one `ExerciseSpec` with:
 
 - `key` and `display_name`
 - `default_variation` and confidence
-- `metric_factory` for mock per-rep metrics
+- `metric_factory` for legacy/mock fallback metadata
 - optional `variation_hints`, default `not_issues`, and `mock_issue`
 
 The Gradio dropdown, profile validation, variation detector, rep analysis, and issue marker read from
 this catalog, so new exercises do not require changing each step just to become selectable. Real
-exercise-specific algorithms can still replace individual step implementations later while preserving
-the same pipeline contracts.
+exercise-specific code lives under `src/pozify/exercises/<exercise>/`:
+
+- `strategy.py`: rep-counting signal, variation logic, and exercise strategy wiring
+- `analyzer.py`: per-rep metrics
+- `issue_markers.py`: frame-level issue rules
+
+Shared analyzer and issue marker primitives live under `src/pozify/exercises/shared/`.
 
 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. `rep_analysis.py` and `issue_marker.py`: compute real metrics and issue scores.
-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.
 
 ## Exercise Router Training
 
@@ -253,12 +276,12 @@ classes from the Riccio dataset, such as bicep curl, are mapped to `unknown`.
 
 ```bash
 uv run python -m unittest discover -s tests
-python3 -m py_compile app.py src/pozify/*.py src/pozify/steps/*.py src/pozify/ml/*.py scripts/*.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
 

app.py

@@ -27,141 +27,6 @@ APP_DESCRIPTION = (
 )
 
 
-QUALITY_GUIDANCE = {
-    "too_short": "Record at least 10 seconds so the set contains enough movement context.",
-    "too_long": "Keep the clip under 60 seconds for the MVP analyzer.",
-    "too_dark": "Use brighter, even lighting and keep the body visible against the background.",
-    "too_blurry": "Stabilize the camera and avoid fast panning or heavy motion blur.",
-    "fps_too_low": "Use a camera mode with at least 15 FPS.",
-    "resolution_too_low": "Record at 480x360 or higher so joint positions are readable.",
-    "video_decode_failed": "Upload a playable video file; the current file could not be decoded.",
-}
-
-
-def _pretty_json(value: dict[str, Any]) -> str:
-    return json.dumps(value, ensure_ascii=False, indent=2)
-
-
-def _quality_markdown(video_manifest: dict[str, Any]) -> str:
-    warnings = video_manifest["quality_warnings"]
-    if not warnings:
-        return "## Video Quality\n\nNo quality warnings detected."
-
-    warning_items = "\n".join(f"- `{warning}`: {QUALITY_GUIDANCE[warning]}" for warning in warnings)
-    status = (
-        "Analysis is blocked until the video can be decoded reliably."
-        if not video_manifest["analysis_allowed"]
-        else "Analysis completed, but capture quality may affect downstream feedback."
-    )
-    return f"""## Capture Quality
-
-{status}
-
-{warning_items}
-"""
-
-
-def _mock_status_markdown(report: dict[str, Any]) -> str:
-    mock_steps = report["artifacts"].get("mock_steps", [])
-    if not mock_steps:
-        return ""
-    steps = ", ".join(f"`{step}`" for step in mock_steps)
-    return (
-        "## Pipeline Status\n\n"
-        "The current run uses real video QC, pose extraction, rep segmentation, and annotated video rendering, "
-        f"but these steps still use placeholders: {steps}."
-    )
-
-
-def analyze_video(
-    video_path: str | None,
-    goal: str,
-    experience_level: str,
-    intended_exercise: str,
-    intended_variation: str,
-    limitations: list[str],
-    equipment: str,
-) -> tuple[str | None, str, str, str]:
-    result = run_pipeline(
-        video_path=video_path,
-        profile_input={
-            "goal": goal,
-            "experience_level": experience_level,
-            "intended_exercise": intended_exercise,
-            "intended_variation": intended_variation or None,
-            "known_limitations": limitations,
-            "equipment": equipment,
-        },
-    )
-
-    report = result["final_report"]
-    video_quality = _quality_markdown(report["video_manifest"])
-    mock_status = _mock_status_markdown(report)
-    summary = report["coach_summary"]
-    if not report["video_manifest"]["analysis_allowed"]:
-        markdown = f"""{video_quality}
-
-{mock_status}
-
-## Run
-
-- **Run ID:** `{report["run_id"]}`
-- **Saved report:** `{Path(result["run_dir"]) / "final_report.json"}`
-"""
-        artifact_path = Path(result["run_dir"]) / "final_report.json"
-        return (
-            result["annotated_video_path"],
-            markdown,
-            _pretty_json(report),
-            str(artifact_path),
-        )
-
-    fallback_note = (
-        "\nRouter confidence is low or window predictions disagree. Select the exercise manually and rerun.\n"
-        if report["exercise"]["fallback_required"]
-        else ""
-    )
-    markdown = f"""## Scan Summary
-
-| Signal | Result |
-| --- | --- |
-| Exercise router | {report["exercise"]["exercise"]} ({report["exercise"]["confidence"]:.0%}) |
-| Router fallback required | {report["exercise"]["fallback_required"]} |
-| Variation | {report["variation"]["detected_variation"]} ({report["variation"]["variation_confidence"]:.0%}) |
-| Reps | {len(report["reps"]["reps"])} |
-| Analysis mode | {report["artifacts"].get("analysis_mode", "unknown")} |
-| Pose source | {report["artifacts"].get("pose_source", "unknown")} |
-| Primary finding | {summary["main_findings"][0] if summary["main_findings"] else "No finding emitted"} |
-| Run ID | `{report["run_id"]}` |
-{fallback_note}
-
-{mock_status}
-
-## Coach Notes
-
-{summary["summary"]}
-
-### What Went Well
-{chr(10).join(f"- {item}" for item in summary["what_went_well"])}
-
-### Top Fixes
-{chr(10).join(f"- {item}" for item in summary["top_fixes"])}
-
-### Next Session Plan
-{chr(10).join(f"- {item}" for item in summary["next_session_plan"])}
-
-{video_quality}
-"""
-
-    artifact_path = Path(result["run_dir"]) / "final_report.json"
-    return (
-        result["annotated_video_path"],
-        markdown,
-        _pretty_json(report),
-        str(artifact_path),
-    )
-
-
 server = gr.Server(
     title="Pozify",
     summary="Video-based workout form review API",
@@ -184,7 +49,13 @@ def index() -> FileResponse:
 def config() -> dict[str, Any]:
     return {
         "description": APP_DESCRIPTION,
-        "goals": ["strength", "hypertrophy", "endurance", "mobility", "beginner_practice"],
+        "goals": [
+            "strength",
+            "hypertrophy",
+            "endurance",
+            "mobility",
+            "beginner_practice",
+        ],
         "experience_levels": ["beginner", "intermediate"],
         "exercises": ["auto", *USER_SELECTABLE_EXERCISES],
         "limitations": ["wrist_discomfort", "knee_discomfort", "shoulder_discomfort"],
@@ -225,12 +96,16 @@ async def analyze_api(
     try:
         parsed_limitations = json.loads(limitations)
     except json.JSONDecodeError as exc:
-        raise HTTPException(status_code=400, detail="Limitations must be valid JSON.") from exc
+        raise HTTPException(
+            status_code=400, detail="Limitations must be valid JSON."
+        ) from exc
 
     if not isinstance(parsed_limitations, list) or not all(
         isinstance(item, str) for item in parsed_limitations
     ):
-        raise HTTPException(status_code=400, detail="Limitations must be a JSON list of strings.")
+        raise HTTPException(
+            status_code=400, detail="Limitations must be a JSON list of strings."
+        )
 
     video_path: str | None = None
     if video is not None and video.filename:
@@ -258,7 +133,9 @@ async def analyze_api(
     return {
         "run_id": result["run_id"],
         "run_dir": result["run_dir"],
-        "annotated_video_url": _artifact_url(result["run_id"], result["annotated_video_path"]),
+        "annotated_video_url": _artifact_url(
+            result["run_id"], result["annotated_video_path"]
+        ),
         "final_report_url": f"/api/artifacts/{result['run_id']}/final_report.json",
         "report": result["final_report"],
     }

src/pozify/exercises/__init__.py

@@ -0,0 +1,4 @@
+from pozify.exercises.base import ExerciseStrategy
+from pozify.exercises.registry import create_exercise_strategy
+
+__all__ = ["ExerciseStrategy", "create_exercise_strategy"]

src/pozify/exercises/base.py

@@ -0,0 +1,410 @@
+from __future__ import annotations
+
+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
+
+    def detect_variation(self, analysis: RepAnalysis) -> tuple[str, float, list[str]]:
+        raise NotImplementedError
+
+    def profile_not_issues(self, variation: str) -> list[str]:
+        return []
+
+    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)):
+            return float(value)
+        return None
+
+    def confidence(
+        self,
+        base: float,
+        analysis: RepAnalysis,
+        supporting_metric: float | None,
+    ) -> float:
+        rep_bonus = min(0.12, len(analysis.items) * 0.03)
+        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/__init__.py

@@ -0,0 +1,5 @@
+from pozify.exercises.push_up.analyzer import PushUpAnalyzer
+from pozify.exercises.push_up.issue_markers import RULES as ISSUE_RULES
+from pozify.exercises.push_up.strategy import PushUpExercise
+
+__all__ = ["ISSUE_RULES", "PushUpAnalyzer", "PushUpExercise"]

src/pozify/exercises/push_up/analyzer.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import (
+    ExerciseMetricResult,
+    max_optional,
+    mean_optional,
+    mean_pair,
+    min_optional,
+    range_optional,
+    round_optional,
+    safe_ratio,
+    score,
+    side_delta,
+    std_optional,
+    value_series,
+    width,
+)
+from pozify.steps.rep_signals import average_axis, body_line_score
+
+
+class PushUpAnalyzer:
+    def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
+        elbow_angles = value_series(
+            frames,
+            lambda frame: mean_pair(
+                frame,
+                ("left_shoulder", "left_elbow", "left_wrist"),
+                ("right_shoulder", "right_elbow", "right_wrist"),
+            ),
+        )
+        elbow_deltas = value_series(
+            frames,
+            lambda frame: side_delta(
+                frame,
+                ("left_shoulder", "left_elbow", "left_wrist"),
+                ("right_shoulder", "right_elbow", "right_wrist"),
+            ),
+        )
+        body_line = value_series(frames, body_line_score)
+        shoulder_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_shoulder", "right_shoulder"), "y"),
+        )
+        hip_y = value_series(frames, lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"))
+        ankle_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_ankle", "right_ankle"), "y"),
+        )
+        hand_width = value_series(frames, lambda frame: width(frame, "left_wrist", "right_wrist"))
+        shoulder_width = value_series(
+            frames,
+            lambda frame: width(frame, "left_shoulder", "right_shoulder"),
+        )
+        elbow_width = value_series(frames, lambda frame: width(frame, "left_elbow", "right_elbow"))
+        knee_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_knee", "right_knee"), "y"),
+        )
+
+        min_elbow = min_optional(elbow_angles)
+        max_elbow = max_optional(elbow_angles)
+        elbow_rom = 0.0 if min_elbow is None or max_elbow is None else max_elbow - min_elbow
+        chest_depth = range_optional(shoulder_y) or 0.0
+        hand_width_ratio = safe_ratio(mean_optional(hand_width), mean_optional(shoulder_width))
+        elbow_flare = safe_ratio(mean_optional(elbow_width), mean_optional(shoulder_width))
+        body_line_mean = mean_optional(body_line)
+        hip_sag_score = None
+        if body_line_mean is not None:
+            hip_sag_score = max(0.0, 1.0 - body_line_mean)
+        knee_support_score = self._knee_support_score(hip_y, knee_y, ankle_y)
+
+        rom_score = score((elbow_rom / 80.0) * 0.65 + (chest_depth / 0.16) * 0.35)
+        hip_stability = 1.0 - min(1.0, (std_optional(hip_y) or 0.0) * 4.0)
+        stability_score = score(((body_line_mean or 0.5) * 0.75) + hip_stability * 0.25)
+        symmetry_score = score(1.0 - ((mean_optional(elbow_deltas) or 0.0) / 45.0))
+
+        metrics = {
+            "min_elbow_angle_deg": round_optional(min_elbow),
+            "max_elbow_angle_deg": round_optional(max_elbow),
+            "body_line_score": round_optional(body_line_mean),
+            "hip_sag_score": round_optional(hip_sag_score),
+            "hip_pike_score": round_optional(max(0.0, ((body_line_mean or 1.0) - 1.0) * -1.0), 4),
+            "chest_depth_proxy": round_optional(chest_depth, 4),
+            "hand_width_ratio": round_optional(hand_width_ratio, 3),
+            "elbow_flare_ratio": round_optional(elbow_flare, 3),
+            "lockout_quality": score(((max_elbow or 120.0) - 120.0) / 55.0),
+            "knee_support_score": knee_support_score,
+        }
+        hints = []
+        if hand_width_ratio is not None and hand_width_ratio > 1.45:
+            hints.append("wide_grip_push_up")
+        elif hand_width_ratio is not None and hand_width_ratio < 0.95:
+            hints.append("close_grip_push_up")
+        if knee_support_score >= 0.8:
+            hints.append("knee_push_up")
+        return metrics, rom_score, stability_score, symmetry_score, hints
+
+    def _knee_support_score(
+        self,
+        hip_y: list[float | None],
+        knee_y: list[float | None],
+        ankle_y: list[float | None],
+    ) -> float:
+        scores: list[float] = []
+        for hip, knee, ankle in zip(hip_y, knee_y, ankle_y, strict=False):
+            if hip is None or knee is None or ankle is None:
+                continue
+
+            hip_to_ankle = abs(ankle - hip)
+            if hip_to_ankle <= 1e-6:
+                continue
+            knee_to_hip = abs(knee - hip)
+            bent_leg_score = score(1.0 - knee_to_hip / max(hip_to_ankle * 0.55, 0.01))
+            scores.append(bent_leg_score)
+
+        return score(mean_optional(scores) or 0.0)

src/pozify/exercises/push_up/issue_markers.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import mean_optional
+from pozify.exercises.shared.issue_marker import IssueRule
+from pozify.steps.rep_signals import angle_deg, body_line_score
+
+
+def _elbow_angle(frame: PoseFrame) -> float | None:
+    return mean_optional(
+        [
+            angle_deg(frame, "left_shoulder", "left_elbow", "left_wrist"),
+            angle_deg(frame, "right_shoulder", "right_elbow", "right_wrist"),
+        ]
+    )
+
+
+RULES: tuple[IssueRule, ...] = (
+    IssueRule(
+        issue="hip_sag",
+        metric_name="body_line_score",
+        threshold=0.65,
+        comparison="lt",
+        affected_joints=(
+            "left_hip",
+            "right_hip",
+            "left_shoulder",
+            "right_shoulder",
+            "left_ankle",
+            "right_ankle",
+        ),
+        getter=body_line_score,
+    ),
+    IssueRule(
+        issue="incomplete_depth",
+        metric_name="elbow_angle_deg",
+        threshold=115.0,
+        comparison="gt",
+        affected_joints=(
+            "left_shoulder",
+            "right_shoulder",
+            "left_elbow",
+            "right_elbow",
+            "left_wrist",
+            "right_wrist",
+        ),
+        getter=_elbow_angle,
+        phase="bottom",
+    ),
+)

src/pozify/{steps/rep_counters/push_up.py → exercises/push_up/strategy.py}

@@ -2,15 +2,23 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence
-from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+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.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
-class PushUpRepCounter(ExerciseRepCounter):
+class PushUpExercise(PushUpAnalyzer, ExerciseStrategy):
     exercise = "push_up"
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def issue_rules(self) -> tuple[IssueRule, ...]:
+        return ISSUE_RULES
+
+    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 = [
@@ -38,3 +46,30 @@ class PushUpRepCounter(ExerciseRepCounter):
             "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
         }
 
+    def detect_variation(self, analysis: RepAnalysis) -> tuple[str, float, list[str]]:
+        hand_width = self.metric(analysis, "avg_hand_width_ratio")
+        knee_support = self.metric(analysis, "avg_knee_support_score")
+        not_issues: list[str] = []
+
+        if knee_support is not None and knee_support >= 0.8:
+            return "knee_push_up", self.confidence(0.74, analysis, knee_support), ["knee_contact"]
+        if hand_width is not None and hand_width >= 1.45:
+            return "wide_grip_push_up", self.confidence(0.72, analysis, hand_width), ["wide_hand_placement"]
+        if hand_width is not None and hand_width <= 0.95:
+            return (
+                "close_grip_push_up",
+                self.confidence(0.72, analysis, 1.0 - hand_width),
+                ["close_hand_placement"],
+            )
+
+        if hand_width is None:
+            not_issues.append("hand_width_unverified")
+        return "standard_push_up", self.confidence(0.62, analysis, hand_width), not_issues
+
+    def profile_not_issues(self, variation: str) -> list[str]:
+        mapping = {
+            "wide_grip_push_up": ["wide_hand_placement"],
+            "close_grip_push_up": ["close_hand_placement"],
+            "knee_push_up": ["knee_contact"],
+        }
+        return list(mapping.get(variation, []))

src/pozify/exercises/registry.py

@@ -0,0 +1,31 @@
+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
+from pozify.exercises.squat import SquatExercise
+from pozify.exercises.unknown import UnknownExercise
+
+
+EXERCISE_CLASSES: dict[str, type[ExerciseStrategy]] = {
+    "push_up": PushUpExercise,
+    "shoulder_press": ShoulderPressExercise,
+    "squat": SquatExercise,
+    "unknown": UnknownExercise,
+}
+
+
+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(
+        video_manifest=video_manifest,
+        pose_sequence=pose_sequence,
+        profile=profile,
+    )

src/pozify/exercises/shared/__init__.py

@@ -0,0 +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", "ExerciseRepCounter", "IssueRule"]

src/pozify/exercises/shared/analyzer.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from statistics import pstdev
+from typing import Any, Callable, Protocol
+
+from pozify.contracts import PoseFrame
+from pozify.steps.rep_signals import angle_deg, average_axis, landmark_axis
+
+
+NumberGetter = Callable[[PoseFrame], float | None]
+ExerciseMetricResult = tuple[dict[str, Any], float, float, float, list[str]]
+
+
+class ExerciseAnalyzer(Protocol):
+    def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
+        ...
+
+
+def round_optional(value: float | None, digits: int = 2) -> float | None:
+    if value is None:
+        return None
+    return round(value, digits)
+
+
+def score(value: float) -> float:
+    return round(min(1.0, max(0.0, value)), 2)
+
+
+def usable(values: list[float | None]) -> list[float]:
+    return [value for value in values if value is not None]
+
+
+def mean_optional(values: list[float | None]) -> float | None:
+    usable_values = usable(values)
+    if not usable_values:
+        return None
+    return sum(usable_values) / len(usable_values)
+
+
+def min_optional(values: list[float | None]) -> float | None:
+    usable_values = usable(values)
+    return min(usable_values) if usable_values else None
+
+
+def max_optional(values: list[float | None]) -> float | None:
+    usable_values = usable(values)
+    return max(usable_values) if usable_values else None
+
+
+def range_optional(values: list[float | None]) -> float | None:
+    usable_values = usable(values)
+    if not usable_values:
+        return None
+    return max(usable_values) - min(usable_values)
+
+
+def std_optional(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 safe_ratio(numerator: float | None, denominator: float | None) -> float | None:
+    if numerator is None or denominator is None or abs(denominator) <= 1e-6:
+        return None
+    return numerator / denominator
+
+
+def width(frame: PoseFrame, left: str, right: str) -> float | None:
+    left_x = landmark_axis(frame, left, "x")
+    right_x = landmark_axis(frame, right, "x")
+    if left_x is None or right_x is None:
+        return None
+    return abs(right_x - left_x)
+
+
+def mean_pair(
+    frame: PoseFrame,
+    first: tuple[str, str, str],
+    second: tuple[str, str, str],
+) -> float | None:
+    values = [angle_deg(frame, *first), angle_deg(frame, *second)]
+    return mean_optional(values)
+
+
+def side_delta(
+    frame: PoseFrame,
+    first: tuple[str, str, str],
+    second: tuple[str, str, str],
+) -> float | None:
+    first_value = angle_deg(frame, *first)
+    second_value = angle_deg(frame, *second)
+    if first_value is None or second_value is None:
+        return None
+    return abs(first_value - second_value)
+
+
+def torso_lean_deg(frame: PoseFrame, side: str) -> float | None:
+    shoulder_x = landmark_axis(frame, f"{side}_shoulder", "x")
+    shoulder_y = landmark_axis(frame, f"{side}_shoulder", "y")
+    hip_x = landmark_axis(frame, f"{side}_hip", "x")
+    hip_y = landmark_axis(frame, f"{side}_hip", "y")
+    if None in {shoulder_x, shoulder_y, hip_x, hip_y}:
+        return None
+    horizontal_offset = abs(float(shoulder_x) - float(hip_x))
+    vertical_offset = abs(float(shoulder_y) - float(hip_y))
+    if vertical_offset <= 1e-6:
+        return None
+    from math import atan2, degrees
+
+    return degrees(atan2(horizontal_offset, vertical_offset))
+
+
+def value_series(frames: list[PoseFrame], getter: NumberGetter) -> list[float | None]:
+    return [getter(frame) for frame in frames]
+
+
+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 average_y(frame: PoseFrame, names: tuple[str, ...]) -> float | None:
+    return average_axis(frame, names, "y")

src/pozify/exercises/shared/issue_marker.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from statistics import mean
+from typing import Callable, Literal
+
+from pozify.contracts import IssueMarker, PoseFrame, PoseSequence, Rep, RepAnalysisItem, Variation
+from pozify.steps.rep_signals import average_axis, smooth_signal
+
+
+Comparison = Literal["lt", "gt"]
+Phase = Literal["all", "bottom", "top"]
+MetricGetter = Callable[[PoseFrame], float | None]
+
+
+@dataclass(frozen=True)
+class IssueRule:
+    issue: str
+    metric_name: str
+    threshold: float
+    comparison: Comparison
+    affected_joints: tuple[str, ...]
+    getter: MetricGetter
+    phase: Phase = "all"
+    suppress_when_not_issue: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class FrameScore:
+    frame: PoseFrame
+    value: float
+    severity: float
+
+
+def frames_for_rep(sequence: PoseSequence | None, rep: Rep) -> list[PoseFrame]:
+    if sequence is None:
+        return []
+    return [
+        frame
+        for frame in sequence.frames
+        if rep.start_frame <= frame.frame_index <= rep.end_frame
+    ]
+
+
+def phase_mask(frames: list[PoseFrame], exercise: str, phase: Phase) -> list[bool]:
+    if phase == "all":
+        return [True for _ in frames]
+
+    if exercise == "shoulder_press":
+        values = [average_axis(frame, ("left_wrist", "right_wrist"), "y") for frame in frames]
+        top_is_low = True
+    elif exercise == "push_up":
+        values = [
+            average_axis(frame, ("left_shoulder", "right_shoulder"), "y") for frame in frames
+        ]
+        top_is_low = False
+    else:
+        values = [average_axis(frame, ("left_hip", "right_hip"), "y") for frame in frames]
+        top_is_low = False
+
+    usable_values = [value for value in values if value is not None]
+    if not usable_values:
+        return [False for _ in frames]
+
+    minimum = min(usable_values)
+    maximum = max(usable_values)
+    value_range = maximum - minimum
+    if value_range <= 1e-6:
+        return [True for _ in frames]
+
+    if phase == "top":
+        cutoff = minimum + value_range * 0.35 if top_is_low else maximum - value_range * 0.35
+        return [
+            value is not None and (value <= cutoff if top_is_low else value >= cutoff)
+            for value in values
+        ]
+
+    cutoff = maximum - value_range * 0.35 if not top_is_low else minimum + value_range * 0.35
+    return [
+        value is not None and (value >= cutoff if not top_is_low else value <= cutoff)
+        for value in values
+    ]
+
+
+def violates(value: float, rule: IssueRule) -> bool:
+    if rule.comparison == "lt":
+        return value < rule.threshold
+    return value > rule.threshold
+
+
+def severity(value: float, rule: IssueRule) -> float:
+    denominator = max(abs(rule.threshold), 1e-6)
+    if rule.comparison == "lt":
+        return min(1.0, max(0.0, (rule.threshold - value) / denominator))
+    return min(1.0, max(0.0, (value - rule.threshold) / denominator))
+
+
+def minimum_run_length(frames: list[PoseFrame]) -> int:
+    return max(2, min(5, round(len(frames) * 0.08)))
+
+
+def group_violations(
+    scores: list[FrameScore | None],
+    minimum_length: int,
+) -> list[list[FrameScore]]:
+    groups: list[list[FrameScore]] = []
+    current: list[FrameScore] = []
+    for score_item in scores:
+        if score_item is None:
+            if len(current) >= minimum_length:
+                groups.append(current)
+            current = []
+            continue
+        current.append(score_item)
+
+    if len(current) >= minimum_length:
+        groups.append(current)
+    return groups
+
+
+def confidence(group: list[FrameScore], rep_item: RepAnalysisItem, variation: Variation) -> float:
+    visibility_values = [
+        frame_score.frame.pose_quality.get("mean_visibility")
+        for frame_score in group
+        if frame_score.frame.pose_quality.get("mean_visibility") is not None
+    ]
+    visibility = mean(float(value) for value in visibility_values) if visibility_values else 0.6
+    support = mean(frame_score.severity for frame_score in group)
+    value = (visibility * 0.5) + (support * 0.3) + (variation.variation_confidence * 0.2)
+    value *= max(0.5, min(1.0, rep_item.stability_score))
+    return round(min(1.0, max(0.0, value)), 2)
+
+
+def marker_from_group(
+    rule: IssueRule,
+    group: list[FrameScore],
+    rep_item: RepAnalysisItem,
+    variation: Variation,
+) -> IssueMarker:
+    metric_values = [frame_score.value for frame_score in group]
+    peak_score = max(group, key=lambda frame_score: frame_score.severity)
+    marker_severity = round(
+        min(1.0, max(0.0, mean(frame_score.severity for frame_score in group))),
+        2,
+    )
+    start = group[0].frame
+    end = group[-1].frame
+    evidence = {
+        rule.metric_name: round(peak_score.value, 4),
+        "threshold": rule.threshold,
+        "confidence": confidence(group, rep_item, variation),
+        "variation_context": {
+            "detected_variation": variation.detected_variation,
+            "variation_confidence": variation.variation_confidence,
+            "not_issues": list(variation.not_issues),
+        },
+        "mean_metric_value": round(mean(metric_values), 4),
+        "supporting_frames": len(group),
+    }
+    if rep_item.variation_hints:
+        evidence["rep_variation_hints"] = list(rep_item.variation_hints)
+
+    return IssueMarker(
+        rep_id=rep_item.rep_id,
+        issue=rule.issue,
+        severity=marker_severity,
+        start_frame=start.frame_index,
+        end_frame=end.frame_index,
+        start_sec=start.timestamp_sec,
+        end_sec=end.timestamp_sec,
+        affected_joints=list(rule.affected_joints),
+        evidence=evidence,
+    )
+
+
+def frame_scores_for_rule(
+    frames: list[PoseFrame],
+    exercise: str,
+    rule: IssueRule,
+) -> list[FrameScore | None]:
+    raw_values = [rule.getter(frame) for frame in frames]
+    values = smooth_signal(raw_values, window_radius=2)
+    active_phase = phase_mask(frames, exercise, rule.phase)
+    scores: list[FrameScore | None] = []
+
+    for frame, value, in_phase in zip(frames, values, active_phase, strict=False):
+        if value is None or not in_phase or not violates(value, rule):
+            scores.append(None)
+            continue
+        scores.append(FrameScore(frame=frame, value=value, severity=severity(value, rule)))
+
+    return scores

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/__init__.py

@@ -0,0 +1,5 @@
+from pozify.exercises.shoulder_press.analyzer import ShoulderPressAnalyzer
+from pozify.exercises.shoulder_press.issue_markers import RULES as ISSUE_RULES
+from pozify.exercises.shoulder_press.strategy import ShoulderPressExercise
+
+__all__ = ["ISSUE_RULES", "ShoulderPressAnalyzer", "ShoulderPressExercise"]

src/pozify/exercises/shoulder_press/analyzer.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from statistics import mean
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import (
+    ExerciseMetricResult,
+    max_optional,
+    mean_optional,
+    mean_pair,
+    min_optional,
+    range_optional,
+    round_optional,
+    score,
+    side_delta,
+    value_series,
+)
+from pozify.steps.rep_signals import average_axis, landmark_axis
+
+
+class ShoulderPressAnalyzer:
+    def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
+        elbow_angles = value_series(
+            frames,
+            lambda frame: mean_pair(
+                frame,
+                ("left_shoulder", "left_elbow", "left_wrist"),
+                ("right_shoulder", "right_elbow", "right_wrist"),
+            ),
+        )
+        elbow_deltas = value_series(
+            frames,
+            lambda frame: side_delta(
+                frame,
+                ("left_shoulder", "left_elbow", "left_wrist"),
+                ("right_shoulder", "right_elbow", "right_wrist"),
+            ),
+        )
+        wrist_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_wrist", "right_wrist"), "y"),
+        )
+        wrist_x = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_wrist", "right_wrist"), "x"),
+        )
+        left_wrist_y = value_series(frames, lambda frame: landmark_axis(frame, "left_wrist", "y"))
+        right_wrist_y = value_series(frames, lambda frame: landmark_axis(frame, "right_wrist", "y"))
+        wrist_asymmetry = [
+            abs(left - right)
+            for left, right in zip(left_wrist_y, right_wrist_y, strict=False)
+            if left is not None and right is not None
+        ]
+        shoulder_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_shoulder", "right_shoulder"), "y"),
+        )
+        hip_y = value_series(frames, lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"))
+
+        min_elbow = min_optional(elbow_angles)
+        max_elbow = max_optional(elbow_angles)
+        wrist_travel = range_optional(wrist_y) or 0.0
+        wrist_lateral_drift = range_optional(wrist_x) or 0.0
+        lockout_quality = score(((max_elbow or 120.0) - 120.0) / 55.0)
+        verticality = score(1.0 - wrist_lateral_drift / max(0.01, wrist_travel))
+        asymmetry = mean(wrist_asymmetry) if wrist_asymmetry else 0.0
+        back_arch_proxy = abs((range_optional(hip_y) or 0.0) - (range_optional(shoulder_y) or 0.0))
+
+        rom_score = score((wrist_travel / 0.28) * 0.55 + lockout_quality * 0.45)
+        stability_score = score(verticality * 0.65 + (1.0 - min(1.0, back_arch_proxy * 4.0)) * 0.35)
+        symmetry_score = score(1.0 - max(asymmetry * 5.0, (mean_optional(elbow_deltas) or 0.0) / 45.0))
+
+        metrics = {
+            "min_elbow_angle_deg": round_optional(min_elbow),
+            "max_elbow_angle_deg": round_optional(max_elbow),
+            "wrist_path_verticality": verticality,
+            "lockout_quality": lockout_quality,
+            "wrist_height_asymmetry": round_optional(asymmetry, 4),
+            "left_right_wrist_delta": round_optional(asymmetry, 4),
+            "back_arch_proxy": round_optional(back_arch_proxy, 4),
+            "overhead_stability_score": stability_score,
+            "wrist_travel": round_optional(wrist_travel, 4),
+        }
+        hints = []
+        if lockout_quality < 0.65:
+            hints.append("partial_press")
+        if asymmetry > 0.12:
+            hints.append("asymmetric_press")
+        return metrics, rom_score, stability_score, symmetry_score, hints

src/pozify/exercises/shoulder_press/issue_markers.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import mean_optional
+from pozify.exercises.shared.issue_marker import IssueRule
+from pozify.steps.rep_signals import angle_deg, landmark_axis
+
+
+def _elbow_angle(frame: PoseFrame) -> float | None:
+    return mean_optional(
+        [
+            angle_deg(frame, "left_shoulder", "left_elbow", "left_wrist"),
+            angle_deg(frame, "right_shoulder", "right_elbow", "right_wrist"),
+        ]
+    )
+
+
+def _wrist_height_asymmetry(frame: PoseFrame) -> float | None:
+    left = landmark_axis(frame, "left_wrist", "y")
+    right = landmark_axis(frame, "right_wrist", "y")
+    if left is None or right is None:
+        return None
+    return abs(left - right)
+
+
+RULES: tuple[IssueRule, ...] = (
+    IssueRule(
+        issue="incomplete_lockout",
+        metric_name="elbow_angle_deg",
+        threshold=155.0,
+        comparison="lt",
+        affected_joints=("left_elbow", "right_elbow", "left_wrist", "right_wrist"),
+        getter=_elbow_angle,
+        phase="top",
+    ),
+    IssueRule(
+        issue="asymmetry",
+        metric_name="wrist_height_asymmetry",
+        threshold=0.1,
+        comparison="gt",
+        affected_joints=("left_wrist", "right_wrist", "left_elbow", "right_elbow"),
+        getter=_wrist_height_asymmetry,
+    ),
+)

src/pozify/{steps/rep_counters/shoulder_press.py → exercises/shoulder_press/strategy.py}

@@ -2,15 +2,23 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence
-from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+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.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
-class ShoulderPressRepCounter(ExerciseRepCounter):
+class ShoulderPressExercise(ShoulderPressAnalyzer, ExerciseStrategy):
     exercise = "shoulder_press"
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def issue_rules(self) -> tuple[IssueRule, ...]:
+        return ISSUE_RULES
+
+    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(
@@ -36,3 +44,29 @@ class ShoulderPressRepCounter(ExerciseRepCounter):
             "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
         }
 
+    def detect_variation(self, analysis: RepAnalysis) -> tuple[str, float, list[str]]:
+        lockout_quality = self.metric(analysis, "avg_lockout_quality")
+        wrist_travel = self.metric(analysis, "avg_wrist_travel")
+        wrist_asymmetry = self.metric(analysis, "avg_wrist_height_asymmetry")
+
+        if wrist_asymmetry is not None and wrist_asymmetry >= 0.12:
+            return (
+                "asymmetric_press",
+                self.confidence(0.76, analysis, wrist_asymmetry),
+                ["intentional_asymmetry_check"],
+            )
+        if (lockout_quality is not None and lockout_quality <= 0.65) or (
+            wrist_travel is not None and wrist_travel < 0.24
+        ):
+            support = 1.0 - lockout_quality if lockout_quality is not None else wrist_travel
+            return "partial_press", self.confidence(0.72, analysis, support), ["partial_range_of_motion"]
+
+        not_issues = ["lockout_unverified"] if lockout_quality is None else []
+        return "standing_shoulder_press", self.confidence(0.62, analysis, lockout_quality), not_issues
+
+    def profile_not_issues(self, variation: str) -> list[str]:
+        mapping = {
+            "partial_press": ["partial_range_of_motion"],
+            "asymmetric_press": ["intentional_asymmetry_check"],
+        }
+        return list(mapping.get(variation, []))

src/pozify/exercises/squat/__init__.py

@@ -0,0 +1,5 @@
+from pozify.exercises.squat.analyzer import SquatAnalyzer
+from pozify.exercises.squat.issue_markers import RULES as ISSUE_RULES
+from pozify.exercises.squat.strategy import SquatExercise
+
+__all__ = ["ISSUE_RULES", "SquatAnalyzer", "SquatExercise"]

src/pozify/exercises/squat/analyzer.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import (
+    ExerciseMetricResult,
+    max_optional,
+    mean_optional,
+    mean_pair,
+    min_optional,
+    round_optional,
+    safe_ratio,
+    score,
+    side_delta,
+    std_optional,
+    torso_lean_deg,
+    value_series,
+    width,
+)
+from pozify.steps.rep_signals import average_axis
+
+
+class SquatAnalyzer:
+    def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
+        knee_angles = value_series(
+            frames,
+            lambda frame: mean_pair(
+                frame,
+                ("left_hip", "left_knee", "left_ankle"),
+                ("right_hip", "right_knee", "right_ankle"),
+            ),
+        )
+        hip_angles = value_series(
+            frames,
+            lambda frame: mean_pair(
+                frame,
+                ("left_shoulder", "left_hip", "left_knee"),
+                ("right_shoulder", "right_hip", "right_knee"),
+            ),
+        )
+        knee_deltas = value_series(
+            frames,
+            lambda frame: side_delta(
+                frame,
+                ("left_hip", "left_knee", "left_ankle"),
+                ("right_hip", "right_knee", "right_ankle"),
+            ),
+        )
+        hip_deltas = value_series(
+            frames,
+            lambda frame: side_delta(
+                frame,
+                ("left_shoulder", "left_hip", "left_knee"),
+                ("right_shoulder", "right_hip", "right_knee"),
+            ),
+        )
+        hip_y = value_series(frames, lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"))
+        knee_y = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_knee", "right_knee"), "y"),
+        )
+        ankle_width = value_series(frames, lambda frame: width(frame, "left_ankle", "right_ankle"))
+        shoulder_width = value_series(
+            frames,
+            lambda frame: width(frame, "left_shoulder", "right_shoulder"),
+        )
+        knee_width = value_series(frames, lambda frame: width(frame, "left_knee", "right_knee"))
+        torso_lean = value_series(
+            frames,
+            lambda frame: mean_optional(
+                [torso_lean_deg(frame, "left"), torso_lean_deg(frame, "right")]
+            ),
+        )
+
+        min_knee = min_optional(knee_angles)
+        max_knee = max_optional(knee_angles)
+        min_hip = min_optional(hip_angles)
+        max_hip = max_optional(hip_angles)
+        hip_depth_delta = None
+        max_hip_y = max_optional(hip_y)
+        mean_knee_y = mean_optional(knee_y)
+        if max_hip_y is not None and mean_knee_y is not None:
+            hip_depth_delta = max_hip_y - mean_knee_y
+
+        stance_ratio = safe_ratio(mean_optional(ankle_width), mean_optional(shoulder_width))
+        knee_tracking_ratio = safe_ratio(mean_optional(knee_width), mean_optional(ankle_width))
+        valgus_proxy = None if knee_tracking_ratio is None else max(0.0, 1.0 - knee_tracking_ratio)
+        symmetry_delta = mean_optional(knee_deltas + hip_deltas) or 0.0
+        stability_noise = (std_optional(hip_y) or 0.0) + (std_optional(knee_width) or 0.0)
+
+        knee_rom = 0.0 if min_knee is None or max_knee is None else max_knee - min_knee
+        depth_score = score((hip_depth_delta + 0.08) / 0.18) if hip_depth_delta is not None else 0.5
+        angle_score = score(knee_rom / 65.0)
+        rom_score = score(angle_score * 0.55 + depth_score * 0.45)
+        stability_score = score(1.0 - stability_noise * 5.0)
+        symmetry_score = score(1.0 - symmetry_delta / 45.0)
+
+        hip_x = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_hip", "right_hip"), "x"),
+        )
+        metrics = {
+            "min_knee_angle_deg": round_optional(min_knee),
+            "max_knee_angle_deg": round_optional(max_knee),
+            "min_hip_angle_deg": round_optional(min_hip),
+            "max_hip_angle_deg": round_optional(max_hip),
+            "hip_depth_delta": round_optional(hip_depth_delta, 4),
+            "hip_depth_relative_to_knee": (
+                "below_parallel"
+                if hip_depth_delta is not None and hip_depth_delta >= 0.03
+                else "parallel"
+                if hip_depth_delta is not None and hip_depth_delta >= -0.03
+                else "above_parallel"
+            ),
+            "max_torso_lean_deg": round_optional(max_optional(torso_lean)),
+            "knee_valgus_proxy": round_optional(valgus_proxy, 4),
+            "knee_tracking_score": score(1.0 - (valgus_proxy or 0.0)),
+            "stance_width_ratio": round_optional(stance_ratio, 3),
+            "hip_shift": round_optional(std_optional(hip_x), 4),
+            "bottom_stability_score": stability_score,
+        }
+        hints = []
+        if stance_ratio is not None and stance_ratio > 1.35:
+            hints.append("wide_squat_stance")
+        elif stance_ratio is not None and stance_ratio < 0.85:
+            hints.append("narrow_squat_stance")
+        return metrics, rom_score, stability_score, symmetry_score, hints

src/pozify/exercises/squat/issue_markers.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import mean_optional, safe_ratio, torso_lean_deg, width
+from pozify.exercises.shared.issue_marker import IssueRule
+from pozify.steps.rep_signals import average_axis
+
+
+def _depth_delta(frame: PoseFrame) -> float | None:
+    hip_y = average_axis(frame, ("left_hip", "right_hip"), "y")
+    knee_y = average_axis(frame, ("left_knee", "right_knee"), "y")
+    if hip_y is None or knee_y is None:
+        return None
+    return hip_y - knee_y
+
+
+def _knee_valgus_proxy(frame: PoseFrame) -> float | None:
+    knee_width = width(frame, "left_knee", "right_knee")
+    ankle_width = width(frame, "left_ankle", "right_ankle")
+    tracking_ratio = safe_ratio(knee_width, ankle_width)
+    if tracking_ratio is None:
+        return None
+    return max(0.0, 1.0 - tracking_ratio)
+
+
+def _torso_lean(frame: PoseFrame) -> float | None:
+    return mean_optional([torso_lean_deg(frame, "left"), torso_lean_deg(frame, "right")])
+
+
+RULES: tuple[IssueRule, ...] = (
+    IssueRule(
+        issue="shallow_depth",
+        metric_name="hip_depth_delta",
+        threshold=-0.03,
+        comparison="lt",
+        affected_joints=("left_hip", "right_hip", "left_knee", "right_knee"),
+        getter=_depth_delta,
+        phase="bottom",
+    ),
+    IssueRule(
+        issue="knee_valgus",
+        metric_name="knee_valgus_proxy",
+        threshold=0.25,
+        comparison="gt",
+        affected_joints=("left_knee", "right_knee", "left_ankle", "right_ankle"),
+        getter=_knee_valgus_proxy,
+        phase="bottom",
+    ),
+    IssueRule(
+        issue="excessive_torso_lean",
+        metric_name="torso_lean_deg",
+        threshold=35.0,
+        comparison="gt",
+        affected_joints=("left_shoulder", "right_shoulder", "left_hip", "right_hip"),
+        getter=_torso_lean,
+        phase="bottom",
+    ),
+)

src/pozify/{steps/rep_counters/squat.py → exercises/squat/strategy.py}

@@ -2,15 +2,23 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence
-from pozify.steps.rep_counters.base import ExerciseRepCounter, combine, mean_optional, normalized_samples
+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.exercises.shared.rep_counter import combine, mean_optional, normalized_samples
 from pozify.steps.rep_signals import SignalSample, angle_deg, average_axis, body_line_score
 
 
-class SquatRepCounter(ExerciseRepCounter):
+class SquatExercise(SquatAnalyzer, ExerciseStrategy):
     exercise = "squat"
 
-    def build_signal(self, sequence: PoseSequence) -> tuple[list[SignalSample], dict[str, Any]]:
+    def issue_rules(self) -> tuple[IssueRule, ...]:
+        return ISSUE_RULES
+
+    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(
@@ -33,3 +41,28 @@ class SquatRepCounter(ExerciseRepCounter):
             "body_line_mean": round(mean_optional(body_line) or 0.0, 4),
         }
 
+    def detect_variation(self, analysis: RepAnalysis) -> tuple[str, float, list[str]]:
+        stance_width = self.metric(analysis, "avg_stance_width_ratio")
+        bottom_pause = self.metric(analysis, "avg_bottom_pause_sec")
+
+        if bottom_pause is not None and bottom_pause >= 0.4:
+            return "pause_squat", self.confidence(0.76, analysis, bottom_pause), ["bottom_pause"]
+        if stance_width is not None and stance_width >= 1.35:
+            return "wide_squat_stance", self.confidence(0.72, analysis, stance_width), ["wide_stance"]
+        if stance_width is not None and stance_width <= 0.85:
+            return (
+                "narrow_squat_stance",
+                self.confidence(0.72, analysis, 1.0 - stance_width),
+                ["narrow_stance"],
+            )
+
+        not_issues = ["stance_width_unverified"] if stance_width is None else []
+        return "normal_squat_stance", self.confidence(0.62, analysis, stance_width), not_issues
+
+    def profile_not_issues(self, variation: str) -> list[str]:
+        mapping = {
+            "wide_squat_stance": ["wide_stance"],
+            "narrow_squat_stance": ["narrow_stance"],
+            "pause_squat": ["bottom_pause"],
+        }
+        return list(mapping.get(variation, []))

src/pozify/exercises/unknown/__init__.py

@@ -0,0 +1,4 @@
+from pozify.exercises.unknown.analyzer import UnknownAnalyzer
+from pozify.exercises.unknown.strategy import UnknownExercise
+
+__all__ = ["UnknownAnalyzer", "UnknownExercise"]

src/pozify/exercises/unknown/analyzer.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pozify.contracts import PoseFrame
+from pozify.exercises.shared.analyzer import (
+    ExerciseMetricResult,
+    mean_visibility,
+    range_optional,
+    score,
+    value_series,
+)
+from pozify.steps.rep_signals import average_axis
+
+
+class UnknownAnalyzer:
+    def metrics(self, frames: list[PoseFrame]) -> ExerciseMetricResult:
+        movement_signal = value_series(
+            frames,
+            lambda frame: average_axis(frame, ("left_hip", "right_hip"), "y"),
+        )
+        movement = range_optional(movement_signal) or 0.0
+        confidence = mean_visibility(frames)
+        metrics = {
+            "movement_consistency_score": score(1.0 - movement * 4.0),
+            "landmark_confidence": confidence,
+        }
+        return metrics, 0.0, metrics["movement_consistency_score"], confidence, []

src/pozify/{steps/rep_counters/registry.py → exercises/unknown/strategy.py}

@@ -2,33 +2,27 @@ from __future__ import annotations
 
 from typing import Any
 
-from pozify.contracts import PoseSequence, Reps
-from pozify.steps.rep_counters.base import ExerciseRepCounter
-from pozify.steps.rep_counters.push_up import PushUpRepCounter
-from pozify.steps.rep_counters.shoulder_press import ShoulderPressRepCounter
-from pozify.steps.rep_counters.squat import SquatRepCounter
+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
 from pozify.steps.rep_signals import SignalSample
 
 
-class UnknownRepCounter(ExerciseRepCounter):
+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": []}
 
-
-REP_COUNTERS: dict[str, ExerciseRepCounter] = {
-    "push_up": PushUpRepCounter(),
-    "shoulder_press": ShoulderPressRepCounter(),
-    "squat": SquatRepCounter(),
-    "unknown": UnknownRepCounter(),
-}
-
-
-def get_rep_counter(exercise: str) -> ExerciseRepCounter:
-    return REP_COUNTERS.get(exercise, REP_COUNTERS["unknown"])
-
+    def detect_variation(self, analysis: RepAnalysis) -> tuple[str, float, list[str]]:
+        exercise_spec = get_exercise_spec(analysis.exercise)
+        return (
+            exercise_spec.default_variation,
+            exercise_spec.default_variation_confidence,
+            list(exercise_spec.default_variation_not_issues),
+        )

src/pozify/pipeline.py

@@ -8,16 +8,13 @@ from uuid import uuid4
 
 from pozify.artifacts import write_json
 from pozify.contracts import UserProfile, to_dict
+from pozify.exercises import create_exercise_strategy
 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,
 )
@@ -26,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"}
 
 
@@ -37,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
@@ -73,17 +74,24 @@ def run_pipeline(
     classification = exercise_classifier.run(cleaned_pose_sequence, profile, mock=mock_mode)
     write_artifact("exercise_classification.json", classification)
 
-    reps, rep_debug = rep_counter.run(classification, cleaned_pose_sequence)
+    exercise = create_exercise_strategy(
+        classification.exercise,
+        video_manifest=manifest,
+        pose_sequence=cleaned_pose_sequence,
+        profile=profile,
+    )
+
+    reps, rep_debug = exercise.count()
     write_artifact("reps.json", reps)
     write_artifact("rep_debug.json", rep_debug)
 
-    analysis = rep_analysis.run(classification, reps, cleaned_pose_sequence)
+    analysis = exercise.analyze_reps(reps)
     write_artifact("rep_analysis.json", analysis)
 
-    variation = variation_detector.run(classification, analysis, profile)
+    variation = exercise.resolve_variation(analysis)
     write_artifact("variation.json", variation)
 
-    issues = issue_marker.run(classification, reps, analysis, variation)
+    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)
@@ -95,9 +103,6 @@ def run_pipeline(
     )
     analysis_mode = "mock" if mock_mode else "real"
     mock_steps = [
-        "rep_analysis",
-        "variation_detector",
-        "issue_marker",
         "coach_summary",
         "verifier",
     ]

src/pozify/steps/annotated_renderer.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import json
 from pathlib import Path
+import shutil
+import subprocess
 from typing import Any
 
 import cv2
@@ -24,6 +27,186 @@ SKELETON_EDGES = [
 ]
 
 PREFERRED_VIDEO_CODECS = ("avc1", "H264", "mp4v")
+HDR_TRANSFERS = {"arib-std-b67", "smpte2084"}
+HDR_PRIMARIES = {"bt2020"}
+BT709_COLOR_ARGS = (
+    "-color_primaries",
+    "bt709",
+    "-color_trc",
+    "bt709",
+    "-colorspace",
+    "bt709",
+)
+
+
+def _tool_path(name: str) -> str | None:
+    return shutil.which(name)
+
+
+def _video_color_metadata(video_path: str) -> dict[str, str]:
+    ffprobe = _tool_path("ffprobe")
+    if ffprobe is None:
+        return {}
+
+    command = [
+        ffprobe,
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=color_space,color_transfer,color_primaries,color_range",
+        "-of",
+        "json",
+        video_path,
+    ]
+    try:
+        result = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        payload = json.loads(result.stdout)
+    except (subprocess.SubprocessError, json.JSONDecodeError, OSError):
+        return {}
+
+    streams = payload.get("streams")
+    if not isinstance(streams, list) or not streams:
+        return {}
+    stream = streams[0]
+    if not isinstance(stream, dict):
+        return {}
+    metadata: dict[str, str] = {}
+    for key, value in stream.items():
+        if value is None or isinstance(value, (dict, list)):
+            continue
+        normalized_value = str(value).lower()
+        if normalized_value == "unknown":
+            continue
+        metadata[key] = normalized_value
+    return metadata
+
+
+def _needs_sdr_conversion(color_metadata: dict[str, str]) -> bool:
+    transfer = color_metadata.get("color_transfer", "")
+    primaries = color_metadata.get("color_primaries", "")
+    return transfer in HDR_TRANSFERS or primaries in HDR_PRIMARIES
+
+
+def _sdr_filter(color_metadata: dict[str, str]) -> str:
+    transfer = color_metadata.get("color_transfer", "arib-std-b67")
+    primaries = color_metadata.get("color_primaries", "bt2020")
+    matrix = color_metadata.get("color_space", "bt2020nc")
+    if transfer not in HDR_TRANSFERS:
+        transfer = "arib-std-b67"
+    if primaries not in HDR_PRIMARIES:
+        primaries = "bt2020"
+    if matrix not in {"bt2020nc", "bt2020c"}:
+        matrix = "bt2020nc"
+
+    return (
+        f"zscale=transfer=linear:transferin={transfer}:"
+        f"primariesin={primaries}:matrixin={matrix}:npl=100,"
+        "tonemap=tonemap=hable:desat=0,"
+        "zscale=transfer=bt709:primaries=bt709:matrix=bt709:range=tv,"
+        "format=yuv420p"
+    )
+
+
+def _transcode_hdr_to_sdr(
+    input_path: Path,
+    output_path: Path,
+    color_metadata: dict[str, str],
+) -> bool:
+    ffmpeg = _tool_path("ffmpeg")
+    if ffmpeg is None:
+        return False
+
+    command = [
+        ffmpeg,
+        "-y",
+        "-v",
+        "error",
+        "-i",
+        str(input_path),
+        "-vf",
+        _sdr_filter(color_metadata),
+        "-an",
+        "-c:v",
+        "libx264",
+        "-preset",
+        "veryfast",
+        "-crf",
+        "18",
+        "-pix_fmt",
+        "yuv420p",
+        *BT709_COLOR_ARGS,
+        str(output_path),
+    ]
+    try:
+        subprocess.run(command, check=True, capture_output=True, timeout=120)
+    except (subprocess.SubprocessError, OSError):
+        return False
+    return output_path.exists() and output_path.stat().st_size > 0
+
+
+def _encode_bt709_output(
+    raw_video_path: Path,
+    output_path: Path,
+    audio_source_path: Path | None,
+) -> bool:
+    ffmpeg = _tool_path("ffmpeg")
+    if ffmpeg is None:
+        return False
+
+    command = [
+        ffmpeg,
+        "-y",
+        "-v",
+        "error",
+        "-i",
+        str(raw_video_path),
+    ]
+    if audio_source_path is not None:
+        command.extend(["-i", str(audio_source_path)])
+
+    command.extend(
+        [
+            "-map",
+            "0:v:0",
+        ]
+    )
+    if audio_source_path is not None:
+        command.extend(["-map", "1:a?"])
+
+    command.extend(
+        [
+            "-c:v",
+            "libx264",
+            "-preset",
+            "veryfast",
+            "-crf",
+            "18",
+            "-vf",
+            "setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709,format=yuv420p",
+            "-pix_fmt",
+            "yuv420p",
+            *BT709_COLOR_ARGS,
+        ]
+    )
+    if audio_source_path is not None:
+        command.extend(["-c:a", "aac", "-b:a", "128k", "-shortest"])
+    else:
+        command.append("-an")
+    command.append(str(output_path))
+
+    try:
+        subprocess.run(command, check=True, capture_output=True, timeout=120)
+    except (subprocess.SubprocessError, OSError):
+        return False
+    return output_path.exists() and output_path.stat().st_size > 0
 
 
 def _frame_landmark_points(
@@ -103,7 +286,12 @@ def _draw_overlays(
         )
 
 
-def _open_video_writer(output_path: Path, fps: float, width: int, height: int) -> tuple[cv2.VideoWriter | None, str | None]:
+def _open_video_writer(
+    output_path: Path,
+    fps: float,
+    width: int,
+    height: int,
+) -> tuple[cv2.VideoWriter | None, str | None]:
     for codec in PREFERRED_VIDEO_CODECS:
         writer = cv2.VideoWriter(
             str(output_path),
@@ -127,9 +315,21 @@ def run(
     if not manifest.analysis_allowed or not manifest.video_path:
         return manifest.video_path
 
-    capture = cv2.VideoCapture(manifest.video_path)
+    source_path = Path(manifest.video_path)
+    color_metadata = _video_color_metadata(manifest.video_path)
+    render_input_path = source_path
+    temporary_paths: list[Path] = []
+    if _needs_sdr_conversion(color_metadata):
+        sdr_input_path = run_dir / "renderer_sdr_input.mp4"
+        if _transcode_hdr_to_sdr(source_path, sdr_input_path, color_metadata):
+            render_input_path = sdr_input_path
+            temporary_paths.append(sdr_input_path)
+
+    capture = cv2.VideoCapture(str(render_input_path))
     if not capture.isOpened():
         capture.release()
+        for temporary_path in temporary_paths:
+            temporary_path.unlink(missing_ok=True)
         return manifest.video_path
 
     fps = manifest.fps if manifest.fps > 0 else 30.0
@@ -140,9 +340,12 @@ def run(
         return manifest.video_path
 
     output_path = run_dir / "annotated_video.mp4"
-    writer, _codec = _open_video_writer(output_path, fps, width, height)
+    raw_output_path = run_dir / "annotated_video_raw.mp4" if _tool_path("ffmpeg") else output_path
+    writer, _codec = _open_video_writer(raw_output_path, fps, width, height)
     if writer is None:
         capture.release()
+        for temporary_path in temporary_paths:
+            temporary_path.unlink(missing_ok=True)
         return manifest.video_path
 
     pose_by_frame = {frame.frame_index: frame for frame in pose_sequence.frames}
@@ -180,5 +383,13 @@ def run(
     finally:
         writer.release()
         capture.release()
+        for temporary_path in temporary_paths:
+            temporary_path.unlink(missing_ok=True)
+
+    if raw_output_path != output_path:
+        encoded = _encode_bt709_output(raw_output_path, output_path, source_path)
+        if not encoded:
+            raw_output_path.replace(output_path)
+        raw_output_path.unlink(missing_ok=True)
 
     return str(output_path)

src/pozify/steps/coach_summary.py

@@ -22,29 +22,29 @@ def run(
     issue_labels = [issue.issue for issue in issues.issues]
     main_issue = issue_labels[0] if issue_labels else "no_major_issue"
     issue_text = (
-        f"The current mock issue placeholder is `{main_issue}`, mostly appearing in later reps."
+        f"The strongest frame-level marker is `{main_issue}`, with timestamps and metric evidence in the issue timeline."
         if issues.issues
-        else "The current mock issue layer did not emit a major issue."
+        else "The frame-level issue rules did not find a sustained threshold violation."
     )
 
     return CoachSummary(
         summary=(
             f"The pipeline segmented {len(reps.reps)} {classification.exercise} reps from the current pose stream. "
-            f"Exercise routing, variation labeling, issue labeling, and coaching language still use mock placeholders. "
-            f"The current placeholder variation is `{variation.detected_variation}`. {issue_text}"
+            f"Exercise routing, variation labeling, and coaching language may still use lightweight rules or placeholders. "
+            f"The detected variation is `{variation.detected_variation}`. {issue_text}"
         ),
         what_went_well=[
             f"Current placeholder ROM score is {analysis.aggregate_metrics['avg_rom_score']}.",
             f"Current placeholder symmetry score is {analysis.aggregate_metrics['avg_symmetry_score']}.",
         ],
         main_findings=[
-            f"Mock issue placeholder `{main_issue}` appears in {len(issues.issues)} rep(s)."
+            f"Frame-level marker `{main_issue}` appears in {len(issues.issues)} interval(s)."
             if issues.issues
-            else "No mock issue placeholder detected."
+            else "No sustained issue interval detected."
         ],
         variation_explanation=(
-            f"`{variation.detected_variation}` is currently a placeholder variation label. "
-            f"It should not be treated as a verified movement diagnosis yet."
+            f"`{variation.detected_variation}` was included as context for interpreting issue markers. "
+            f"It should be reviewed alongside camera angle and pose confidence."
         ),
         top_fixes=[
             "Keep the same setup and record from a stable camera angle.",

src/pozify/steps/issue_marker.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from pozify.contracts import (
-    ExerciseClassification,
-    IssueMarker,
-    IssueMarkers,
-    RepAnalysis,
-    Reps,
-    Variation,
-)
-from pozify.exercise_catalog import get_exercise_spec
-
-
-def run(
-    classification: ExerciseClassification,
-    reps: Reps,
-    analysis: RepAnalysis,
-    variation: Variation,
-) -> IssueMarkers:
-    issues: list[IssueMarker] = []
-    exercise_spec = get_exercise_spec(classification.exercise)
-    for item in analysis.items:
-        if item.stability_score >= 0.78 or exercise_spec.mock_issue is None:
-            continue
-
-        rep = next(rep for rep in reps.reps if rep.rep_id == item.rep_id)
-        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)
-        )
-        evidence = {
-            issue_spec.evidence_metric: metric_value,
-            "threshold": issue_spec.threshold,
-            "variation": variation.detected_variation,
-        }
-
-        issues.append(
-            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=evidence,
-            )
-        )
-
-    return IssueMarkers(issues=issues)

src/pozify/steps/rep_analysis.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from statistics import mean
-from typing import Any
-
-from pozify.contracts import (
-    ExerciseClassification,
-    PoseSequence,
-    RepAnalysis,
-    RepAnalysisItem,
-    Reps,
-)
-from pozify.exercise_catalog import get_exercise_spec
-
-
-def _clamp_score(value: float) -> float:
-    return round(min(1.0, max(0.0, value)), 2)
-
-
-def _metrics_for_exercise(exercise: str, rep_id: int) -> dict[str, Any]:
-    fatigue_penalty = max(0, rep_id - 3) * 0.08
-    return get_exercise_spec(exercise).metric_factory(rep_id, fatigue_penalty)
-
-
-def run(
-    classification: ExerciseClassification,
-    reps: Reps,
-    sequence: PoseSequence,
-) -> RepAnalysis:
-    items: list[RepAnalysisItem] = []
-    exercise_spec = get_exercise_spec(classification.exercise)
-    for rep in reps.reps:
-        fatigue_penalty = max(0, rep.rep_id - 3) * 0.08
-        items.append(
-            RepAnalysisItem(
-                rep_id=rep.rep_id,
-                duration_sec=round(rep.end_sec - rep.start_sec, 2),
-                range_of_motion_score=_clamp_score(0.88 - fatigue_penalty),
-                stability_score=_clamp_score(0.86 - fatigue_penalty),
-                symmetry_score=_clamp_score(0.9 - fatigue_penalty / 2),
-                metrics=_metrics_for_exercise(classification.exercise, rep.rep_id),
-                variation_hints=list(exercise_spec.variation_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,
-        "pose_valid_ratio": sequence.pose_valid_ratio,
-        "mock": True,
-    }
-
-    return RepAnalysis(
-        exercise=classification.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 ExerciseClassification, PoseSequence, Reps
-from pozify.steps.rep_counters import get_rep_counter
-
-
-def run(classification: ExerciseClassification, sequence: PoseSequence) -> tuple[Reps, dict[str, Any]]:
-    return get_rep_counter(classification.exercise).count(sequence)

src/pozify/steps/rep_counters/__init__.py

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

src/pozify/steps/variation_detector.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from pozify.contracts import ExerciseClassification, RepAnalysis, UserProfile, Variation
-from pozify.exercise_catalog import get_exercise_spec
-
-
-def run(
-    classification: ExerciseClassification,
-    analysis: RepAnalysis,
-    profile: UserProfile,
-) -> Variation:
-    exercise_spec = get_exercise_spec(classification.exercise)
-    if profile.intended_variation:
-        variation = profile.intended_variation
-        confidence = 0.95
-    else:
-        variation = exercise_spec.default_variation
-        confidence = exercise_spec.default_variation_confidence
-
-    not_issues = (
-        list(exercise_spec.default_variation_not_issues)
-        if variation == exercise_spec.default_variation
-        else []
-    )
-    if analysis.aggregate_metrics.get("avg_rom_score", 1.0) < 0.7:
-        not_issues.append("mock_low_rom_requires_user_intent_check")
-
-    return Variation(
-        exercise=classification.exercise,
-        detected_variation=variation,
-        variation_confidence=confidence,
-        not_issues=not_issues,
-    )

tests/test_annotated_renderer.py

@@ -95,6 +95,26 @@ class AnnotatedRendererTests(unittest.TestCase):
         self.assertIsNotNone(output_path)
         self.assertTrue(Path(str(output_path)).exists())
 
+    def test_hdr_metadata_requires_sdr_conversion(self) -> None:
+        self.assertTrue(
+            annotated_renderer._needs_sdr_conversion(
+                {
+                    "color_space": "bt2020nc",
+                    "color_transfer": "arib-std-b67",
+                    "color_primaries": "bt2020",
+                }
+            )
+        )
+        self.assertFalse(
+            annotated_renderer._needs_sdr_conversion(
+                {
+                    "color_space": "bt709",
+                    "color_transfer": "bt709",
+                    "color_primaries": "bt709",
+                }
+            )
+        )
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_issue_marker.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+import sys
+from typing import Callable
+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
+
+
+def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
+    return PoseFrame(
+        frame_index=frame_index,
+        timestamp_sec=round(frame_index / 30.0, 3),
+        landmarks=landmarks,
+        world_landmarks={},
+        pose_quality={"mean_visibility": 0.92, "normalized": True},
+    )
+
+
+def _wave(frame_index: int, cycle_frames: int = 30) -> float:
+    return (1.0 - math.cos(2.0 * math.pi * (frame_index / cycle_frames))) / 2.0
+
+
+def _reps(exercise: str, end_frame: int = 29) -> Reps:
+    return Reps(
+        exercise=exercise,
+        reps=[Rep(1, 0, end_frame // 2, end_frame, 0.0, round((end_frame // 2) / 30.0, 3), round(end_frame / 30.0, 3))],
+        partial_reps=[],
+    )
+
+
+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 _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)],
+        normalized=True,
+        smoothing_method="none",
+        pose_valid_ratio=1.0,
+    )
+
+
+def _push_up_landmarks(frame_index: int, depth: float, *, noise_only: bool = False) -> dict[str, dict[str, float]]:
+    shoulder_y = 0.38 + depth * 0.16
+    hip_y = 0.46 + depth * 0.16
+    ankle_y = 0.54 + depth * 0.16
+    if 10 <= frame_index <= 18 and not noise_only:
+        hip_y += 0.45
+    if frame_index == 15 and noise_only:
+        hip_y += 0.45
+
+    shoulder_width = 0.4
+    hand_width = shoulder_width * 1.7
+    return {
+        "left_shoulder": {"x": 0.3, "y": shoulder_y},
+        "right_shoulder": {"x": 0.7, "y": shoulder_y},
+        "left_elbow": {"x": 0.36 + depth * 0.02, "y": 0.46 + depth * 0.1},
+        "right_elbow": {"x": 0.64 - depth * 0.02, "y": 0.46 + depth * 0.1},
+        "left_wrist": {"x": 0.5 - hand_width / 2, "y": 0.5 + depth * 0.04},
+        "right_wrist": {"x": 0.5 + hand_width / 2, "y": 0.5 + depth * 0.04},
+        "left_hip": {"x": 0.42, "y": hip_y},
+        "right_hip": {"x": 0.58, "y": hip_y},
+        "left_knee": {"x": 0.44, "y": hip_y + 0.2},
+        "right_knee": {"x": 0.56, "y": hip_y + 0.2},
+        "left_ankle": {"x": 0.44, "y": ankle_y},
+        "right_ankle": {"x": 0.56, "y": ankle_y},
+    }
+
+
+def _squat_landmarks(frame_index: int, depth: float) -> dict[str, dict[str, float]]:
+    del frame_index
+    hip_y = 0.54 + depth * 0.08
+    knee_y = 0.74
+    knee_half_width = 0.04 + (1.0 - depth) * 0.08
+    return {
+        "left_shoulder": {"x": 0.74, "y": 0.26 + depth * 0.02},
+        "right_shoulder": {"x": 0.86, "y": 0.26 + depth * 0.02},
+        "left_hip": {"x": 0.43, "y": hip_y},
+        "right_hip": {"x": 0.57, "y": hip_y},
+        "left_knee": {"x": 0.5 - knee_half_width, "y": knee_y},
+        "right_knee": {"x": 0.5 + knee_half_width, "y": knee_y},
+        "left_ankle": {"x": 0.3, "y": 0.94},
+        "right_ankle": {"x": 0.7, "y": 0.94},
+    }
+
+
+def _shoulder_press_landmarks(frame_index: int, lift: float) -> dict[str, dict[str, float]]:
+    del frame_index
+    wrist_y = 0.74 - lift * 0.12
+    return {
+        "left_shoulder": {"x": 0.42, "y": 0.42},
+        "right_shoulder": {"x": 0.58, "y": 0.42},
+        "left_elbow": {"x": 0.35, "y": 0.56 - lift * 0.04},
+        "right_elbow": {"x": 0.65, "y": 0.56 - lift * 0.04},
+        "left_wrist": {"x": 0.18, "y": wrist_y + 0.08},
+        "right_wrist": {"x": 0.82, "y": wrist_y - 0.08},
+        "left_hip": {"x": 0.44, "y": 0.74},
+        "right_hip": {"x": 0.56, "y": 0.74},
+        "left_ankle": {"x": 0.45, "y": 0.96},
+        "right_ankle": {"x": 0.55, "y": 0.96},
+    }
+
+
+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 = exercise_strategy.analyze_reps(reps)
+    variation = exercise_strategy.resolve_variation(analysis)
+    return exercise_strategy.mark_issues(reps, analysis, variation)
+
+
+class IssueMarkerTests(unittest.TestCase):
+    def test_push_up_hip_sag_interval_includes_evidence_and_variation_context(self) -> None:
+        markers = _run_markers("push_up", _sequence(_push_up_landmarks))
+        hip_sag = next(issue for issue in markers.issues if issue.issue == "hip_sag")
+
+        self.assertGreaterEqual(hip_sag.end_frame - hip_sag.start_frame, 2)
+        self.assertLess(hip_sag.evidence["body_line_score"], hip_sag.evidence["threshold"])
+        self.assertIn("confidence", hip_sag.evidence)
+        self.assertEqual(
+            hip_sag.evidence["variation_context"]["detected_variation"],
+            "wide_grip_push_up",
+        )
+        self.assertIn("wide_hand_placement", hip_sag.evidence["variation_context"]["not_issues"])
+        self.assertIn("left_hip", hip_sag.affected_joints)
+
+    def test_single_frame_push_up_sag_noise_is_filtered_out(self) -> None:
+        markers = _run_markers(
+            "push_up",
+            _sequence(lambda frame_index, depth: _push_up_landmarks(frame_index, depth, noise_only=True)),
+        )
+
+        self.assertNotIn("hip_sag", {issue.issue for issue in markers.issues})
+
+    def test_squat_rules_emit_depth_valgus_and_torso_lean_intervals(self) -> None:
+        markers = _run_markers("squat", _sequence(_squat_landmarks))
+        labels = {issue.issue for issue in markers.issues}
+
+        self.assertIn("shallow_depth", labels)
+        self.assertIn("knee_valgus", labels)
+        self.assertIn("excessive_torso_lean", labels)
+
+    def test_shoulder_press_rules_emit_lockout_and_asymmetry_intervals(self) -> None:
+        markers = _run_markers("shoulder_press", _sequence(_shoulder_press_landmarks))
+        labels = {issue.issue for issue in markers.issues}
+
+        self.assertIn("incomplete_lockout", labels)
+        self.assertIn("asymmetry", labels)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+from pathlib import Path
+import math
+import sys
+from typing import Callable
+import unittest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from pozify.contracts import (
+    PoseFrame,
+    PoseSequence,
+    Rep,
+    Reps,
+    UserProfile,
+    VideoManifest,
+)
+from pozify.exercises import create_exercise_strategy
+
+
+def _frame(frame_index: int, landmarks: dict[str, dict[str, float]]) -> PoseFrame:
+    return PoseFrame(
+        frame_index=frame_index,
+        timestamp_sec=round(frame_index / 30.0, 3),
+        landmarks=landmarks,
+        world_landmarks={},
+        pose_quality={"mean_visibility": 0.95, "normalized": True},
+    )
+
+
+def _wave(frame_index: int, cycle_frames: int) -> float:
+    return (1.0 - math.cos(2.0 * math.pi * (frame_index / cycle_frames))) / 2.0
+
+
+def _push_up_landmarks(depth: float, *, hand_ratio: float = 1.7) -> dict[str, dict[str, float]]:
+    shoulder_y = 0.38 + depth * 0.16
+    hip_y = 0.46 + depth * 0.16
+    ankle_y = 0.54 + depth * 0.16
+    elbow_y = 0.46 + depth * 0.1
+    wrist_y = 0.5 + depth * 0.04
+    shoulder_width = 0.4
+    hand_width = shoulder_width * hand_ratio
+    return {
+        "left_shoulder": {"x": 0.3, "y": shoulder_y},
+        "right_shoulder": {"x": 0.7, "y": shoulder_y},
+        "left_elbow": {"x": 0.36 + depth * 0.02, "y": elbow_y},
+        "right_elbow": {"x": 0.64 - depth * 0.02, "y": elbow_y},
+        "left_wrist": {"x": 0.5 - hand_width / 2, "y": wrist_y},
+        "right_wrist": {"x": 0.5 + hand_width / 2, "y": wrist_y},
+        "left_hip": {"x": 0.42, "y": hip_y},
+        "right_hip": {"x": 0.58, "y": hip_y},
+        "left_ankle": {"x": 0.44, "y": ankle_y},
+        "right_ankle": {"x": 0.56, "y": ankle_y},
+    }
+
+
+def _knee_push_up_landmarks(depth: float, *, hand_ratio: float = 1.1) -> dict[str, dict[str, float]]:
+    shoulder_y = 0.38 + depth * 0.16
+    hip_y = 0.46 + depth * 0.16
+    knee_y = hip_y + 0.03
+    ankle_y = hip_y + 0.28
+    elbow_y = 0.46 + depth * 0.1
+    wrist_y = 0.5 + depth * 0.04
+    shoulder_width = 0.4
+    hand_width = shoulder_width * hand_ratio
+    return {
+        "left_shoulder": {"x": 0.3, "y": shoulder_y},
+        "right_shoulder": {"x": 0.7, "y": shoulder_y},
+        "left_elbow": {"x": 0.36 + depth * 0.02, "y": elbow_y},
+        "right_elbow": {"x": 0.64 - depth * 0.02, "y": elbow_y},
+        "left_wrist": {"x": 0.5 - hand_width / 2, "y": wrist_y},
+        "right_wrist": {"x": 0.5 + hand_width / 2, "y": wrist_y},
+        "left_hip": {"x": 0.42, "y": hip_y},
+        "right_hip": {"x": 0.58, "y": hip_y},
+        "left_knee": {"x": 0.44, "y": knee_y},
+        "right_knee": {"x": 0.56, "y": knee_y},
+        "left_ankle": {"x": 0.44, "y": ankle_y},
+        "right_ankle": {"x": 0.56, "y": ankle_y},
+    }
+
+
+def _straight_leg_push_up_landmarks(depth: float) -> dict[str, dict[str, float]]:
+    shoulder_y = 0.38 + depth * 0.1
+    hip_y = 0.46 + depth * 0.1
+    knee_y = 0.5 + depth * 0.1
+    ankle_y = 0.52 + depth * 0.1
+    elbow_y = 0.46 + depth * 0.06
+    wrist_y = 0.52 + depth * 0.02
+    return {
+        "left_shoulder": {"x": 0.3, "y": shoulder_y},
+        "right_shoulder": {"x": 0.32, "y": shoulder_y},
+        "left_elbow": {"x": 0.35, "y": elbow_y},
+        "right_elbow": {"x": 0.37, "y": elbow_y},
+        "left_wrist": {"x": 0.42, "y": wrist_y},
+        "right_wrist": {"x": 0.44, "y": wrist_y},
+        "left_hip": {"x": 0.58, "y": hip_y},
+        "right_hip": {"x": 0.6, "y": hip_y},
+        "left_knee": {"x": 0.72, "y": knee_y},
+        "right_knee": {"x": 0.74, "y": knee_y},
+        "left_ankle": {"x": 0.88, "y": ankle_y},
+        "right_ankle": {"x": 0.9, "y": ankle_y},
+    }
+
+
+def _squat_landmarks(depth: float, *, stance_ratio: float = 1.5) -> dict[str, dict[str, float]]:
+    shoulder_width = 0.2
+    stance_width = shoulder_width * stance_ratio
+    hip_y = 0.52 + depth * 0.22
+    shoulder_y = 0.28 + depth * 0.06
+    knee_y = 0.7
+    return {
+        "left_shoulder": {"x": 0.4, "y": shoulder_y},
+        "right_shoulder": {"x": 0.6, "y": shoulder_y},
+        "left_hip": {"x": 0.43, "y": hip_y},
+        "right_hip": {"x": 0.57, "y": hip_y},
+        "left_knee": {"x": 0.43 + depth * 0.05, "y": knee_y},
+        "right_knee": {"x": 0.57 - depth * 0.05, "y": knee_y},
+        "left_ankle": {"x": 0.5 - stance_width / 2, "y": 0.92},
+        "right_ankle": {"x": 0.5 + stance_width / 2, "y": 0.92},
+    }
+
+
+def _shoulder_press_landmarks(lift: float, *, partial: bool = True) -> dict[str, dict[str, float]]:
+    wrist_top = 0.56 if partial else 0.42
+    wrist_y = 0.76 - lift * (0.76 - wrist_top)
+    elbow_y = 0.6 - lift * 0.06
+    return {
+        "left_shoulder": {"x": 0.42, "y": 0.42},
+        "right_shoulder": {"x": 0.58, "y": 0.42},
+        "left_elbow": {"x": 0.4 - lift * 0.02, "y": elbow_y},
+        "right_elbow": {"x": 0.6 + lift * 0.02, "y": elbow_y},
+        "left_wrist": {"x": 0.4, "y": wrist_y},
+        "right_wrist": {"x": 0.6, "y": wrist_y},
+        "left_hip": {"x": 0.44, "y": 0.74},
+        "right_hip": {"x": 0.56, "y": 0.74},
+    }
+
+
+def _sequence(exercise: str) -> PoseSequence:
+    frames = []
+    for frame_index in range(25):
+        wave = _wave(frame_index, 24)
+        if exercise == "push_up":
+            landmarks = _push_up_landmarks(wave)
+        elif exercise == "shoulder_press":
+            landmarks = _shoulder_press_landmarks(wave)
+        else:
+            landmarks = _squat_landmarks(wave)
+        frames.append(_frame(frame_index, landmarks))
+    return PoseSequence(
+        frames=frames,
+        normalized=True,
+        smoothing_method="none",
+        pose_valid_ratio=1.0,
+    )
+
+
+def _custom_sequence(
+    landmark_factory: Callable[[float], dict[str, dict[str, float]]],
+) -> PoseSequence:
+    frames = []
+    for frame_index in range(25):
+        frames.append(_frame(frame_index, landmark_factory(_wave(frame_index, 24))))
+    return PoseSequence(
+        frames=frames,
+        normalized=True,
+        smoothing_method="none",
+        pose_valid_ratio=1.0,
+    )
+
+
+def _reps(exercise: str) -> Reps:
+    return Reps(
+        exercise=exercise,
+        reps=[Rep(1, 0, 12, 24, 0.0, 0.4, 0.8)],
+        partial_reps=[],
+    )
+
+
+def _profile() -> UserProfile:
+    return UserProfile(
+        goal="beginner_practice",
+        experience_level="beginner",
+        intended_exercise="auto",
+        intended_variation=None,
+        known_limitations=[],
+        equipment="bodyweight",
+    )
+
+
+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:
+        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)
+        self.assertGreater(analysis.items[0].metrics["hand_width_ratio"], 1.45)
+        self.assertIn("body_line_score", analysis.items[0].metrics)
+
+    def test_push_up_metrics_detect_knee_push_up_variation(self) -> None:
+        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:
+        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:
+        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)
+        self.assertGreater(analysis.items[0].metrics["stance_width_ratio"], 1.35)
+        self.assertIn("min_knee_angle_deg", analysis.items[0].metrics)
+
+    def test_shoulder_press_metrics_detect_partial_press_variation(self) -> None:
+        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)
+        self.assertIn("lockout_quality", analysis.items[0].metrics)
+        self.assertLess(analysis.aggregate_metrics["avg_wrist_travel"], 0.24)
+
+    def test_profile_intended_variation_overrides_metric_rule(self) -> None:
+        profile = UserProfile(
+            goal="beginner_practice",
+            experience_level="beginner",
+            intended_exercise="push_up",
+            intended_variation="close_grip_push_up",
+            known_limitations=[],
+            equipment="bodyweight",
+        )
+        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)
+        self.assertIn("close_hand_placement", variation.not_issues)
+
+
+if __name__ == "__main__":
+    unittest.main()

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 ExerciseClassification, PoseFrame, PoseSequence
-from pozify.steps import rep_counter
-from pozify.steps.rep_counters import get_rep_counter
-from pozify.steps.rep_counters.push_up import PushUpRepCounter
-from pozify.steps.rep_counters.shoulder_press import ShoulderPressRepCounter
-from pozify.steps.rep_counters.squat import SquatRepCounter
+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
 
 
 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
     )
 
 
-class RepCounterTests(unittest.TestCase):
-    def _classification(self, exercise: str) -> ExerciseClassification:
-        return ExerciseClassification(
-            exercise=exercise,  # type: ignore[arg-type]
-            confidence=0.95,
-            window_predictions=[],
-            fallback_required=False,
-        )
+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(self._classification("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(self._classification("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(
-            self._classification("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(
-            self._classification("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(self._classification("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_rep_counter_strategies(self) -> None:
-        self.assertIsInstance(get_rep_counter("push_up"), PushUpRepCounter)
-        self.assertIsInstance(get_rep_counter("shoulder_press"), ShoulderPressRepCounter)
-        self.assertIsInstance(get_rep_counter("squat"), SquatRepCounter)
+    def test_exercises_resolve_to_specific_strategies(self) -> None:
+        sequence = _sequence_for_exercise("push_up", 1)
+        push_up = _exercise_strategy("push_up", sequence)
+        self.assertIsInstance(push_up, PushUpExercise)
+        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__":

web/app.js

@@ -51,10 +51,12 @@ function Summary({ result }) {
   const report = result.report;
   const summary = report.coach_summary;
   const warnings = report.video_manifest.quality_warnings || [];
+  const issues = report.issue_markers?.issues || [];
   const stats = [
     ["Exercise", report.exercise.exercise],
     ["Variation", report.variation.detected_variation],
     ["Reps", String(report.reps.reps.length)],
+    ["Issues", String(issues.length)],
     ["Mode", report.artifacts.analysis_mode],
   ];
 
@@ -77,6 +79,7 @@ function Summary({ result }) {
       h(NoteList, { title: "Top fixes", items: summary.top_fixes }),
       h(NoteList, { title: "Next session", items: summary.next_session_plan }),
     ),
+    h(IssueTimeline, { issues }),
     warnings.length
       ? h(
           "div",
@@ -87,6 +90,54 @@ function Summary({ result }) {
   );
 }
 
+function issueEvidence(issue) {
+  const entries = Object.entries(issue.evidence || {}).filter(
+    ([key, value]) =>
+      !["threshold", "confidence", "variation_context", "supporting_frames", "fallback"].includes(key) &&
+      typeof value !== "object",
+  );
+  const [metric, value] = entries[0] || ["metric", "n/a"];
+  return `${label(metric)} ${value} vs ${issue.evidence?.threshold ?? "n/a"}`;
+}
+
+function IssueTimeline({ issues }) {
+  return h(
+    "section",
+    { className: "issue-timeline", "aria-label": "Issue timeline" },
+    h(
+      "div",
+      { className: "timeline-head" },
+      h("h3", null, "Issue timeline"),
+      h("span", null, issues.length ? `${issues.length} interval${issues.length === 1 ? "" : "s"}` : "clear"),
+    ),
+    issues.length
+      ? h(
+          "div",
+          { className: "timeline-list" },
+          issues.map((issue, index) =>
+            h(
+              "article",
+              { className: "timeline-item", key: `${issue.rep_id}-${issue.issue}-${index}` },
+              h(
+                "div",
+                { className: "timeline-main" },
+                h("strong", null, label(issue.issue)),
+                h("span", null, `Rep ${issue.rep_id} · ${issue.start_sec.toFixed(2)}s-${issue.end_sec.toFixed(2)}s`),
+              ),
+              h(
+                "div",
+                { className: "timeline-meta" },
+                h("span", null, `severity ${Math.round(issue.severity * 100)}%`),
+                h("span", null, issueEvidence(issue)),
+                h("span", null, issue.affected_joints.map(label).join(", ")),
+              ),
+            ),
+          ),
+        )
+      : h("p", null, "No sustained threshold violations were found."),
+  );
+}
+
 function NoteList({ title, items }) {
   return h(
     "article",

web/styles.css

@@ -373,7 +373,7 @@ input[type="text"]:focus,
 
 .stat-grid {
   display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
+  grid-template-columns: repeat(5, minmax(0, 1fr));
   gap: 10px;
   margin: 16px 0;
 }
@@ -432,6 +432,78 @@ input[type="text"]:focus,
   margin-top: 14px;
 }
 
+.issue-timeline {
+  margin-top: 14px;
+  border: 1px solid rgba(37, 44, 31, 0.12);
+  border-radius: 8px;
+  padding: 14px;
+  background: rgba(255, 253, 247, 0.62);
+}
+
+.timeline-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+.timeline-head h3 {
+  margin: 0;
+  color: var(--forest);
+  font-size: 0.98rem;
+}
+
+.timeline-head span,
+.timeline-meta span {
+  color: var(--muted);
+  font-size: 0.82rem;
+}
+
+.timeline-list {
+  display: grid;
+  gap: 8px;
+}
+
+.timeline-item {
+  display: grid;
+  grid-template-columns: minmax(150px, 0.36fr) minmax(0, 0.64fr);
+  gap: 12px;
+  border-left: 3px solid var(--clay);
+  border-radius: 8px;
+  padding: 10px 12px;
+  background: rgba(255, 249, 236, 0.72);
+}
+
+.timeline-main strong,
+.timeline-main span {
+  display: block;
+}
+
+.timeline-main strong {
+  color: var(--forest-deep);
+  font-size: 0.95rem;
+}
+
+.timeline-main span {
+  margin-top: 3px;
+  color: var(--muted);
+  font-size: 0.84rem;
+}
+
+.timeline-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  align-items: center;
+}
+
+.timeline-meta span {
+  border-radius: 999px;
+  padding: 6px 8px;
+  background: rgba(33, 79, 58, 0.08);
+}
+
 .quality-list span {
   border-radius: 999px;
   padding: 7px 10px;
@@ -532,4 +604,9 @@ input[type="text"]:focus,
   .panel-head {
     display: grid;
   }
+
+  .timeline-item,
+  .timeline-head {
+    display: grid;
+  }
 }