react-native-nitro-pose-exercises 1.1.16 → 1.1.18

package/android/build.gradle

@@ -122,5 +122,6 @@ dependencies {
   implementation project(":react-native-nitro-modules")
   implementation 'com.google.mlkit:pose-detection:18.0.0-beta5'
   implementation project(":react-native-vision-camera")
+  implementation "androidx.camera:camera-core:1.3.4"
 }
 

package/android/src/main/java/com/margelo/nitro/nitroposeexercises/NitroPoseExercises.kt

@@ -4,6 +4,7 @@ import com.margelo.nitro.camera.HybridFrameSpec
 import com.margelo.nitro.camera.public.NativeFrame
 import com.google.android.gms.tasks.Tasks
 import java.util.concurrent.TimeUnit
+import androidx.camera.core.ImageProxy
 
 // import android.graphics.Matrix
 import androidx.annotation.Keep
@@ -130,7 +131,7 @@ override var onPostureRegained: (() -> Unit)? = null
 
   // ─── Posture Gate ──────────────────────────────────────────
 private var consecutivePostureFailures: Int = 0
-private val postureFailureThreshold: Int = 10
+private val postureFailureThreshold: Int = 30  // ~3s — tolerant of pushup occlusion
 private var postureWasLost = false
 
   // ─── Hold Tracking ──────────────────────────────────────────
