Major code cleanup: Remove unused metrics and consolidate model files

- Remove unused DTL metrics (keep only 4): shoulder tilt/swing plane, back tilt, knee flexion, head drop/rise
- Remove unused front-facing metrics (keep only 4): shoulder tilt @ impact, hip turn @ impact, hip sway @ top, wrist hinge @ top
- Remove 12 unused grading functions from streamlit_app.py
- Consolidate model files: merge math_utils into segmentation, prompts into llm_analyzer
- Remove deprecated functions: early extension, shaft angle, diagnostic overlay
- Clean up swing_analyzer.py to keep only essential functions
- Update imports and fix circular dependencies
- All functionality preserved for 8 core metrics

app/main.py

@@ -16,7 +16,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from utils.video_downloader import download_youtube_video, cleanup_video_file
 from utils.video_processor import process_video
 from models.pose_estimator import analyze_pose
-from models.swing_analyzer import segment_swing, analyze_trajectory
+from models.swing_analyzer import segment_swing_pose_based, analyze_trajectory
 from models.llm_analyzer import generate_swing_analysis
 from utils.visualizer import create_annotated_video
 
@@ -55,7 +55,7 @@ def main():
 
         # Step 6: Segment swing into phases
         print("\nSegmenting swing phases...")
-        swing_phases = segment_swing(pose_data,
+        swing_phases = segment_swing_pose_based(pose_data,
                                      detections,
                                      sample_rate=sample_rate,
                                      fps=30.0)

app/models/coach_prompt.md

@@ -1,216 +0,0 @@
-# Golf Swing Analysis
-
-## NEW METRICS CALIBRATION
-Use these new professional/amateur benchmarks for scoring. These represent updated golf swing mechanics based on the latest analysis:
-
-### **NEW FRONT-FACING METRICS:**
-
-**Shoulder Tilt @ Impact:**
-- Professional = 39°
-- 30 Handicap = 27°
-
-# Hip Turn @ Impact metric removed from DTL analysis
-
-**Hip Sway @ Top:**
-- Professional = 3.9" towards target
-- 30 Handicap = 2.5" towards target
-
-**Hip Sway @ Impact:**
-- To be measured and calibrated
-
-**Wrist Hinge @ Top:**
-- To be measured and calibrated
-
-### **NEW DTL METRICS:**
-
-**Shoulder Tilt/Swing Plane Angle @ Top:**
-- Professional = 36° (Iron avg: 34.3°, Driver avg: 30.5°)
-- 30 Handicap = 29°
-
-**Back Tilt (°):**
-- Professional = 31° (Iron avg: 30.8°, Driver avg: 32.3°)
-
-**Knee Flexion (°):**
-- Professional = 22° (Iron avg: 21.6°, Driver avg: 27.2°)
-
-**Head Drop/Rise @ Top (%):**
-- Professional = 0-5% drop (Iron: 0-7.6% range, Driver: 4.6-5.5% drop)
-
-# Hip Turn @ Impact metric removed from DTL analysis
-
-### **KEY AMATEUR SWING PROBLEMS FOR EVALUATION REFERENCE:**
-**Common Issues in 40-50% Level Swings:**
-- **Standing up during impact** (loss of posture maintenance)
-- **Severe head movement** (stability and consistency issues)
-- **Wrist casting** (early release, loss of lag)
-- **Hands leading downswing instead of hips** (poor kinematic sequence)
-- **Excessive knee flexion** (39.4° male, 33.8° female vs 16-28° professional range)
-- **Back tilt out of professional range** (39.0° vs 25-35° professional range)
-- **Inconsistent swing path and ball contact**
-- **Equipment issues** (wrong club length affecting stance and mechanics)
-- **Bent arms in follow through** (loss of extension and power)
-- **Hands continuing at top when they should stop** (over-swing, timing issues)
-
-**Evaluation Emphasis Points:**
-- Knee flexion >35° should be flagged as problematic for power and stability
-- Back tilt >35° indicates setup issues that affect entire swing
-- Wrist casting patterns significantly impact ball striking and distance
-- Head movement and standing up during impact are major consistency killers
-- Poor kinematic sequence (hands before hips) reduces power generation
-
-### **COMPREHENSIVE AMATEUR SWING ISSUES REFERENCE:**
-
-**Swing Mechanics & Tempo Issues:**
-1. **Over-Swinging:**
-   - Swinging with excessive force leads to loss of control and poor tempo
-   - Makes it harder to stay connected and achieve consistent contact
-   - Often results in loss of balance and timing
-
-2. **Over-the-Top Swing Path:**
-   - Golfer starts downswing from the outside, causing club to swing across the ball
-   - Results in pulls, slices, and inconsistent ball striking
-   - Common in amateur swings due to improper sequencing
-
-3. **Lack of Weight Transfer:**
-   - Not shifting weight from back foot to lead foot during downswing
-   - Reduces power generation and can cause inconsistent contact
-   - Often combined with poor hip rotation
-
-4. **Poor Rotation & Early Extension:**
-   - Lack of proper body rotation through the swing
-   - Hips moving towards the ball during downswing (early extension)
-   - Leads to loss of posture and inconsistent strike patterns
-
-5. **"Lifting" the Ball:**
-   - Attempting to lift the ball into the air rather than hitting down and through
-   - Common counter-intuitive mistake that leads to poor contact
-   - Results in topped shots and inconsistent ball flight
-
-6. **Wrist Casting:**
-   - Early release of wrist hinge, reducing power and distance
-   - Loss of lag angle that professionals maintain
-   - Significantly impacts ball compression and distance
-
-7. **Moving Head/Standing Up in Swing:**
-   - Loss of spine angle and posture during swing
-   - Creates inconsistent contact points
-   - Major factor in amateur swing inconsistency
-
-**Impact on Evaluation:**
-- Look for combinations of these issues in amateur swings
-- Multiple issues often compound each other (e.g., over-swinging + early extension)
-- Early extension and standing up are visible in DTL analysis as posture loss
-- Weight transfer issues may manifest as poor hip rotation or kinematic sequence problems
-- Over-the-top swing path affects shaft plane and swing consistency
-
-### **UPDATED METRICS CALIBRATION:**
-**New Core Biomechanical Metrics:**
-- **Shoulder Tilt @ Impact**: Professional = 39°, 30 Handicap = 27°
-- **Hip Sway @ Top**: Professional = 3.9" towards target, 30 Handicap = 2.5" towards target
-- **Shoulder Tilt/Swing Plane @ Top**: Professional = 36°, 30 Handicap = 29°
-- **Back Tilt @ Top**: Professional = 31°
-- **Knee Flexion @ Top**: Professional = 22°
-- **Head Drop/Rise @ Top**: Professional = 0-5% drop
-
-## CURRENT SWING ANALYSIS
-
-### Swing Phase Breakdown
-{swing_phase_data}
-
-### DTL-Reliable Core Metrics
-{core_mechanics}
-
-## ANALYSIS INSTRUCTIONS
-
-**GOLF SWING ANALYSIS FORMAT**
-Use the benchmarks above to guide your evaluation. Follow this exact format:
-
-**OVERALL_SUMMARY:** [1-2 sentences maximum providing a concise evaluation of the swing's overall quality and main strengths/areas for improvement]
-
-**PERFORMANCE_CLASSIFICATION:** [XX%]
-(XX = number from 10% to 100%)
-
-**Metric Evaluations**
-
-For each of the new metrics below, write exactly 3 sentences evaluating the metric:
-1. First sentence: State if it's good, bad, or needs improvement compared to professional standards
-2. Second sentence: Compare the specific value to professional/amateur ranges  
-3. Third sentence: Brief explanation of impact on swing performance
-
-**FRONT-FACING METRICS:**
-
-**1. Shoulder Tilt @ Impact Evaluation:**
-[3 sentences about shoulder tilt angle at impact - professional = 39°, 30 handicap = 27°]
-
-# Hip Turn @ Impact evaluation removed from DTL analysis
-
-**3. Hip Sway @ Top Evaluation:**
-[3 sentences about hip sway at top - professional = 3.9" towards target, 30 handicap = 2.5" towards target]
-
-**4. Hip Sway @ Impact Evaluation:**
-[3 sentences about hip sway at impact]
-
-**5. Wrist Hinge @ Top Evaluation:**
-[3 sentences about wrist hinge angle at top of backswing]
-
-**DTL METRICS:**
-
-**1. Shoulder Tilt/Swing Plane @ Top Evaluation:**
-[3 sentences about shoulder tilt/swing plane angle at top - professional = 36°, 30 handicap = 29°]
-
-**2. Back Tilt @ Top Evaluation:**
-[3 sentences about spine forward tilt angle at top of backswing - professional = 31°]
-
-**3. Knee Flexion @ Top Evaluation:**
-[3 sentences about knee flexion angle at top of backswing - professional = 22°]
-
-**4. Head Drop/Rise @ Top Evaluation:**
-[3 sentences about head movement percentage at top of backswing - professional = 0-5% drop]
-
-# Hip Turn @ Impact evaluation removed from DTL analysis
-
-**SCORING GUIDELINES (Use to help decide % score)**
-
-**FRONT-FACING METRICS:**
-
-| Metric | Professional Standard | 30 Handicap Standard | Note |
-|--------|----------------------|---------------------|------|
-| Shoulder Tilt @ Impact | 39° | 27° | Shoulder tilt angle at impact |
-# Hip Turn @ Impact metric removed from DTL analysis
-| Hip Sway @ Top | 3.9" towards target | 2.5" towards target | Hip lateral movement at top |
-| Hip Sway @ Impact | To be calibrated | To be calibrated | Hip lateral movement at impact |
-| Wrist Hinge @ Top | To be calibrated | To be calibrated | Wrist angle at top of backswing |
-
-**DTL METRICS:**
-
-| Metric | Professional Standard | 30 Handicap Standard | Note |
-|--------|----------------------|---------------------|------|
-| Shoulder Tilt/Swing Plane @ Top | 36° | 29° | Shoulder tilt/swing plane angle at top |
-| Back Tilt @ Top | 31° | To be calibrated | Forward spine tilt at top of backswing |
-| Knee Flexion @ Top | 22° | To be calibrated | Knee flexion angle at top of backswing |
-| Head Drop/Rise @ Top | 0-5% drop | To be calibrated | Head movement percentage at top |
-# Hip Turn @ Impact metric removed from DTL analysis
-
-**Classification Bands:**
-- **90–100%**: Tour-level
-- **80–89%**: Advanced amateur
-- **70–79%**: Skilled
-- **60–69%**: Intermediate
-- **50–59%**: Developing
-- **40–49%**: Beginner
-- **10–39%**: Novice
-
-**STYLE & FORMATTING RULES:**
-- Use these headers: OVERALL_SUMMARY, PERFORMANCE_CLASSIFICATION, Metric Evaluations, and the numbered metric sections for both Front-Facing and DTL metrics
-- No emojis anywhere in the response  
-- Write 1-2 sentences maximum for the overall summary - be concise and highlight main strengths/improvement areas
-- Write exactly 3 sentences for each metric evaluation
-- Tie all evaluations to the new professional/amateur standards and ranges provided
-- Use a positive, coaching tone throughout
-- Avoid saying "perfect" — say "strong" or "meets standards"
-- Focus on biomechanics and compare actual values to the new professional ranges (39° shoulder tilt, etc.) - Hip turn removed from DTL metrics
-- Consider common amateur swing issues when evaluating: over-swinging, over-the-top path, lack of weight transfer, early extension, lifting the ball, wrist casting, head movement/standing up
-- Look for combinations of swing problems that often compound each other in amateur golfers
-- Use the new calibration values: Professional = 39° shoulder tilt @ impact, 36° shoulder tilt @ top, 31° back tilt @ top, 22° knee flexion @ top, 0-5% head drop @ top vs 30 Handicap = 27° shoulder tilt @ impact, 29° shoulder tilt @ top
-
-

app/models/front_facing_metrics.py

@@ -10,6 +10,8 @@ import numpy as np
 import cv2
 from typing import Dict, List, Tuple, Optional, Union
 
+# Note: grade_hip_turn function moved to streamlit_app.py to keep all grading logic in one place
+
 # Landmark indices
 L_HIP, R_HIP = 23, 24
 L_SHO, R_SHO = 11, 12
@@ -422,8 +424,15 @@ def _address_pelvis_rel(world_landmarks, setup_frames, target_hat):
                 vals.append(rel)
     return float(np.median(vals)) if vals else None
 
+
 def grade_hip_turn(delta_deg: float, club: str = "iron") -> dict:
-    """Grade hip turn with club-aware bands and actionable tips"""
+    """
+    Grade hip turn with club-aware bands and actionable tips
+    
+    NOTE: This function has been moved to streamlit_app.py to consolidate all grading logic.
+    This copy remains here temporarily to avoid circular imports.
+    TODO: Remove this function once a better import structure is established.
+    """
     c = club.lower()
     bands = {
         "driver": {"excellent": (38,48), "good_low": (32,38), "good_high": (48,52)},
@@ -445,6 +454,7 @@ def grade_hip_turn(delta_deg: float, club: str = "iron") -> dict:
         )
     return {"label": label, "color": color, "tip": tip}
 
+
 def _target_hat_from_toes_world(world_landmarks, setup_frames, handedness='right'):
     """Build stable target axis from toe line at address with outlier trimming"""
     LEFT_TOE, RIGHT_TOE = 31, 32

app/models/llm_analyzer.py

@@ -11,9 +11,7 @@ import re
 from typing import Dict, Any, Optional
 from .metrics_calculator import (
     calculate_back_tilt_degree, calculate_knee_bend_degree, 
-    calculate_hip_depth_early_extension,
     calculate_shoulder_tilt_swing_plane_at_top,
-    compute_dtl_five_metrics,
     compute_dtl_three
 )
 from .front_facing_metrics import compute_front_facing_metrics
@@ -24,9 +22,9 @@ try:
         get_shoulder_tilt_swing_plane_grading,
         get_back_tilt_grading,
         get_knee_flexion_grading,
-        get_hip_depth_grading,
-        # get_hip_turn_impact_grading, # Removed hip turn metric
+        get_head_drop_grading,
         get_shoulder_tilt_impact_grading,
+        get_hip_turn_impact_grading,
         get_hip_sway_grading,
         get_wrist_hinge_grading
     )
@@ -447,21 +445,74 @@ def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None, fps=30.0
 
 def create_llm_prompt(analysis_data):
     """Create LLM prompt from swing analysis data"""
-    try:
-        with open('models/coach_prompt.md', 'r') as f:
-            prompt_template = f.read()
-    except FileNotFoundError:
-        # Fallback basic prompt
-        prompt_template = """
-        Analyze this golf swing based on the provided metrics. Give specific feedback on:
-        1. Back tilt at setup
-        2. Knee flexion 
-        3. Hip depth and early extension
-        4. Shaft angle at address
-        5. Head stability
-        
-        Provide a professional assessment with actionable advice.
-        """
+    prompt_template = """# Golf Swing Analysis
+
+## NEW METRICS CALIBRATION
+Use these new professional/amateur benchmarks for scoring. These represent updated golf swing mechanics based on the latest analysis:
+
+### **NEW FRONT-FACING METRICS:**
+
+**Shoulder Tilt @ Impact:**
+- Professional = 39°
+- 30 Handicap = 27°
+
+**Hip Sway @ Top:**
+- Professional = 3.9" towards target
+- 30 Handicap = 2.5" towards target
+
+**Wrist Hinge @ Top:**
+- To be measured and calibrated
+
+### **NEW DTL METRICS:**
+
+**Shoulder Tilt/Swing Plane Angle @ Top:**
+- Professional = 36° (Iron avg: 34.3°, Driver avg: 30.5°)
+- 30 Handicap = 29°
+
+**Back Tilt (°):**
+- Professional = 31° (Iron avg: 30.8°, Driver avg: 32.3°)
+
+**Knee Flexion (°):**
+- Professional = 22° (Iron avg: 21.6°, Driver avg: 27.2°)
+
+**Head Drop/Rise @ Top (%):**
+- Professional = 0-5% drop (Iron: 0-7.6% range, Driver: 4.6-5.5% drop)
+
+### **ANALYSIS INSTRUCTIONS**
+
+**GOLF SWING ANALYSIS FORMAT**
+Use the benchmarks above to guide your evaluation. Follow this exact format:
+
+**OVERALL_SUMMARY:** [1-2 sentences maximum providing a concise evaluation of the swing's overall quality and main strengths/areas for improvement]
+
+**PERFORMANCE_CLASSIFICATION:** [XX%]
+(XX = number from 10% to 100%)
+
+**Metric Evaluations**
+
+For each metric below, write exactly 3 sentences evaluating the metric:
+1. First sentence: State if it's good, bad, or needs improvement compared to professional standards
+2. Second sentence: Compare the specific value to professional/amateur ranges  
+3. Third sentence: Brief explanation of impact on swing performance
+
+**Classification Bands:**
+- **90–100%**: Tour-level
+- **80–89%**: Advanced amateur
+- **70–79%**: Skilled
+- **60–69%**: Intermediate
+- **50–59%**: Developing
+- **40–49%**: Beginner
+- **10–39%**: Novice
+
+**STYLE & FORMATTING RULES:**
+- Use these headers: OVERALL_SUMMARY, PERFORMANCE_CLASSIFICATION, Metric Evaluations
+- No emojis anywhere in the response  
+- Write 1-2 sentences maximum for the overall summary
+- Write exactly 3 sentences for each metric evaluation
+- Use a positive, coaching tone throughout
+- Focus on biomechanics and compare actual values to the professional ranges provided
+
+"""
     
     # Format metrics for prompt
     core_metrics = analysis_data.get('core_metrics', {})

app/models/math_utils.py

@@ -1,89 +0,0 @@
-"""
-Simplified math utilities for DTL golf swing analysis
-Focused on the core metrics only
-"""
-import math
-import numpy as np
-
-# Core utility functions for DTL analysis
-def _angle_deg_2d(ax, ay, bx, by):
-    """angle of vector a->b vs +X axis, in degrees"""
-    return math.degrees(math.atan2(by - ay, bx - ax))
-
-def line_angle(points_left, points_right):
-    """points_* are (x,y) tuples; returns angle of L->R line in degrees"""
-    (lx, ly), (rx, ry) = points_left, points_right
-    return _angle_deg_2d(lx, ly, rx, ry)
-
-def rel_rotation_deg(angle_now, angle_addr):
-    """normalize relative rotation to [-180,180]"""
-    d = angle_now - angle_addr
-    while d > 180: d -= 360
-    while d < -180: d += 360
-    return d
-
-def unit_vector(vector):
-    """Convert vector to unit vector"""
-    norm = np.linalg.norm(vector)
-    if norm == 0:
-        return vector
-    return vector / norm
-
-def signed_angle_2d(vec1, vec2):
-    """Calculate signed angle between two 2D vectors in radians"""
-    cross_product = vec1[0] * vec2[1] - vec1[1] * vec2[0]
-    dot_product = np.dot(vec1, vec2)
-    return math.atan2(cross_product, dot_product)
-
-# Mediapipe landmark indices
-MP_SHOULDERS = (11, 12)
-MP_HIPS = (23, 24)
-
-def vis_ok(kp, idxs, thr=0.4):
-    """Check if keypoints at given indices have sufficient visibility"""
-    if kp is None or len(kp) <= max(idxs): 
-        return False
-    return all(kp[i][2] >= thr for i in idxs)
-
-def seg_angle(p1, p2):
-    """Angle (deg) of segment p1->p2 vs +x axis"""
-    return math.degrees(math.atan2(p2[1]-p1[1], p2[0]-p1[0]))
-
-def ang_diff(a, b):
-    """Signed difference in [-180, 180]"""
-    d = (a - b + 180) % 360 - 180
-    return d
-
-
-def _dt_and_fps(frame_timestamps_ms, frames: int, total_ms: float):
-    """Calculate time delta and FPS from frame data"""
-    if frame_timestamps_ms and len(frame_timestamps_ms) >= 2:
-        dt = (frame_timestamps_ms[-1] - frame_timestamps_ms[0]) / max(len(frame_timestamps_ms) - 1, 1) / 1000.0
-    else:
-        dt = (total_ms / 1000.0) / max(frames, 1)
-    return dt, 1.0 / max(dt, 1e-6)
-
-
-def detect_arm_velocity_zero_crossing(pose_data, frames):
-    """Simple fallback for top detection - now handled in swing_analyzer.py"""
-    if not frames:
-        return 0
-    return frames[len(frames)//3]  # Simple fallback
-
-
-# Legacy functions - simplified versions for compatibility
-def validate_metric_sanity(metric_name, value, player_handedness='right'):
-    """Simple validation - now handled in swing_analyzer.py"""
-    return True, value
-
-def get_target_line_angle(pose_data, address_frame_idx):
-    """Simple target line - now handled in swing_analyzer.py"""
-    return 0.0
-
-def calculate_thorax_rotation(shoulder_keypoints, reference_angle=0.0, target_line_angle=0.0, reference_keypoints=None):
-    """Simple thorax rotation - now handled in swing_analyzer.py"""
-    return 45.0  # Default
-
-def calculate_pelvis_rotation(hip_keypoints, reference_angle=0.0, player_handedness='right', target_line_angle=0.0):
-    """Simple pelvis rotation - now handled in swing_analyzer.py"""
-    return 30.0  # Default

app/models/metrics_calculator.py

@@ -125,13 +125,7 @@ def wrap180_deg(a):
     return a
 
 
-# Safe no-op to avoid NameError in validation/overlay paths
-def calculate_shaft_angle_at_address(*args, **kwargs):
-    """Safe stub for removed shaft angle function to prevent NameError"""
-    return None
-
-
-# Note: calculate_metric_confidence removed - not used by the 5 DTL metrics
+# Note: calculate_metric_confidence removed - not used by the DTL metrics
 # This function was defined but never called by the displayed metrics
 
 
@@ -790,89 +784,7 @@ def calculate_smoothed_hip_width(pose_data, swing_phases, window_size=5):
 
 
 # Hip depth/early extension metric removed per user request
-def early_extension_pct(pose_data, swing_phases, frame_w, frame_h, camera_side="trail"):
-    """Calculate early extension percentage using posterior hip method with unit conversion
-    
-    Args:
-        pose_data (dict): Dictionary mapping frame indices to pose keypoints
-        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
-        frame_w (int): Frame width in pixels
-        frame_h (int): Frame height in pixels
-        camera_side (str): "trail" or "lead" - which side camera is on
-        
-    Returns:
-        float: Early extension percentage (0-100%)
-    """
-    setup_frames = swing_phases.get("setup", [])
-    impact_frames = swing_phases.get("impact", [])
-    
-    if not setup_frames or not impact_frames:
-        return None
-    
-    address_idx = setup_frames[0]
-    impact_idx = impact_frames[0]
-    
-    if (address_idx not in pose_data or impact_idx not in pose_data or 
-        pose_data[address_idx] is None or pose_data[impact_idx] is None):
-        return None
-    
-    addr_kp = pose_data[address_idx]
-    impact_kp = pose_data[impact_idx]
-    
-    if len(addr_kp) < 25 or len(impact_kp) < 25:
-        return None
-    
-    # Ensure pixels
-    addr_kp = to_pixels_if_needed(addr_kp, frame_w, frame_h)
-    impact_kp = to_pixels_if_needed(impact_kp, frame_w, frame_h)
-    
-    # Check hip keypoint validity - be more lenient
-    if (not addr_kp[23] or not addr_kp[24] or not impact_kp[23] or not impact_kp[24] or
-        len(addr_kp[23]) < 2 or len(addr_kp[24]) < 2 or
-        len(impact_kp[23]) < 2 or len(impact_kp[24]) < 2):
-        return None
-    
-    # Posterior-most hip x at address/impact
-    hips_addr = [addr_kp[23][0], addr_kp[24][0]]
-    hips_impact = [impact_kp[23][0], impact_kp[24][0]]
-    
-    if camera_side == "trail":
-        butt_addr = max(hips_addr)
-        butt_impact = max(hips_impact)
-    else:
-        butt_addr = min(hips_addr)
-        butt_impact = min(hips_impact)
-    
-    # Hip width at address (pixels) - more lenient threshold
-    hip_width = abs(hips_addr[1] - hips_addr[0])
-    if hip_width < 5:  # Very lenient sanity check
-        return None
-    
-    # Hip depth/early extension metric removed per user request
-    return None
-
-
-def calculate_hip_depth_early_extension(pose_data, swing_phases, frame_w=None, frame_h=None):
-    """Calculate hip depth/early extension - DEPRECATED, use early_extension_pct instead
-    
-    This function is kept for backward compatibility but will use the new implementation.
-    """
-    # Try to get frame dimensions from first available frame if not provided
-    if frame_w is None or frame_h is None:
-        for frame_data in pose_data.values():
-            if frame_data:
-                # Default frame size - this is a fallback and may not be accurate
-                frame_w = frame_w or 1920
-                frame_h = frame_h or 1080
-                break
-    
-    # Hip depth/early extension metric removed per user request
-    return None
-
-
-# Note: Shaft angle functions removed - not part of the 5 core DTL metrics
-# calculate_shaft_angle_at_address, detect_shaft_line_hough, estimate_shaft_angle_fallback
-# These functions were not in the target 5 DTL metrics and can be moved to a separate FO module if needed later
+# Note: Hip depth/early extension and shaft angle functions removed - not part of the 4 core DTL metrics
 
 
 def validate_angle_calculations(pose_data, swing_phases, frames=None):
@@ -1534,153 +1446,4 @@ def compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames=None, ca
     return metrics
 
 
-def compute_dtl_five_metrics(pose_data, swing_phases, frames=None, frame_w=None, frame_h=None):
-    """DEPRECATED - use compute_dtl_three instead (hip depth and hip turn removed)
-    
-    This function is kept for backward compatibility.
-    """
-    # Try to get frame dimensions if not provided
-    if frame_w is None or frame_h is None:
-        frame_w = frame_w or 1920
-        frame_h = frame_h or 1080
-    
-    result = compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames)
-    
-    if result is None:
-        return None
-    
-    # Apply clamp_or_none for backward compatibility
-    return {
-        "shoulder_plane_top_deg": clamp_or_none(result.get("shoulder_plane_top_deg"), 20, 50),
-        "back_tilt_setup_deg": clamp_or_none(result.get("back_tilt_setup_deg"), 25, 50),
-        "knee_flexion_deg": clamp_or_none(result.get("knee_flexion_deg"), 15, 45),
-        # Hip depth and hip turn metrics removed per user request
-    }
-
 
-def generate_diagnostic_overlay(pose_data, swing_phases, frames=None):
-    """Generate diagnostic overlay information for one frame at address
-    
-    Returns the exact format requested:
-    addr_idx=123
-    θ_spine= -56.7°, θ_ground= +1.4°, θ_rel_horiz= -58.1°, back_tilt= 31.9°
-    θ_shaft= -57.9°, shaft_angle= 59.3°, ROI_ok=True, hough_lines=7
-    
-    Args:
-        pose_data (dict): Dictionary mapping frame indices to pose keypoints
-        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
-        frames (list, optional): Video frames for analysis
-        
-    Returns:
-        dict: Diagnostic overlay data
-    """
-    try:
-        # Find stable address frame
-        address_idx = find_stable_address_frame(pose_data, swing_phases)
-        if address_idx is None:
-            return None
-        
-        if address_idx not in pose_data or pose_data[address_idx] is None:
-            return None
-        
-        kp = pose_data[address_idx]
-        if len(kp) < 25:
-            return None
-        
-        # Calculate spine vector components
-        shoulder_mid_x = (kp[11][0] + kp[12][0]) / 2
-        shoulder_mid_y = (kp[11][1] + kp[12][1]) / 2
-        hip_mid_x = (kp[23][0] + kp[24][0]) / 2
-        hip_mid_y = (kp[23][1] + kp[24][1]) / 2
-        
-        dx_spine = shoulder_mid_x - hip_mid_x
-        dy_spine = shoulder_mid_y - hip_mid_y
-        theta_spine = math.degrees(math.atan2(dy_spine, dx_spine))
-        
-        # Get ground angle
-        ground_angle = detect_ground_line_angle(pose_data, swing_phases, frames)
-        theta_ground = math.degrees(ground_angle)
-        theta_ground_wrapped = wrap180_deg(theta_ground)
-        
-        # Calculate relative angles
-        theta_rel_horiz = wrap180_deg(theta_spine - theta_ground)
-        back_tilt = 90.0 - abs(theta_rel_horiz)
-        
-        # Calculate shaft angle
-        shaft_angle = calculate_shaft_angle_at_address(pose_data, swing_phases, frames)
-        
-        # Get shaft angle details for diagnostics
-        theta_shaft = None
-        roi_ok = False
-        hough_lines = 0
-        
-        if frames is not None and address_idx < len(frames):
-            # Get grip position
-            grip_pos = np.array(kp[16][:2])  # Right wrist
-            if len(kp) > 15 and kp[15][2] > 0.3:  # Left wrist
-                left_grip = np.array(kp[15][:2])
-                grip_pos = (grip_pos + left_grip) / 2
-            
-            # Try to detect shaft using Hough
-            try:
-                # Convert to grayscale
-                frame = frames[address_idx]
-                if len(frame.shape) == 3:
-                    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-                else:
-                    gray = frame
-                
-                height, width = gray.shape
-                grip_x, grip_y = int(grip_pos[0]), int(grip_pos[1])
-                
-                # Build ROI
-                x_min = max(0, grip_x - 60)
-                x_max = min(width, grip_x + 100)
-                y_min = max(0, grip_y - 60)
-                y_max = min(height, grip_y + 200)
-                
-                roi = gray[y_min:y_max, x_min:x_max]
-                if roi.size > 0:
-                    roi_ok = True
-                    
-                    # Apply edge detection
-                    edges = cv2.Canny(roi, 50, 150, apertureSize=3)
-                    
-                    # Detect lines using Hough transform
-                    lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=30)
-                    
-                    if lines is not None:
-                        hough_lines = len(lines)
-                        
-                        # Find shaft angle
-                        shaft_candidates = []
-                        for line in lines:
-                            rho, theta = line[0]
-                            angle_deg = math.degrees(theta)
-                            angle_wrapped = wrap180_deg(angle_deg)
-                            
-                            if 40 <= abs(angle_wrapped) <= 70:
-                                shaft_candidates.append(angle_wrapped)
-                        
-                        if shaft_candidates:
-                            theta_shaft = np.median(shaft_candidates)
-            except Exception:
-                pass
-        
-        # Format diagnostic output
-        diagnostic_data = {
-            'addr_idx': address_idx,
-            'theta_spine': round(theta_spine, 1),
-            'theta_ground': round(theta_ground_wrapped, 1),
-            'theta_rel_horiz': round(theta_rel_horiz, 1),
-            'back_tilt': round(back_tilt, 1) if back_tilt is not None else None,
-            'theta_shaft': round(theta_shaft, 1) if theta_shaft is not None else None,
-            'shaft_angle': round(shaft_angle, 1) if shaft_angle is not None else None,
-            'roi_ok': roi_ok,
-            'hough_lines': hough_lines
-        }
-        
-        return diagnostic_data
-        
-    except Exception as e:
-        return {'error': str(e)}

