Refactor into modular app structure

Split monolithic files into focused modules:
- app/core: settings, logging, lifecycle
- app/signaling: websocket server, ICE parser, message models
- app/webrtc: peer session, video receiver, frame source
- app/vision: pose landmarker wrapper, model config, pose types
- app/exercises/dead_bug: detector, metrics, rules, state machine, types
- app/rendering: skeleton renderer, status overlay, window display
- app/audio: rep announcer
- app/diagnostics: perf timer, crash handler
- configs: environment-based settings
- tests: unit tests for rules, state machine, ICE parser
- run.py: entry point

app/rendering/overlay_renderer.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+from app.exercises.dead_bug.types import DeadBugResult
+
+
+def draw_status_overlay(image: np.ndarray, result: DeadBugResult) -> None:
+    color = (60, 220, 90) if result.is_standard else (50, 180, 255)
+    cv2.rectangle(image, (12, 12), (520, 142), (20, 20, 20), -1)
+    cv2.putText(image, f"Dead bug reps: {result.rep_count}", (28, 48), cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
+    cv2.putText(image, f"phase: {result.phase.value}", (28, 82), cv2.FONT_HERSHEY_SIMPLEX, 0.68, (230, 230, 230), 2)
+    status = "standard" if result.is_standard else "adjust"
+    cv2.putText(image, f"status: {status}", (28, 116), cv2.FONT_HERSHEY_SIMPLEX, 0.68, color, 2)
+
+    y = 170
+    for text in result.feedback:
+        cv2.putText(image, text, (28, y), cv2.FONT_HERSHEY_SIMPLEX, 0.68, (255, 255, 255), 2)
+        y += 30

app/rendering/skeleton_renderer.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import cv2
+import numpy as np
+
+from app.exercises.dead_bug.types import DeadBugResult, Point
+from app.vision.pose_types import _POSE_CONNECTIONS
+
+
+def draw_landmarks(
+    image: np.ndarray,
+    landmarks: list[Point],
+    required_indices: tuple[int, ...],
+    connections: tuple[tuple[int, int], ...] | None = None,
+    visibility_threshold: float = 0.45,
+    line_color: tuple[int, int, int] = (65, 180, 255),
+    point_color: tuple[int, int, int] = (80, 255, 120),
+    line_thickness: int = 2,
+    point_radius: int = 4,
+) -> None:
+    if connections is None:
+        connections = _POSE_CONNECTIONS
+
+    h, w = image.shape[:2]
+
+    for start, end in connections:
+        if start >= len(landmarks) or end >= len(landmarks):
+            continue
+        p1 = landmarks[start]
+        p2 = landmarks[end]
+        if p1.visibility < visibility_threshold or p2.visibility < visibility_threshold:
+            continue
+        cv2.line(
+            image,
+            (int(p1.x * w), int(p1.y * h)),
+            (int(p2.x * w), int(p2.y * h)),
+            line_color,
+            line_thickness,
+        )
+
+    for idx in required_indices:
+        if idx >= len(landmarks):
+            continue
+        p = landmarks[idx]
+        if p.visibility >= visibility_threshold:
+            cv2.circle(image, (int(p.x * w), int(p.y * h)), point_radius, point_color, -1)

app/rendering/window_display.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import cv2
+
+WINDOW_NAME = "Android Camera (WebRTC)"
+
+
+def show_frame(image, window_name: str = WINDOW_NAME) -> None:
+    cv2.imshow(window_name, image)
+
+
+def wait_key(delay_ms: int = 1) -> int:
+    return cv2.waitKey(delay_ms) & 0xFF
+
+
+def is_esc_pressed() -> bool:
+    return wait_key(1) == 27
+
+
+def close_window() -> None:
+    cv2.destroyAllWindows()