@@ -214,10 +215,6 @@ override fun isReady(): Boolean {
   // Frame Processing (ML Kit — async with cached results)
   // ═══════════════════════════════════════════════════════════
 
-// Reusable scratch — allocated once, never GC'd per frame
-@Volatile private var lastProcessTime: Long = 0L
-private val minIntervalMs: Long = 66L  // ~15fps cap; bump down to 33 for ~30fps
-
 // Time-based throttle — more reliable than frame-count under variable FPS
 @Volatile private var lastProcessTime: Long = 0L
 private val minIntervalMs: Long = 66L  // ~15fps; lower to 33 for ~30fps once release build is fast enough
@@ -304,23 +301,31 @@ private fun processExerciseLogic() {
   val config = exerciseConfig ?: return
   if (_landmarks.isEmpty()) return
 
-val failureThreshold = if (config.type == ExerciseType.HOLD)
-  postureFailureThreshold * 3
-else
-  postureFailureThreshold
-
-if (!isPostureValid(config.postureFamily, config.visibilityThreshold)) {
-  consecutivePostureFailures++
-  if (consecutivePostureFailures >= failureThreshold) {
-    if (!postureWasLost) {
-      postureWasLost = true
-      onPostureLost?.invoke()
+  // Hold exercises get 3x more tolerance — stationary poses suffer from
+  // visibility flicker more than active reps.
+  val failureThreshold = if (config.type == ExerciseType.HOLD) {
+    postureFailureThreshold * 3
+  } else {
+    postureFailureThreshold
+  }
+
+  // Posture gate with hysteresis
+  if (!isPostureValid(config.postureFamily, config.visibilityThreshold)) {
+    consecutivePostureFailures += 1
+    if (consecutivePostureFailures >= failureThreshold) {
+      if (!postureWasLost) {
+        postureWasLost = true
+        onPostureLost?.invoke()
+      }
+      // Only nuke phase history after EXTENDED loss (3x threshold).
+      // Brief occlusions during a pushup shouldn't wipe an in-progress rep.
+      if (consecutivePostureFailures >= failureThreshold * 3) {
+        _currentPhase = ExercisePhase.UNKNOWN
+        phaseHistory = mutableListOf()
+      }
     }
-    _currentPhase = ExercisePhase.UNKNOWN
-    phaseHistory.clear()
+    return
   }
-  return
-}
 
   consecutivePostureFailures = 0
   if (postureWasLost) {
@@ -328,40 +333,52 @@ if (!isPostureValid(config.postureFamily, config.visibilityThreshold)) {
     onPostureRegained?.invoke()
   }
 
-    val currentAngles = mutableMapOf<String, Double>()
-    val angleSnapshots = mutableListOf<AngleSnapshot>()
+  // Angle calculation
+  val visThreshold = config.visibilityThreshold
+  val currentAngles = mutableMapOf<String, Double>()
+  val angleSnapshots = mutableListOf<AngleSnapshot>()
 
-    for (angleDef in config.angles) {
-      val a = angleDef.landmarkA.toInt()
-      val b = angleDef.landmarkB.toInt()
-      val c = angleDef.landmarkC.toInt()
+  for (angleDef in config.angles) {
+    val a = angleDef.landmarkA.toInt()
+    val b = angleDef.landmarkB.toInt()
+    val c = angleDef.landmarkC.toInt()
 
-      if (a >= _landmarks.size || b >= _landmarks.size || c >= _landmarks.size) continue
+    if (a >= _landmarks.size || b >= _landmarks.size || c >= _landmarks.size) continue
 
-      // Only calculate if all three landmarks have reasonable confidence
-      if (_landmarks[a].visibility < 0.3 || _landmarks[b].visibility < 0.3 || _landmarks[c].visibility < 0.3) continue
+    if (_landmarks[a].visibility <= visThreshold ||
+        _landmarks[b].visibility <= visThreshold ||
+        _landmarks[c].visibility <= visThreshold) continue
 
-      val angle = calculateAngle(_landmarks[a], _landmarks[b], _landmarks[c])
-      currentAngles[angleDef.name] = angle
-      angleSnapshots.add(AngleSnapshot(name = angleDef.name, value = angle))
-    }
+    val angle = calculateAngle(
+      pointA = _landmarks[a],
+      vertex = _landmarks[b],
+      pointC = _landmarks[c]
+    )
 
-    repAngleSnapshots = angleSnapshots.toTypedArray()
+    currentAngles[angleDef.name] = angle
+    angleSnapshots.add(AngleSnapshot(name = angleDef.name, value = angle))
+  }
 
-    val detectedPhase = determinePhase(currentAngles, config)
+  repAngleSnapshots = angleSnapshots
 
-    if (detectedPhase != _currentPhase && detectedPhase != ExercisePhase.UNKNOWN) {
-      _currentPhase = detectedPhase
-      onPhaseChange?.invoke(detectedPhase)
-      handlePhaseTransition(detectedPhase, config)
-    }
+  val detectedPhase = determinePhase(currentAngles, config)
 
-    checkFormRules(currentAngles, config)
+  // Debug log — remove once reps count reliably
+  println("[Pose] angles=$currentAngles current=$_currentPhase detected=$detectedPhase history=$phaseHistory reps=$_repCount")
 
-    if (config.type == ExerciseType.HOLD) {
-      handleHoldProgress(currentAngles, config)
-    }
+  if (detectedPhase != _currentPhase && detectedPhase != ExercisePhase.UNKNOWN) {
+    val previousPhase = _currentPhase
+    _currentPhase = detectedPhase
+    onPhaseChange?.invoke(detectedPhase)
+    handlePhaseTransition(previousPhase, detectedPhase, config)
+  }
+
+  checkFormRules(currentAngles, config)
+
+  if (config.type == ExerciseType.HOLD) {
+    handleHoldProgress(currentAngles, config)
   }
+}
 
   // ═══════════════════════════════════════════════════════════
   // Angle Calculation
@@ -635,6 +652,7 @@ private fun isPostureValid(family: PostureFamily, threshold: Double): Boolean {
   val lh = _landmarks[23]; val rh = _landmarks[24]
   val lk = _landmarks[25]; val rk = _landmarks[26]
   val la = _landmarks[27]; val ra = _landmarks[28]
+  val lw = _landmarks[15]; val rw = _landmarks[16]
 
   // Shoulders mandatory; everything below is optional for close-range framing
   val shouldersVisible = ls.visibility > threshold && rs.visibility > threshold
@@ -643,6 +661,8 @@ private fun isPostureValid(family: PostureFamily, threshold: Double): Boolean {
   val hipsVisible = lh.visibility > threshold && rh.visibility > threshold
   val kneesVisible = lk.visibility > threshold && rk.visibility > threshold
   val anklesVisible = la.visibility > threshold && ra.visibility > threshold
+  val wristsVisible = lw.visibility > threshold && rw.visibility > threshold
+  val oneWristVisible = lw.visibility > threshold || rw.visibility > threshold
 
   val shoulderY = (ls.y + rs.y) / 2
   val shoulderX = (ls.x + rs.x) / 2
@@ -656,25 +676,31 @@ private fun isPostureValid(family: PostureFamily, threshold: Double): Boolean {
 
   return when (family) {
     PostureFamily.HORIZONTALPRONE, PostureFamily.SUPINE -> {
-      if (!hipsVisible) return false
+      // Case A: side view — full body in horizontal band
+      if (hipsVisible) {
+        val ys = if (anklesVisible)
+          listOf(shoulderY, hipY, ankleY)
+        else
+          listOf(shoulderY, hipY)
+        if ((ys.max() - ys.min()) < 0.25) return true
+      }
+
+      // Case B: front-facing prone — minimum signature is shoulders + at least
+      // one wrist. Hips often occluded by the body in pushup framings.
+      if (!oneWristVisible) return false
 
-      // Case A: side view — shoulders/hips/(ankles) in a horizontal band
-      val ys = if (anklesVisible)
-        listOf(shoulderY, hipY, ankleY)
+      val wristY = if (wristsVisible)
+        (lw.y + rw.y) / 2
       else
-        listOf(shoulderY, hipY)
-      if ((ys.max() - ys.min()) < 0.25) return true
-
-      // Case B: front-facing prone (pushup head-on) — large y-spread,
-      // fall back to upper-body geometry
-      val le = _landmarks[13]; val re = _landmarks[14]
-      val lw = _landmarks[15]; val rw = _landmarks[16]
-      val upperBodyVisible = le.visibility > threshold && re.visibility > threshold &&
-                             lw.visibility > threshold && rw.visibility > threshold
-      if (!upperBodyVisible) return false
-
-      val wristY = (lw.y + rw.y) / 2
-      wristY > shoulderY + 0.03 && shoulderWidth > 0.10
+        kotlin.math.max(lw.y, rw.y)
+
+      // Geometry: wrists at or below shoulder line, torso reasonably wide.
+      // Tolerance loosened for deep DOWN phase where shoulders drop close
+      // to wrist level.
+      val handsLowerOrLevel = wristY > shoulderY - 0.08
+      val torsoFacing = shoulderWidth > 0.06
+
+      handsLowerOrLevel && torsoFacing
     }
 
     PostureFamily.STANDINGUPRIGHT -> {

package/ios/NitroPoseExercises.swift

@@ -72,7 +72,7 @@ class NitroPoseExercises: HybridNitroPoseExercisesSpec {
 
   // ─── Posture Gate ──────────────────────────────────────────
 private var consecutivePostureFailures: Int = 0
-private let postureFailureThreshold: Int = 10  // ~1s at 30fps with throttle=3
+private let postureFailureThreshold: Int = 30  // ~3s at 30fps with throttle=3 — tolerant of pushup occlusion
 private var postureWasLost = false
 
   // ─── Pose Tracking ──────────────────────────────────────────
@@ -287,8 +287,12 @@ private func processExerciseLogic() {
         postureWasLost = true
         onPostureLost?()
       }
-      _currentPhase = .unknown
-      phaseHistory = []
+      // Only nuke phase history after EXTENDED loss (3x threshold).
+      // Brief occlusions during a pushup shouldn't wipe an in-progress rep.
+      if consecutivePostureFailures >= failureThreshold * 3 {
+        _currentPhase = .unknown
+        phaseHistory = []
+      }
     }
     return
   }
@@ -329,6 +333,9 @@ private func processExerciseLogic() {
 
   let detectedPhase = determinePhase(from: currentAngles, config: config)
 
+  // Debug log — remove once reps count reliably
+  print("[Pose] angles=\(currentAngles) current=\(_currentPhase) detected=\(detectedPhase) history=\(phaseHistory) reps=\(_repCount)")
+
   if detectedPhase != _currentPhase && detectedPhase != .unknown {
     let previousPhase = _currentPhase
     _currentPhase = detectedPhase
@@ -354,14 +361,17 @@ private func isPostureValid(family: PostureFamily, threshold: Double) -> Bool {
   let lh = _landmarks[23], rh = _landmarks[24]
   let lk = _landmarks[25], rk = _landmarks[26]
   let la = _landmarks[27], ra = _landmarks[28]
+  let lw = _landmarks[15], rw = _landmarks[16]
 
-  // Shoulders are mandatory; hips/knees/ankles are optional for close-range framing
+  // Shoulders mandatory; everything below is optional for close-range framing
   let shouldersVisible = ls.visibility > threshold && rs.visibility > threshold
   guard shouldersVisible else { return false }
 
   let hipsVisible = lh.visibility > threshold && rh.visibility > threshold
   let kneesVisible = lk.visibility > threshold && rk.visibility > threshold
   let anklesVisible = la.visibility > threshold && ra.visibility > threshold
+  let wristsVisible = lw.visibility > threshold && rw.visibility > threshold
+  let oneWristVisible = lw.visibility > threshold || rw.visibility > threshold
 
   let shoulderY = (ls.y + rs.y) / 2
   let shoulderX = (ls.x + rs.x) / 2
@@ -370,40 +380,40 @@ private func isPostureValid(family: PostureFamily, threshold: Double) -> Bool {
   let kneeY = kneesVisible ? (lk.y + rk.y) / 2 : hipY
   let ankleY = anklesVisible ? (la.y + ra.y) / 2 : kneeY
 
-  // Shoulder width is camera-mirror invariant: |x1 - x2| is the same
-  // whether the front camera mirror has been applied or not.
+  // Mirror-invariant — works for front and back camera identically
   let shoulderWidth = (ls.x - rs.x).magnitude
 
   switch family {
   case .horizontalprone, .supine:
-    // Need hips to make any meaningful judgment for prone/supine
-    guard hipsVisible else { return false }
-
-    // Case A: side view — shoulders, hips, ankles in a horizontal band
-    let ys: [Double] = anklesVisible
-      ? [shoulderY, hipY, ankleY]
-      : [shoulderY, hipY]
-    let ySpread = (ys.max() ?? 0) - (ys.min() ?? 0)
-    if ySpread < 0.25 {
-      return true
+    // Case A: side view — full body in horizontal band
+    if hipsVisible {
+      let ys: [Double] = anklesVisible
+        ? [shoulderY, hipY, ankleY]
+        : [shoulderY, hipY]
+      let ySpread = (ys.max() ?? 0) - (ys.min() ?? 0)
+      if ySpread < 0.25 {
+        return true
+      }
     }
 
-    // Case B: front-facing prone (e.g. pushup viewed head-on) — body extends
-    // away along Z, so y-spread is large. Fall back to upper-body geometry.
-    let le = _landmarks[13], re = _landmarks[14]
-    let lw = _landmarks[15], rw = _landmarks[16]
-    let upperBodyVisible = le.visibility > threshold && re.visibility > threshold
-                        && lw.visibility > threshold && rw.visibility > threshold
-    guard upperBodyVisible else { return false }
-
-    let wristY = (lw.y + rw.y) / 2
-    guard wristY > shoulderY + 0.03 else { return false }
-    guard shoulderWidth > 0.10 else { return false }
-    return true
+    // Case B: front-facing prone — minimum signature is shoulders + at least
+    // one wrist. We do NOT require hips because in pushup framings hips are
+    // often occluded by the body itself.
+    guard oneWristVisible else { return false }
+
+    let wristY = wristsVisible
+      ? (lw.y + rw.y) / 2
+      : max(lw.y, rw.y)  // whichever wrist we can see
+
+    // Geometry: wrists at or below shoulder line, torso reasonably wide.
+    // Tolerance loosened to handle deep DOWN phase where shoulders drop
+    // close to wrist level.
+    let handsLowerOrLevel = wristY > shoulderY - 0.08
+    let torsoFacing = shoulderWidth > 0.06
+
+    return handsLowerOrLevel && torsoFacing
 
   case .standingupright:
-    // Front-facing standing: user often crops hips/knees at close range.
-    // Use a tiered check based on what's visible.
     if hipsVisible {
       if kneesVisible {
         return shoulderY < hipY - 0.05
@@ -412,8 +422,7 @@ private func isPostureValid(family: PostureFamily, threshold: Double) -> Bool {
       }
       return shoulderY < hipY - 0.05
     }
-    // Hips off-frame — accept if shoulders form a reasonable horizontal span,
-    // which means the person is upright and facing (or backing) the camera.
+    // Hips cropped (close-range front-facing) — accept based on shoulder span
     return shoulderWidth > 0.08
 
   case .seated:
@@ -423,7 +432,6 @@ private func isPostureValid(family: PostureFamily, threshold: Double) -> Bool {
     if hipsVisible {
       return shoulderY < hipY - 0.05
     }
-    // Seated with hips out of frame is rare; fall back to upright shoulder span
     return shoulderWidth > 0.08
 
   case .sideplank:

package/lib/module/config/pushup.js

@@ -9,8 +9,8 @@
 export const PUSHUP_CONFIG = {
   name: 'Push-Up',
   type: 'rep',
-  postureFamily: 'none',
-  visibilityThreshold: 0.3,
+  postureFamily: 'horizontalProne',
+  visibilityThreshold: 0.1,
   cameraAngle: 'front',
   angles: [{
     name: 'leftElbow',
@@ -23,10 +23,7 @@ export const PUSHUP_CONFIG = {
     landmarkB: 14,
     landmarkC: 16
   }],
-  phases: [
-  // Calibrated for 2D-projected angles in front-facing portrait filming.
-  // Real anatomical 180° appears as ~140-150° due to perspective foreshortening.
-  {
+  phases: [{
     phase: 'up',
     angleName: 'leftElbow',
     minAngle: 130,
@@ -34,23 +31,11 @@ export const PUSHUP_CONFIG = {
   }, {
     phase: 'down',
     angleName: 'leftElbow',
-    minAngle: 40,
-    maxAngle: 80
+    minAngle: 0,
+    maxAngle: 120
   }],
   repSequence: ['up', 'down', 'up'],
-  formRules: [
-  // Trigger when descending but stalled above true-down threshold
-  {
-    name: 'shallowRep',
-    message: 'Go lower',
-    severity: 'info',
-    angleName: 'leftElbow',
-    minAngle: 80,
-    maxAngle: 130 // "limbo zone" — too low to be up, too high to be down
-    // Note: ideally this only fires when angle has stalled, not on the way down.
-    // If your formRule engine doesn't support velocity/stall detection,
-    // accept that it'll fire briefly during transitions too.
-  }],
+  formRules: [],
   holdDurationMs: 0
 };
 //# sourceMappingURL=pushup.js.map

package/lib/module/config/pushup.js.map

@@ -1 +1 @@
-{"version":3,"names":["PUSHUP_CONFIG","name","type","postureFamily","visibilityThreshold","cameraAngle","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","message","severity","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/pushup.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;;AAEA,OAAO,MAAMA,aAA6B,GAAG;EAC3CC,IAAI,EAAE,SAAS;EACfC,IAAI,EAAE,KAAK;EACXC,aAAa,EAAE,MAAM;EACrBC,mBAAmB,EAAE,GAAG;EACxBC,WAAW,EAAE,OAAO;EACpBC,MAAM,EAAE,CACN;IAAEL,IAAI,EAAE,WAAW;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,EAClE;IAAER,IAAI,EAAE,YAAY;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,CACpE;EACDC,MAAM,EAAE;EACN;EACA;EACA;IAAEC,KAAK,EAAE,IAAI;IAAEC,SAAS,EAAE,WAAW;IAAEC,QAAQ,EAAE,GAAG;IAAEC,QAAQ,EAAE;EAAI,CAAC,EACrE;IAAEH,KAAK,EAAE,MAAM;IAAEC,SAAS,EAAE,WAAW;IAAEC,QAAQ,EAAE,EAAE;IAAEC,QAAQ,EAAE;EAAG,CAAC,CACtE;EACDC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC;EACjCC,SAAS,EAAE;EACT;EACA;IACEf,IAAI,EAAE,YAAY;IAClBgB,OAAO,EAAE,UAAU;IACnBC,QAAQ,EAAE,MAAM;IAChBN,SAAS,EAAE,WAAW;IACtBC,QAAQ,EAAE,EAAE;IACZC,QAAQ,EAAE,GAAG,CAAE;IACf;IACA;IACA;EACF,CAAC,CACF;EACDK,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}
+{"version":3,"names":["PUSHUP_CONFIG","name","type","postureFamily","visibilityThreshold","cameraAngle","angles","landmarkA","landmarkB","landmarkC","phases","phase","angleName","minAngle","maxAngle","repSequence","formRules","holdDurationMs"],"sourceRoot":"../../../src","sources":["config/pushup.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;;AAEA,OAAO,MAAMA,aAA6B,GAAG;EAC3CC,IAAI,EAAE,SAAS;EACfC,IAAI,EAAE,KAAK;EACXC,aAAa,EAAE,iBAAiB;EAChCC,mBAAmB,EAAE,GAAG;EACxBC,WAAW,EAAE,OAAO;EACpBC,MAAM,EAAE,CACN;IAAEL,IAAI,EAAE,WAAW;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,EAClE;IAAER,IAAI,EAAE,YAAY;IAAEM,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE,EAAE;IAAEC,SAAS,EAAE;EAAG,CAAC,CACpE;EACDC,MAAM,EAAE,CACN;IAAEC,KAAK,EAAE,IAAI;IAAEC,SAAS,EAAE,WAAW;IAAEC,QAAQ,EAAE,GAAG;IAAEC,QAAQ,EAAE;EAAI,CAAC,EACrE;IAAEH,KAAK,EAAE,MAAM;IAAEC,SAAS,EAAE,WAAW;IAAEC,QAAQ,EAAE,CAAC;IAAEC,QAAQ,EAAE;EAAI,CAAC,CACtE;EACDC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC;EACjCC,SAAS,EAAE,EAAE;EACbC,cAAc,EAAE;AAClB,CAAC","ignoreList":[]}

package/lib/typescript/src/config/pushup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pushup.d.ts","sourceRoot":"","sources":["../../../../src/config/pushup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAQlE,eAAO,MAAM,aAAa,EAAE,cAgC3B,CAAC"}
+{"version":3,"file":"pushup.d.ts","sourceRoot":"","sources":["../../../../src/config/pushup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAQlE,eAAO,MAAM,aAAa,EAAE,cAiB3B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-pose-exercises",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "Real-time on-device exercise tracking for React Native. Rep counting, form validation, and skeleton overlay powered by Apple Vision (iOS) and Google ML Kit (Android) with VisionCamera v5 via Nitro Modules.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/config/pushup.ts

@@ -9,33 +9,18 @@ import type { ExerciseConfig } from '../NitroPoseExercises.nitro';
 export const PUSHUP_CONFIG: ExerciseConfig = {
   name: 'Push-Up',
   type: 'rep',
-  postureFamily: 'none',
-  visibilityThreshold: 0.3,
+  postureFamily: 'horizontalProne',
+  visibilityThreshold: 0.1,
   cameraAngle: 'front',
   angles: [
     { name: 'leftElbow', landmarkA: 11, landmarkB: 13, landmarkC: 15 },
     { name: 'rightElbow', landmarkA: 12, landmarkB: 14, landmarkC: 16 },
   ],
   phases: [
-    // Calibrated for 2D-projected angles in front-facing portrait filming.
-    // Real anatomical 180° appears as ~140-150° due to perspective foreshortening.
     { phase: 'up', angleName: 'leftElbow', minAngle: 130, maxAngle: 180 },
-    { phase: 'down', angleName: 'leftElbow', minAngle: 40, maxAngle: 80 },
+    { phase: 'down', angleName: 'leftElbow', minAngle: 0, maxAngle: 120 },
   ],
   repSequence: ['up', 'down', 'up'],
-  formRules: [
-    // Trigger when descending but stalled above true-down threshold
-    {
-      name: 'shallowRep',
-      message: 'Go lower',
-      severity: 'info',
-      angleName: 'leftElbow',
-      minAngle: 80,
-      maxAngle: 130, // "limbo zone" — too low to be up, too high to be down
-      // Note: ideally this only fires when angle has stalled, not on the way down.
-      // If your formRule engine doesn't support velocity/stall detection,
-      // accept that it'll fire briefly during transitions too.
-    },
-  ],
+  formRules: [],
   holdDurationMs: 0,
 };