app/models/prompts.py

@@ -1,11 +0,0 @@
-"""
-Prompt templates for LLM analysis
-"""
-from pathlib import Path
-
-def load_coach_prompt():
-    """Load the coach prompt template from markdown file"""
-    prompt_file = Path(__file__).with_name("coach_prompt.md")
-    return prompt_file.read_text()
-
-COACH_PROMPT = load_coach_prompt()

app/models/segmentation.py

@@ -1,7 +1,21 @@
 """
 Simple swing segmentation with downswing re-gating
 """
-from .math_utils import _dt_and_fps, detect_arm_velocity_zero_crossing
+
+def _dt_and_fps(frame_timestamps_ms, frames: int, total_ms: float):
+    """Calculate time delta and FPS from frame data"""
+    if frame_timestamps_ms and len(frame_timestamps_ms) >= 2:
+        dt = (frame_timestamps_ms[-1] - frame_timestamps_ms[0]) / max(len(frame_timestamps_ms) - 1, 1) / 1000.0
+    else:
+        dt = (total_ms / 1000.0) / max(frames, 1)
+    return dt, 1.0 / max(dt, 1e-6)
+
+
+def detect_arm_velocity_zero_crossing(pose_data, frames):
+    """Simple fallback for top detection"""
+    if not frames:
+        return 0
+    return frames[len(frames)//3]  # Simple fallback
 
 def segment_swing(pose_data, detections=None, sample_rate=1, frame_shape=None, 
                  frame_timestamps_ms=None, total_ms=None, fps=30.0):

app/models/swing_analyzer.py

@@ -1,694 +1,22 @@
 """
-Simplified DTL golf swing analysis - all-in-one module
-Robust and simple analysis focused on what can be reliably measured from DTL view
+Simplified swing analyzer - contains only essential functions
+Cleaned up to remove unused functions per user requirements
 """
 
 import numpy as np
-import math
-import cv2
-from scipy.signal import savgol_filter
-from scipy.stats import zscore
-from sklearn.decomposition import PCA
-from .pose_estimator import calculate_joint_angles
-from .math_utils import _dt_and_fps, detect_arm_velocity_zero_crossing
 
-# One-liner frame mapping replacement
-def to_processed_idx(original_idx, sample_rate): return int(round(original_idx / max(1, sample_rate)))
-
-
-# ===== EVENT DETECTION =====
-
-def find_swing_events(pose_data, fps=30, ball_xy=None):
-    """Find key swing events: Top, Impact, Finish"""
-    frames = sorted([f for f in pose_data.keys() if pose_data[f] is not None])
-    
-    if len(frames) < 10:
-        return {
-            'top': frames[len(frames)//3] if frames else 0,
-            'impact': frames[len(frames)//2] if frames else 0,
-            'finish': frames[-1] if frames else 0
-        }
-    
-    # Extract hand Y coordinates
-    hands_y = []
-    valid_frames = []
-    
-    for frame_idx in frames:
-        kp = pose_data[frame_idx]
-        if kp and len(kp) > 16 and kp[16][2] > 0.4:  # Right wrist
-            hands_y.append(kp[16][1])
-            valid_frames.append(frame_idx)
-    
-    if len(hands_y) < 5:
-        return {
-            'top': frames[len(frames)//3],
-            'impact': frames[len(frames)//2], 
-            'finish': frames[-1]
-        }
-    
-    # Calculate hand velocity
-    hands_y = np.array(hands_y)
-    velocity = np.gradient(hands_y)
-    
-    # Find Top (velocity goes from positive to negative)
-    top_idx = None
-    for i in range(1, len(velocity)):
-        if velocity[i-1] > 0 and velocity[i] <= 0:
-            top_idx = i
-            break
-    
-    if top_idx is None:
-        top_idx = len(valid_frames) // 3
-    
-    # Find Impact (local minimum after top)
-    impact_idx = top_idx
-    if top_idx < len(hands_y) - 5:
-        search_range = hands_y[top_idx:top_idx+20] if top_idx+20 < len(hands_y) else hands_y[top_idx:]
-        local_min = np.argmin(search_range)
-        impact_idx = top_idx + local_min
-    
-    # Find Finish (end of sequence)
-    finish_idx = len(valid_frames) - 1
-    
-    return {
-        'top': valid_frames[min(top_idx, len(valid_frames)-1)],
-        'impact': valid_frames[min(impact_idx, len(valid_frames)-1)],
-        'finish': valid_frames[finish_idx]
-    }
-
-
-# ===== CORE METRICS =====
-
-def calculate_tempo_ratio(top_frame, impact_frame, address_frame=0):
-    """Calculate tempo ratio (backswing time / downswing time)"""
-    if top_frame <= address_frame or impact_frame <= top_frame:
-        return None
-    
-    backswing_frames = top_frame - address_frame
-    downswing_frames = impact_frame - top_frame
-    
-    if downswing_frames == 0:
-        return None
-    
-    return backswing_frames / downswing_frames
-
-
-def calculate_shaft_angle_at_top(pose_data, top_frame, target_line_vec=None):
-    """Calculate shaft angle at top using club vector (hand→clubhead) vs target line"""
-    if top_frame not in pose_data:
-        return None
-    
-    kp = pose_data[top_frame]
-    # Check club visibility: shoulder, elbow, wrist (relaxed thresholds)
-    if not kp or len(kp) <= 16 or kp[16][2] < 0.3 or kp[14][2] < 0.3 or kp[12][2] < 0.3:
-        return None
-    
-    # Build target line from early takeaway path if not provided
-    if target_line_vec is None:
-        target_line_vec = estimate_target_line_from_takeaway(pose_data, top_frame)
-        if target_line_vec is None:
-            # Fallback to horizontal target line
-            target_line_vec = np.array([1.0, 0.0])
-    
-    # Get hand center position
-    wrist_pos = np.array(kp[16][:2])     # Right wrist
-    elbow_pos = np.array(kp[14][:2])     # Right elbow
-    
-    # Approximate clubhead position using club length extension
-    # Extend from hand along forearm direction by typical club length
-    forearm_vec = wrist_pos - elbow_pos
-    forearm_length = np.linalg.norm(forearm_vec)
-    
-    if forearm_length < 10:  # Too short to be reliable
-        return None
-    
-    # Normalize forearm vector and extend by club length (~110% of forearm for typical club)
-    forearm_unit = forearm_vec / forearm_length
-    club_length = forearm_length * 1.1  # Approximate club length
-    clubhead_pos = wrist_pos + forearm_unit * club_length
-    
-    # Build TRUE club shaft vector from hand center to clubhead
-    shaft_vec = clubhead_pos - wrist_pos
-    shaft_length = np.linalg.norm(shaft_vec)
-    
-    if shaft_length < 10:  # Too short to be reliable
-        return None
-        
-    shaft_vec = shaft_vec / shaft_length
-    target_vec = np.array(target_line_vec) / np.linalg.norm(target_line_vec)
-    
-    # Calculate signed angle between club shaft and target line
-    cross_product = shaft_vec[0] * target_vec[1] - shaft_vec[1] * target_vec[0]
-    dot_product = np.dot(shaft_vec, target_vec)
-    angle_rad = math.atan2(cross_product, dot_product)
-    angle_deg = math.degrees(angle_rad)
-    
-    # Fold angle to -90°...+90° range (across-line is positive, laid-off is negative)
-    while angle_deg > 90:
-        angle_deg -= 180
-    while angle_deg < -90:
-        angle_deg += 180
-        
-    # Always return the calculated angle - no hiding based on magnitude
-    return angle_deg
-
-
-def estimate_target_line_from_takeaway(pose_data, top_frame, lookback_frames=10):
-    """Estimate target line from early takeaway hand/club movement using PCA"""
-    # Get frames from early in backswing
-    frames = sorted([f for f in pose_data.keys() if f <= top_frame])
-    if len(frames) < 5:
-        return None
-        
-    takeaway_frames = frames[:min(lookback_frames, len(frames)//2)]
-    hand_positions = []
-    
-    for frame_idx in takeaway_frames:
-        kp = pose_data[frame_idx]
-        if kp and len(kp) > 16 and kp[16][2] > 0.3:  # Right wrist (relaxed)
-            hand_positions.append(kp[16][:2])
-    
-    if len(hand_positions) < 3:
-        return None
-        
-    # Use PCA to find dominant direction of hand movement
-    positions = np.array(hand_positions)
-    if len(positions) < 2:
-        return None
-        
-    # Center the data
-    centered = positions - np.mean(positions, axis=0)
-    
-    # Simple PCA: find direction of maximum variance
-    cov_matrix = np.cov(centered.T)
-    eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)
-    
-    # Principal component (direction of max variance)
-    principal_direction = eigenvectors[:, np.argmax(eigenvalues)]
-    
-    return principal_direction
-
-
-def calculate_head_sway(pose_data, fallback_shoulder_width=None, target_line_vec=None):
-    """Calculate head sway using head center, measuring perpendicular to target line"""
-    frames = sorted(pose_data.keys())
-    if len(frames) < 5:
-        return None, None
-    
-    # Calculate robust shoulder width from clean setup frames
-    shoulder_width = calculate_robust_shoulder_width(pose_data)
-    if shoulder_width is None:
-        if fallback_shoulder_width and fallback_shoulder_width > 10:
-            shoulder_width = fallback_shoulder_width
-        else:
-            return None, None
-    
-    # Get target line for perpendicular measurement
-    if target_line_vec is None:
-        # Estimate from early takeaway or use horizontal default
-        target_line_vec = estimate_target_line_from_takeaway(pose_data, frames[-1])
-        if target_line_vec is None:
-            target_line_vec = np.array([1.0, 0.0])  # Horizontal default
-    
-    # Normalize target line and get perpendicular vector
-    target_unit = np.array(target_line_vec) / np.linalg.norm(target_line_vec)
-    perp_unit = np.array([-target_unit[1], target_unit[0]])  # 90° rotation
-    
-    # Get head center positions with quality filtering
-    head_positions = []
-    valid_frames = []
-    
-    for frame_idx in frames:
-        kp = pose_data[frame_idx]
-        if kp and len(kp) > 7:  # Need multiple facial points
-            # Calculate head center from available facial landmarks
-            head_center = calculate_head_center(kp)
-            if head_center is not None:
-                head_positions.append(head_center)
-                valid_frames.append(frame_idx)
-    
-    if len(head_positions) < 3:
-        return None, None
-    
-    head_positions = np.array(head_positions)
-    
-    # Use median of first few frames as reference (more stable than first frame)
-    setup_positions = head_positions[:min(5, len(head_positions)//3)]
-    reference_pos = np.median(setup_positions, axis=0)
-    
-    # Calculate movement relative to reference
-    movements = head_positions - reference_pos
-    
-    # Project movements onto perpendicular-to-target axis (lateral sway)
-    lateral_movements = np.dot(movements, perp_unit)
-    # Project onto target line axis (forward/back movement)
-    sagittal_movements = np.dot(movements, target_unit)
-    
-    # Convert to percentage of shoulder width
-    lateral_sway = (lateral_movements / shoulder_width) * 100
-    sagittal_sway = (sagittal_movements / shoulder_width) * 100
-    
-    # Apply temporal smoothing to reduce noise
-    if len(lateral_sway) > 5:
-        lateral_sway = apply_temporal_smoothing(lateral_sway)
-        sagittal_sway = apply_temporal_smoothing(sagittal_sway)
-    
-    # Clamp extreme values that indicate scale failures (hide if >100%)
-    lateral_sway = np.clip(lateral_sway, -100, 100)
-    sagittal_sway = np.clip(sagittal_sway, -100, 100)
-    
-    return lateral_sway.tolist(), sagittal_sway.tolist()
-
-
-def calculate_head_center(kp):
-    """Calculate head center from available facial landmarks with fallback to nose"""
-    # Try to use multiple facial points for better head center
-    facial_points = []
-    
-    # Nose (0)
-    if len(kp) > 0 and kp[0][2] > 0.3:
-        facial_points.append(np.array(kp[0][:2]))
-    
-    # Eyes (1, 2) if available
-    if len(kp) > 2:
-        if kp[1][2] > 0.3:  # Left eye
-            facial_points.append(np.array(kp[1][:2]))
-        if kp[2][2] > 0.3:  # Right eye
-            facial_points.append(np.array(kp[2][:2]))
-    
-    # Ears (7, 8) if available
-    if len(kp) > 8:
-        if kp[7][2] > 0.3:  # Left ear
-            facial_points.append(np.array(kp[7][:2]))
-        if kp[8][2] > 0.3:  # Right ear
-            facial_points.append(np.array(kp[8][:2]))
-    
-    if len(facial_points) == 0:
-        return None
-    elif len(facial_points) == 1:
-        return facial_points[0]  # Just nose
-    else:
-        # Average of available facial landmarks
-        return np.mean(facial_points, axis=0)
 
-
-def calculate_robust_shoulder_width(pose_data, max_drift_pct=25):
-    """Calculate robust shoulder width from clean setup frames"""
-    frames = sorted(pose_data.keys())
-    setup_frames = frames[:min(10, len(frames)//3)]  # Use first third or 10 frames
-    
-    shoulder_widths = []
-    
-    for frame_idx in setup_frames:
-        kp = pose_data[frame_idx]
-        if (kp and len(kp) > 12 and 
-            kp[11][2] > 0.4 and kp[12][2] > 0.4):  # Relaxed confidence shoulders
-            
-            left_shoulder = np.array(kp[11][:2])
-            right_shoulder = np.array(kp[12][:2])
-            width = np.linalg.norm(right_shoulder - left_shoulder)
-            
-            if width > 10:  # Minimum plausible shoulder width in pixels
-                shoulder_widths.append(width)
-    
-    if len(shoulder_widths) < 2:
-        return None
-    
-    # Use median for robustness
-    median_width = np.median(shoulder_widths)
-    
-    # Filter out frames with excessive drift
-    stable_widths = []
-    for width in shoulder_widths:
-        drift_pct = abs(width - median_width) / median_width * 100
-        if drift_pct <= max_drift_pct:
-            stable_widths.append(width)
-    
-    if len(stable_widths) < 2:
-        return None
-        
-    return np.median(stable_widths)
-
-
-def apply_temporal_smoothing(signal, window_size=5):
-    """Apply simple moving average smoothing"""
-    if len(signal) < window_size:
-        return signal
-        
-    smoothed = np.convolve(signal, np.ones(window_size)/window_size, mode='same')
-    return smoothed
-
-
-def calculate_wrist_hinge_pattern(pose_data, events):
-    """Calculate wrist hinge pattern and detect early casting - requires two signals for red badge"""
-    frames = sorted(pose_data.keys())
-    wrist_angles = []
-    frame_indices = []
-    club_visibility_good = True
-    
-    for frame_idx in frames:
-        kp = pose_data[frame_idx]
-        if kp and len(kp) > 16:
-            shoulder = kp[12]  # Right shoulder
-            elbow = kp[14]     # Right elbow
-            wrist = kp[16]     # Right wrist
-            
-            # Check club tip visibility (stricter for red badge assessment)
-            if all(point[2] > 0.5 for point in [shoulder, elbow, wrist]):
-                # Calculate wrist hinge angle
-                forearm_vec = np.array([wrist[0] - elbow[0], wrist[1] - elbow[1]])
-                upper_arm_vec = np.array([elbow[0] - shoulder[0], elbow[1] - shoulder[1]])
-                
-                cos_angle = np.dot(forearm_vec, upper_arm_vec) / (
-                    np.linalg.norm(forearm_vec) * np.linalg.norm(upper_arm_vec)
-                )
-                cos_angle = np.clip(cos_angle, -1.0, 1.0)
-                angle = math.degrees(math.acos(cos_angle))
-                
-                wrist_angles.append(180 - angle)  # Hinge angle
-                frame_indices.append(frame_idx)
-            else:
-                # Club tip visibility compromised
-                if any(point[2] < 0.4 for point in [shoulder, elbow, wrist]):
-                    club_visibility_good = False
-    
-    if len(wrist_angles) < 3:
-        return {'pattern': 'insufficient_data', 'casting': False, 'confidence': 'low'}
-    
-    # Check for early casting - need TWO signals for red badge
-    top_frame = events.get('top', 0)
-    impact_frame = events.get('impact', 0)
-    
-    wrist_angle_trend_bad = False
-    shaft_lag_cue_bad = False  # Would need additional club head tracking
-    
-    if top_frame in frame_indices and impact_frame in frame_indices:
-        top_idx = frame_indices.index(top_frame)
-        top_angle = wrist_angles[top_idx]
-        
-        # Signal 1: Wrist angle trend analysis
-        early_release_count = 0
-        for i in range(top_idx, min(len(wrist_angles), frame_indices.index(impact_frame))):
-            if wrist_angles[i] < top_angle * 0.8:  # 20% decrease
-                early_release_count += 1
-        
-        if early_release_count >= 2:  # Multiple frames showing early release
-            wrist_angle_trend_bad = True
-    
-    # For DTL view, we can't reliably detect shaft-lag cue (need face-on or 3D)
-    # So be conservative: only amber unless we have clear evidence
-    
-    if wrist_angle_trend_bad and club_visibility_good:
-        # Only one reliable signal available (wrist angle trend)
-        # Per feedback: need TWO signals for red, so stay amber with caution
-        pattern = 'early_cast_caution'
-        casting = True
-        confidence = 'moderate'
-    elif wrist_angle_trend_bad:
-        pattern = 'early_cast_possible' 
-        casting = True
-        confidence = 'low'
-    else:
-        pattern = 'set_hold_release'
-        casting = False
-        confidence = 'good'
-    
-    return {
-        'pattern': pattern, 
-        'casting': casting,
-        'confidence': confidence,
-        'club_visibility': club_visibility_good
-    }
-
-
-# ===== QUALITY CONTROL =====
-
-def assess_quality_flags(pose_data, frames=None, frame_shape=None):
-    """Assess quality flags for hiding unstable metrics"""
-    flags = {
-        'blur_high': False,
-        'occlusion_high': False,
-        'subject_too_small': False,
-        'camera_roll_high': False,
-        'shoulder_drift_high': False,
-        'overall_stable': True
-    }
-    
-    # Calculate occlusion score
-    if pose_data:
-        total_visibility = 0
-        total_keypoints = 0
-        key_joints = [11, 12, 13, 14, 15, 16, 23, 24]  # Key joints
-        
-        for frame_idx, kp in pose_data.items():
-            if kp and len(kp) > max(key_joints):
-                for joint_idx in key_joints:
-                    total_visibility += kp[joint_idx][2]
-                    total_keypoints += 1
-        
-        avg_visibility = total_visibility / max(total_keypoints, 1)
-        flags['occlusion_high'] = avg_visibility < 0.6
-    
-    # Calculate shoulder width drift
-    widths = []
-    for frame_idx, kp in pose_data.items():
-        if kp and len(kp) > 12:
-            left_shoulder = kp[11]
-            right_shoulder = kp[12]
-            
-            if left_shoulder[2] > 0.5 and right_shoulder[2] > 0.5:
-                width = np.linalg.norm(
-                    np.array(left_shoulder[:2]) - np.array(right_shoulder[:2])
-                )
-                widths.append(width)
-    
-    if len(widths) > 2:
-        median_width = np.median(widths)
-        max_drift = max(abs(w - median_width) for w in widths)
-        drift_pct = (max_drift / median_width) * 100
-        flags['shoulder_drift_high'] = drift_pct > 25
-    
-    # Overall stability
-    flags['overall_stable'] = not any([
-        flags['occlusion_high'],
-        flags['shoulder_drift_high']
-    ])
-    
-    return flags
-
-
-def classify_metric(metric_name, value):
-    """Classify metrics with traffic light system"""
-    if value is None:
-        return {'color': 'gray', 'assessment': 'unknown', 'value': None}
-    
-    if metric_name == 'tempo':
-        if 2.7 <= value <= 3.3:
-            return {'color': 'green', 'assessment': 'good', 'value': value}
-        elif 2.4 <= value < 2.7 or 3.3 < value <= 3.6:
-            return {'color': 'amber', 'assessment': 'acceptable', 'value': value}
-        else:
-            return {'color': 'red', 'assessment': 'needs_improvement', 'value': value}
-    
-    elif metric_name == 'shaft_top':
-        abs_angle = abs(value)
-        if abs_angle <= 10:
-            color = 'green'
-        elif abs_angle <= 15:
-            color = 'amber'
-        else:
-            color = 'red'
-        
-        direction = 'across_the_line' if value > 0 else 'laid_off'
-        return {'color': color, 'assessment': color, 'direction': direction, 'value': value}
-    
-    elif metric_name == 'head_sway':
-        if value <= 25:
-            return {'color': 'green', 'assessment': 'good', 'value': value}
-        elif value <= 35:
-            return {'color': 'amber', 'assessment': 'acceptable', 'value': value}
-        else:
-            return {'color': 'red', 'assessment': 'needs_improvement', 'value': value}
-    
-    return {'color': 'gray', 'assessment': 'unknown', 'value': value}
-
-
-# ===== COACHING SUGGESTIONS =====
-
-def get_coaching_suggestion(metric_name, classification):
-    """Generate coaching suggestions based on metric classification"""
-    if metric_name == 'tempo':
-        tempo_ratio = classification.get('value')
-        if classification.get('color') == 'green':
-            return "Excellent tempo - maintain your current rhythm"
-        elif tempo_ratio and tempo_ratio <= 2.6:
-            return "Backswing rushed—train 3:1 with metronome '1-2-3…4'"
-        elif tempo_ratio and tempo_ratio >= 3.7:
-            return "Backswing too slow—quicken transition, maintain downswing tempo"
-        else:
-            return "Focus on a smooth 3:1 backswing to downswing rhythm"
-    
-    elif metric_name == 'shaft_top':
-        direction = classification.get('direction')
-        if classification.get('color') == 'green':
-            return "Perfect shaft position at top - maintain this position"
-        elif direction == 'laid_off':
-            return "Feel 'more across' with a fuller turn or later wrist-set; rehearsal: pause-at-Top with club pointing down the line"
-        elif direction == 'across_the_line':
-            return "Earlier set / feel 'club more laid-off' at Top; drill: split-hand takeaway to keep shaft neutral"
-        else:
-            return "Focus on pointing club down target line at top of backswing"
-    
-    elif metric_name == 'head_sway':
-        if classification.get('color') == 'green':
-            return "Excellent head stability throughout swing"
-        else:
-            return "Stabilize head—narrower stance or focus on turning around spine; alignment-stick behind head drill"
-    
-    elif metric_name == 'wrist_pattern':
-        if classification.get('casting', False):
-            return "Maintain hinge to P5; pump drill (3 mini downswings holding angle) then hit"
-        else:
-            return "Good wrist hinge sequence—set, hold, release"
-    
-    return "Continue working on this aspect of your swing"
-
-
-# ===== MAIN ANALYSIS FUNCTION =====
-
-def analyze_swing_dtl(pose_data, frames=None, ball_position=None):
-    """
-    Analyze golf swing using simplified DTL method
-    
-    Args:
-        pose_data: Dictionary mapping frame indices to pose keypoints
-        frames: List of video frames (optional)
-        ball_position: Ball position [x, y] (optional)
-    
-    Returns:
-        dict: Complete DTL analysis results
-    """
-    # 1. Find events
-    events = find_swing_events(pose_data, fps=30, ball_xy=ball_position)
-    
-    # 2. Quality assessment
-    quality_flags = assess_quality_flags(pose_data, frames)
-    
-    # 3. Calculate metrics (only if quality is acceptable)
-    metrics = {}
-    assessment = {}
-    coaching = {}
-    
-    if quality_flags.get('overall_stable', False):
-        # Get shoulder width for normalization
-        widths = []
-        for frame_idx, kp in pose_data.items():
-            if kp and len(kp) > 12:
-                left_shoulder = kp[11]
-                right_shoulder = kp[12]
-                if left_shoulder[2] > 0.5 and right_shoulder[2] > 0.5:
-                    width = np.linalg.norm(
-                        np.array(left_shoulder[:2]) - np.array(right_shoulder[:2])
-                    )
-                    widths.append(width)
-        
-        shoulder_width = np.median(widths) if widths else 100
-        
-        # Simple target line (horizontal)
-        target_line_vec = [1, 0]
-        
-        # Calculate core metrics
-        tempo_ratio = calculate_tempo_ratio(events['top'], events['impact'], 0)
-        if tempo_ratio:
-            metrics['tempo_ratio'] = tempo_ratio
-            assessment['tempo'] = classify_metric('tempo', tempo_ratio)
-            coaching['tempo'] = get_coaching_suggestion('tempo', assessment['tempo'])
-        
-        shaft_angle = calculate_shaft_angle_at_top(pose_data, events['top'], target_line_vec)
-        if shaft_angle is not None:
-            metrics['shaft_top_angle'] = shaft_angle
-            assessment['shaft_top'] = classify_metric('shaft_top', shaft_angle)
-            coaching['shaft_top'] = get_coaching_suggestion('shaft_top', assessment['shaft_top'])
-        
-        head_sway_lateral, head_sway_vertical = calculate_head_sway(pose_data, shoulder_width)
-        if head_sway_lateral:
-            max_sway = max(abs(x) for x in head_sway_lateral if x is not None)
-            metrics['head_sway_max'] = max_sway
-            assessment['head_sway'] = classify_metric('head_sway', max_sway)
-            coaching['head_sway'] = get_coaching_suggestion('head_sway', assessment['head_sway'])
-        
-        wrist_pattern = calculate_wrist_hinge_pattern(pose_data, events)
-        metrics['wrist_pattern'] = wrist_pattern
-        assessment['wrist_pattern'] = wrist_pattern
-        coaching['wrist_pattern'] = get_coaching_suggestion('wrist_pattern', wrist_pattern)
-    
-    # 4. Generate summary
-    red_count = sum(1 for a in assessment.values() 
-                   if isinstance(a, dict) and a.get('color') == 'red')
-    amber_count = sum(1 for a in assessment.values() 
-                     if isinstance(a, dict) and a.get('color') == 'amber')
-    green_count = sum(1 for a in assessment.values() 
-                     if isinstance(a, dict) and a.get('color') == 'green')
-    
-    if red_count == 0 and amber_count <= 1:
-        overall = 'excellent'
-    elif red_count <= 1:
-        overall = 'good'
-    else:
-        overall = 'needs_improvement'
-    
-    # Priority coaching (red items first)
-    priority_coaching = []
-    for metric_name in ['tempo', 'head_sway', 'shaft_top', 'wrist_pattern']:
-        if metric_name in assessment:
-            metric_assessment = assessment[metric_name]
-            if isinstance(metric_assessment, dict) and metric_assessment.get('color') == 'red':
-                if metric_name in coaching:
-                    priority_coaching.append(f"{metric_name.replace('_', ' ').title()}: {coaching[metric_name]}")
-    
-    return {
-        'events': events,
-        'quality_flags': quality_flags,
-        'metrics': metrics,
-        'assessment': assessment,
-        'coaching': coaching,
-        'summary': {
-            'overall_assessment': overall,
-            'data_quality': 'stable' if quality_flags.get('overall_stable') else 'unstable',
-            'red_metrics': red_count,
-            'amber_metrics': amber_count,
-            'green_metrics': green_count,
-            'priority_coaching': priority_coaching[:2],
-            'banner_message': "Want hip rotation and X-Factor analysis? Add a face-on view for complete swing analysis."
-        }
-    }
+# One-liner frame mapping replacement
+def to_processed_idx(original_idx, sample_rate): 
+    return int(round(original_idx / max(1, sample_rate)))
 
 
-# Legacy compatibility functions
 def segment_swing_pose_based(pose_data, detections=None, sample_rate=1, frame_shape=None, **kwargs):
     """Legacy function - use analyze_swing_dtl for new analysis"""
     from .segmentation import segment_swing
     return segment_swing(pose_data, detections, sample_rate, frame_shape, **kwargs)
 
 
-def get_swing_summary(analysis_results):
-    """Get user-friendly summary of swing analysis"""
-    return analysis_results.get('summary', {})
-
-
-# ===== SIMPLE USAGE EXAMPLE =====
-
-# Example usage:
-# from models.swing_analyzer import analyze_swing_dtl
-# 
-# # Analyze swing with pose data
-# results = analyze_swing_dtl(pose_data, frames, ball_position)
-# 
-# # Get summary
-# summary = results['summary']
-# print(f"Overall: {summary['overall_assessment']}")
-# print(f"Priority fixes: {summary['priority_coaching']}")
-
 def analyze_trajectory(frames, detections, swing_phases, sample_rate=1, fps=30.0):
     """
     Simple trajectory analysis - just track ball movement after impact
@@ -720,4 +48,4 @@ def analyze_trajectory(frames, detections, swing_phases, sample_rate=1, fps=30.0
         if frame_idx in trajectory_data:
             trajectory_data[frame_idx]["ball_detected"] = True
 
-    return trajectory_data
+    return trajectory_data

app/streamlit_app.py

@@ -20,6 +20,41 @@ load_dotenv()
 # Add the app directory to the path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+# ===== FORCE MODULE RELOAD FOR UPDATED METRICS =====
+# This ensures the latest front_facing_metrics.py fixes are loaded
+import importlib
+modules_to_reload = [
+    'models.front_facing_metrics',
+    'models.metrics_calculator', 
+    'models.pose_estimator',
+    'models.swing_analyzer',
+    'models.llm_analyzer'
+]
+
+for module in modules_to_reload:
+    if module in sys.modules:
+        importlib.reload(sys.modules[module])
+        print(f"🔄 Reloaded {module}")
+
+# Enable debug mode for front-facing metrics
+try:
+    import models.front_facing_metrics as ffm
+    ffm.set_debug(True)
+    print(f"✅ Front-facing metrics version: {ffm.METRICS_VERSION}")
+    print(f"✅ Debug enabled: {ffm.VERBOSE}")
+except Exception as e:
+    print(f"⚠️ Could not enable debug mode: {e}")
+
+# Clear Streamlit caches to ensure fresh data
+if hasattr(st, 'cache_data'):
+    st.cache_data.clear()
+if hasattr(st, 'cache_resource'):
+    st.cache_resource.clear()
+
+print("🚀 Module reloads complete - running with latest fixes!")
+# ===== END MODULE RELOAD SECTION =====
+
+# Import modules (will use reloaded versions from above)
 from utils.video_downloader import download_youtube_video, download_pro_reference, cleanup_video_file, cleanup_downloads_directory
 from utils.video_processor import process_video
 from models.pose_estimator import analyze_pose
@@ -190,79 +225,8 @@ def format_metric_value(metric_data, unit=""):
         return f"{value} ({status}){unit}"
 
 
-def get_shaft_angle_grading(value, confidence):
-    """Grade shaft angle at top with sign-aware labels"""
-    if value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    # Note: Not hiding any values - display all measurements
-    # Even extreme values might be valid for certain swings or camera angles
-    
-    # Determine label based on value (updated thresholds per user spec)
-    if -10 <= value <= 10:
-        badge = "🟢"
-        label = "Neutral"
-    elif 10 < value <= 20:
-        badge = "🟠"
-        label = f"Across (mild)"
-    elif 20 < value <= 35:
-        badge = "🔴"
-        label = f"Across (needs work)"
-    elif -20 <= value < -10:
-        badge = "🟠"
-        label = f"Laid-off (mild)"
-    elif -35 <= value < -20:
-        badge = "🔴"
-        label = f"Laid-off (needs work)"
-    else:
-        badge = "🔴"
-        label = "Extreme"
-    
-    # Format display value with direction and proper sign
-    if value > 0:
-        display_value = f"+{value:.1f}° Across"
-    elif value < 0:
-        display_value = f"{value:.1f}° Laid-off"
-    else:
-        display_value = f"{value:.1f}° Neutral"
-    
-    return {
-        'display_value': display_value,
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-    }
 
 
-def get_head_sway_grading(value, confidence):
-    """Grade head sway with percentage of pelvis/shoulder width"""
-    if value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    # Note: Not hiding any values - display all measurements
-    # Even high values might be valid for certain swings or camera setups
-    
-    # Determine grading (updated per user spec)
-    if value <= 15:
-        badge = "🟢"
-        label = "Minimal"
-    elif value <= 25:
-        badge = "🟢"
-        label = "Controlled"
-    elif value <= 35:
-        badge = "🟠"
-        label = "Noticeable"
-    else:  # 35-50%
-        badge = "🔴"
-        label = "Excessive"
-    
-    return {
-        'display_value': f"{value:.0f}%",
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-        'approx': True,  # DTL-limited
-    }
 
 
 def get_back_tilt_grading(value, confidence, camera_roll=0):
@@ -328,354 +292,14 @@ def get_knee_flexion_grading(value, confidence):
     }
 
 
-def get_wrist_pattern_grading(pattern_data, confidence):
-    """Grade wrist pattern categorically"""
-    if not pattern_data or pattern_data.get('value') is None:
-        return {
-            'display_value': "Unstable",
-            'badge': "⚪",
-            'label': "club not visible",
-            'confidence': 0
-        }
-    
-    # Interpret pattern - prioritize actual pattern value over status
-    pattern_value = pattern_data.get('value', '')
-    status = pattern_data.get('status', 'unknown')
-    
-    # If we have a clear pattern value, use that instead of relying on status
-    if pattern_value == 'set_hold_release':
-        badge = "🟢"
-        label = "Set-Hold-Release — Excellent"
-    elif pattern_value == 'early_cast' or status == 'early_cast':
-        badge = "🔴"
-        label = "Early Cast — Needs work"
-    elif pattern_value == 'late_set' or (status == 'needs_work' and pattern_value != 'set_hold_release'):
-        badge = "🟠"
-        label = "Late Set — Caution"
-    elif status == 'good_sequence':
-        badge = "🟢"
-        label = "Good Sequence"
-    else:
-        badge = "🟠"
-        label = "Inconsistent Pattern"
-    
-    return {
-        'display_value': label,
-        'badge': badge,
-        'label': "Needs work",  # Add descriptive text after badge
-        'confidence': confidence
-    }
 
 
-def get_qualitative_shaft_angle_grading(raw_value, confidence):
-    """Grade shaft angle qualitatively without showing unreliable numbers"""
-    if raw_value is None:
-        return None
-    
-    # Use the raw value to determine qualitative assessment
-    # Even if the number is unreliable, the direction trend can be informative
-    if abs(raw_value) <= 15:
-        category = "Neutral"
-        badge = "🟢"
-        description = "Good plane control"
-    elif raw_value > 15:
-        if raw_value > 30:
-            category = "Across"
-            badge = "🟠"
-            description = "Strong across-line tendency"
-        else:
-            category = "Slightly Across"
-            badge = "🟢"
-            description = "Mild across-line bias"
-    else:  # raw_value < -15
-        if raw_value < -30:
-            category = "Laid-off"
-            badge = "🟠"
-            description = "Strong laid-off tendency"
-        else:
-            category = "Slightly Laid-off"
-            badge = "🟢"
-            description = "Mild laid-off bias"
-    
-    return {
-        'display_value': category,
-        'badge': badge,
-        'label': description,
-        'confidence': confidence,
-    }
 
 
-def get_qualitative_hip_rotation_grading(raw_value, confidence):
-    """Grade hip rotation qualitatively - removed power percentage as unreliable DTL-only"""
-    if raw_value is None:
-        return {
-            'display_value': "Unknown",
-            'badge': "⚪",
-            'label': "insufficient data",
-            'confidence': 0
-        }
-    
-    # Assess kinematic sequence without power percentages (DTL unreliable)
-    # Focus on relative hip rotation amount without claiming % power contribution
-    if isinstance(raw_value, (int, float)):
-        # Evaluate based on professional hip rotation ranges
-        if raw_value >= 25:
-            category = "High Hip Turn"
-            badge = "🟢"
-            description = "Strong hip rotation"
-        elif raw_value >= 18:
-            category = "Good Hip Turn"
-            badge = "🟢"
-            description = "Good hip rotation"
-        elif raw_value >= 12:
-            category = "Moderate Hip Turn"
-            badge = "🟠"
-            description = "Moderate hip rotation"
-        elif raw_value >= 8:
-            category = "Limited Hip Turn"
-            badge = "🟠"
-            description = "Limited hip rotation"
-        else:
-            category = "Minimal Hip Turn"
-            badge = "🔴"
-            description = "Minimal hip rotation"
-    else:
-        category = "Moderate"
-        badge = "🟠"
-        description = "Mixed rotation pattern"
-    
-    return {
-        'display_value': category,
-        'badge': badge,
-        'label': description,
-        'confidence': confidence,
-    }
 
 
-def get_shoulder_turn_grading(value):
-    """Grade shoulder turn quality with proper assessment"""
-    # Assess shoulder turn quality, not just quantity
-    if value is None:
-        return {
-            'display_value': "Unknown",
-            'badge': "⚪",
-            'label': "insufficient data",
-            'confidence': 0,
-            'dtl_only': True
-        }
-    
-    # Convert to quality assessment
-    if isinstance(value, str):
-        turn_desc = value.lower()
-        if turn_desc == "full":
-            badge = "🟢"
-            quality = "Excellent"
-            description = "Complete shoulder rotation"
-        elif turn_desc == "normal":
-            badge = "🟢"
-            quality = "Good"
-            description = "Adequate shoulder turn"
-        elif turn_desc == "small":
-            badge = "🟠"
-            quality = "Limited"
-            description = "Restricted shoulder turn"
-        else:
-            badge = "🟠"
-            quality = turn_desc.title()
-            description = "Mixed shoulder action"
-    else:
-        # Numeric assessment
-        if value >= 90:
-            badge = "🟢"
-            quality = "Excellent"
-            description = "Complete shoulder rotation"
-        elif value >= 75:
-            badge = "🟢"
-            quality = "Good"
-            description = "Adequate shoulder turn"
-        else:
-            badge = "🟠"
-            quality = "Limited"
-            description = "Restricted shoulder turn"
-    
-    return {
-        'display_value': quality,
-        'badge': badge,
-        'label': description,
-        'confidence': 0.7,  # Moderate confidence for DTL assessment
-        'dtl_only': True
-    }
 
 
-def get_hip_depth_grading(hip_depth_data, confidence):
-    """Generate grading for hip depth/early extension with enhanced confidence handling"""
-    if not hip_depth_data:
-        return None
-    
-    depth_loss_pct = hip_depth_data.get('depth_loss_pct', 0)
-    calculation_confidence = hip_depth_data.get('confidence', 1.0)
-    adaptive_threshold = hip_depth_data.get('adaptive_threshold', 20.0)
-    smoothed_measurement = hip_depth_data.get('smoothed_measurement', False)
-    
-    # Determine confidence level and add appropriate indicators
-    confidence_indicators = []
-    if confidence < 0.5:
-        confidence_indicators.append('⚠️ Low confidence')
-    elif confidence < 0.8:
-        confidence_indicators.append('⚡ Moderate confidence')
-    
-    if smoothed_measurement:
-        confidence_indicators.append('📊 Smoothed')
-    
-    if calculation_confidence < 0.5:
-        confidence_indicators.append('🔧 Fallback method')
-    
-    confidence_note = f" ({', '.join(confidence_indicators)})" if confidence_indicators else ""
-    
-    if depth_loss_pct < 5:
-        badge = '🟢'
-        label = 'Good depth maintenance'
-    elif depth_loss_pct < 15:
-        badge = '🟠'
-        label = 'Some early extension'
-    else:
-        badge = '🔴'
-        label = 'Early extension'
-    
-    # Technical details removed per user request
-    
-    return {
-        'value': depth_loss_pct,  # Raw value for display logic
-        'display_value': f'{depth_loss_pct:.1f}% loss{confidence_note}',
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-        'status': label,  # Use label as status for legacy compatibility
-        'calculation_confidence': calculation_confidence,
-        'adaptive_threshold': adaptive_threshold
-    }
-
-
-def get_shaft_address_grading(angle_value, confidence):
-    """Generate grading for shaft angle at address"""
-    if angle_value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    if 45 <= angle_value <= 65:
-        badge = '🟢'
-        label = 'Good setup angle'
-    elif (35 <= angle_value < 45) or (65 < angle_value <= 75):
-        badge = '🟠'
-        label = 'Acceptable angle'
-    else:
-        badge = '🔴'
-        label = 'Needs adjustment'
-    
-    return {
-        'display_value': f'{angle_value:.1f}°',
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-    }
-
-
-def get_head_displacement_grading(displacement_data, confidence):
-    """Generate grading for head vertical displacement"""
-    if not displacement_data:
-        return None
-    
-    displacement_pct = displacement_data.get('displacement_pct', 0)
-    direction = displacement_data.get('displacement_direction', 'unknown')
-    displacement_abs = displacement_data.get('displacement_abs', 0)
-    
-    if displacement_pct < 5:
-        badge = '🟢'
-        label = 'Very stable head'
-    elif displacement_pct < 15:
-        badge = '🟠'
-        label = 'Some movement'
-    else:
-        badge = '🔴'
-        label = 'Excessive movement'
-    
-    display_text = f'{displacement_pct:.1f}% {direction}' if 'displacement_pct' in displacement_data else f'{displacement_abs:.1f}px {direction}'
-    
-    return {
-        'display_value': display_text,
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-    }
-
-
-def get_shoulder_rotation_grading(value, confidence, position="top"):
-    """Grade shoulder rotation angle"""
-    if value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    # Professional ranges: Top ~90-110°, Impact ~30-50°
-    if position == "top":
-        if 85 <= value <= 115:
-            badge = '🟢'
-            label = 'Excellent rotation'
-        elif 75 <= value < 85 or 115 < value <= 125:
-            badge = '🟠'
-            label = 'Good rotation'
-        else:
-            badge = '🔴'
-            label = 'Needs improvement'
-    else:  # impact
-        if 30 <= value <= 50:
-            badge = '🟢'
-            label = 'Excellent impact position'
-        elif 20 <= value < 30 or 50 < value <= 60:
-            badge = '🟠'
-            label = 'Good impact position'
-        else:
-            badge = '🔴'
-            label = 'Needs improvement'
-    
-    return {
-        'display_value': f"{value:.1f}°",
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-    }
-
-
-def get_hip_rotation_grading(value, confidence, position="top"):
-    """Grade hip rotation angle"""
-    if value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    # Professional ranges: Top ~45-60°, Impact ~40-60°
-    if position == "top":
-        if 40 <= value <= 65:
-            badge = '🟢'
-            label = 'Excellent turn'
-        elif 30 <= value < 40 or 65 < value <= 75:
-            badge = '🟠'
-            label = 'Good turn'
-        else:
-            badge = '🔴'
-            label = 'Needs improvement'
-    else:  # impact
-        if 35 <= value <= 65:
-            badge = '🟢'
-            label = 'Excellent impact position'
-        elif 25 <= value < 35 or 65 < value <= 75:
-            badge = '🟠'
-            label = 'Good impact position'
-        else:
-            badge = '🔴'
-            label = 'Needs improvement'
-    
-    return {
-        'display_value': f"{value:.1f}°",
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
-    }
 
 
 
@@ -875,31 +499,30 @@ def get_wrist_hinge_grading(value, confidence, position="top"):
     }
 
 
-def get_head_lateral_sway_grading(value, confidence):
-    """Grade head lateral sway as percentage of shoulder width"""
-    if value is None:
-        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
-    
-    # Grade based on percentage of shoulder width
-    if abs(value) <= 5.0:  # <= 5% of shoulder width
-        badge = '🟢'
-        label = 'Excellent stability'
-    elif abs(value) <= 10.0:  # <= 10% of shoulder width
-        badge = '🟡'
-        label = 'Good stability'
-    elif abs(value) <= 15.0:  # <= 15% of shoulder width
-        badge = '🟠'
-        label = 'Moderate sway'
-    else:  # > 15% of shoulder width
-        badge = '🔴'
-        label = 'Excessive sway'
-    
-    return {
-        'display_value': f"{value:.1f}%",
-        'badge': badge,
-        'label': label,
-        'confidence': confidence,
+
+
+def grade_hip_turn(delta_deg: float, club: str = "iron") -> dict:
+    """Grade hip turn with club-aware bands and actionable tips"""
+    c = club.lower()
+    bands = {
+        "driver": {"excellent": (38,48), "good_low": (32,38), "good_high": (48,52)},
+        "iron":   {"excellent": (32,40), "good_low": (28,32), "good_high": (40,44)},
+        "wedge":  {"excellent": (25,35), "good_low": (22,25), "good_high": (35,38)},
     }
+    b = bands["driver" if "driver" in c else "wedge" if "wedge" in c else "iron"]
+    x = delta_deg
+
+    if b["excellent"][0] <= x <= b["excellent"][1]:
+        label, color, tip = "🟢 Excellent", "green", "Great rotation with control."
+    elif b["good_low"][0] <= x < b["good_low"][1]:
+        label, color, tip = "🟠 Good (slightly low)", "orange", "Open a touch more through impact."
+    elif b["good_high"][0] <= x <= b["good_high"][1]:
+        label, color, tip = "🟠 Good (slightly high)", "orange", "Post on lead leg; avoid over-spinning hips."
+    else:
+        label, color, tip = "🔴 Needs work", "red", (
+            "Too little: shift then open. Too much: trail heel down longer; post into lead glute."
+        )
+    return {"label": label, "color": color, "tip": tip}
 
 
 def display_new_grading_scheme(core_metrics):