Align final check with step feedback flow

Author: ShengkaiXu

evaluation_function/evaluation.py

@@ -817,27 +817,66 @@ def advice_text() -> str:
             for e in selected_errors
             if isinstance(e, dict)
         }
+        driving_gear, smallgear, biggear = _get_gear_counts(out)
+        shaft_long, shaft_short, shaft_total = _get_shaft_counts(out)
+        spacer_long, spacer_short, spacer_total = _get_spacer_counts(out)
 
         # Highest-priority prerequisite errors
         if "E_NO_GEARS" in codes:
-            return False, MESSAGE_POLICY["mesh_ratio"]["fail"]
+            return False, MESSAGE_POLICY["gear_inventory"]["no_gears"].format(
+                driving_gear=driving_gear,
+                smallgear=smallgear,
+                biggear=biggear,
+            )
+
+        if "E_NO_SHAFTS" in codes:
+            return False, MESSAGE_POLICY["shaft"]["none_detected"]
 
-        if "E_NO_SHAFTS" in codes or "E_NO_GEAR11" in codes:
+        if "E_NO_GEAR11" in codes:
             return False, MESSAGE_POLICY["mesh_ratio"]["fail"]
 
+        # Shaft checks
+        if (
+            "E_SHAFT_COUNT_MISMATCH" in codes
+            or "E_SHAFT2_NOT_FOUND" in codes
+        ):
+            if shaft_total == 0:
+                return False, MESSAGE_POLICY["shaft"]["none_detected"]
+            if shaft_total > 2:
+                return False, MESSAGE_POLICY["shaft"]["too_many"]
+            if shaft_total == 1 and shaft_long == 1 and shaft_short == 0:
+                return False, MESSAGE_POLICY["shaft"]["short_missing"]
+            if shaft_total == 1 and shaft_short == 1 and shaft_long == 0:
+                return False, MESSAGE_POLICY["shaft"]["long_missing"]
+            return False, MESSAGE_POLICY["shaft"]["count_fail"]
+
+        if "E_SHAFT_TYPE_CONFUSION" in codes:
+            return False, MESSAGE_POLICY["shaft"]["type_confusion"]
+
+        if (
+            "E_SHAFT_POSITION_SWAP" in codes
+            or "E_SHAFT2_CLASS_MISMATCH" in codes
+            or "E_SHAFT3_CLASS_MISMATCH" in codes
+        ):
+            return False, MESSAGE_POLICY["shaft"]["position_swap"]
+
         # Spacer checks
         if "E_SPACER_SHORT_MISSING" in codes:
             return False, MESSAGE_POLICY["spacer"]["short_missing"]
 
         if "E_SPACER_LONG_MISSING" in codes:
             return False, MESSAGE_POLICY["spacer"]["long_missing"]
 
-        if "E_SPACER_COUNT_MISMATCH" in codes:
-            return False, MESSAGE_POLICY["spacer"]["count_fail"]
-
         if "E_SPACER_TYPE_CONFUSION" in codes:
             return False, MESSAGE_POLICY["spacer"]["type_confusion"]
 
+        if "E_SPACER_COUNT_MISMATCH" in codes:
+            if spacer_total == 0:
+                return False, MESSAGE_POLICY["spacer"]["none_detected"]
+            if spacer_total > 2:
+                return False, MESSAGE_POLICY["spacer"]["too_many"]
+            return False, MESSAGE_POLICY["spacer"]["count_fail"]
+
         if (
             "E_SPACER_ASSIGNMENT_FAIL" in codes
             or "E_SPACER2_MISSING" in codes
@@ -855,28 +894,33 @@ def advice_text() -> str:
         if "E_SPACER_DISTANCE_ORDER" in codes:
             return False, MESSAGE_POLICY["spacer"]["distance_order"]
 
-        # Shaft checks
-        if (
-            "E_SHAFT_POSITION_SWAP" in codes
-            or "E_SHAFT2_CLASS_MISMATCH" in codes
-            or "E_SHAFT3_CLASS_MISMATCH" in codes
-        ):
-            return False, MESSAGE_POLICY["shaft"]["position_swap"]
-
-        if (
-            "E_SHAFT_COUNT_MISMATCH" in codes
-            or "E_SHAFT2_NOT_FOUND" in codes
-        ):
-            return False, MESSAGE_POLICY["shaft"]["count_fail"]
+        # Mesh and consistency checks
+        if "E_GEAR_BIG_SMALL_INCONSISTENT" in codes:
+            return False, MESSAGE_POLICY["gear_inventory"]["big_small_inconsistent"].format(
+                driving_gear=driving_gear,
+                smallgear=smallgear,
+                biggear=biggear,
+            )
 
-        if "E_SHAFT_TYPE_CONFUSION" in codes:
-            return False, MESSAGE_POLICY["shaft"]["type_confusion"]
+        if "E_GEAR_CONTACT_INCONSISTENT" in codes:
+            return False, MESSAGE_POLICY["gear_inventory"]["contact_consistency_fail"].format(
+                driving_gear=driving_gear,
+                smallgear=smallgear,
+                biggear=biggear,
+            )
 
-        # Mesh and consistency checks
         if (
             "E_MISMESH_DETECTED" in codes
             or "E_MESH_MISMATCH" in codes
-            or "E_CONTACT_COUNT_MISMATCH" in codes
+        ):
+            return False, MESSAGE_POLICY["gear_inventory"]["mismatch_fail"].format(
+                driving_gear=driving_gear,
+                smallgear=smallgear,
+                biggear=biggear,
+            )
+
+        if (
+            "E_CONTACT_COUNT_MISMATCH" in codes
             or "E_GEAR_COUNT_UNSUPPORTED" in codes
         ):
             return False, MESSAGE_POLICY["mesh_ratio"]["fail"]

evaluation_function/evaluation_test.py

@@ -369,6 +369,59 @@ def test_spacer_position_checked_before_distance_order(self):
 
         self.assertEqual(errors[0]["code"], "E_SPACER_POSITION_MISMATCH")
 
+    def test_mesh_ratio_uses_specific_shaft_count_feedback(self):
+        errors = [{"code": "E_SHAFT_COUNT_MISMATCH", "message": "Expected 2 shafts."}]
+
+        is_correct, message = _build_student_message(
+            task="mesh_ratio",
+            img_bgr=np.zeros((10, 10, 3), dtype=np.uint8),
+            out={"shaft_counts": {"shaft_long": 1, "shaft_short": 0}, "errors": errors},
+            errors=errors,
+            selected_errors=errors,
+            part_type="",
+        )
+
+        self.assertFalse(is_correct)
+        self.assertIn("short shaft", message.lower())
+
+    def test_mesh_ratio_uses_specific_spacer_count_feedback(self):
+        errors = [{"code": "E_SPACER_COUNT_MISMATCH", "message": "Expected 2 spacers."}]
+
+        is_correct, message = _build_student_message(
+            task="mesh_ratio",
+            img_bgr=np.zeros((10, 10, 3), dtype=np.uint8),
+            out={"spacer_counts": {"spacer_long": 2, "spacer_short": 1}, "errors": errors},
+            errors=errors,
+            selected_errors=errors,
+            part_type="",
+        )
+
+        self.assertFalse(is_correct)
+        self.assertIn("too many spacers", message.lower())
+
+    def test_mesh_ratio_prioritizes_shaft_before_spacer(self):
+        errors = [
+            {"code": "E_SHAFT_COUNT_MISMATCH", "message": "Expected 2 shafts."},
+            {"code": "E_SPACER_COUNT_MISMATCH", "message": "Expected 2 spacers."},
+        ]
+
+        is_correct, message = _build_student_message(
+            task="mesh_ratio",
+            img_bgr=np.zeros((10, 10, 3), dtype=np.uint8),
+            out={
+                "shaft_counts": {"shaft_long": 1, "shaft_short": 0},
+                "spacer_counts": {"spacer_long": 2, "spacer_short": 1},
+                "errors": errors,
+            },
+            errors=errors,
+            selected_errors=errors,
+            part_type="",
+        )
+
+        self.assertFalse(is_correct)
+        self.assertIn("short shaft", message.lower())
+        self.assertNotIn("too many spacers", message.lower())
+
 
 if __name__ == "__main__":
     unittest.main()

evaluation_function/yolo_pipeline.py

@@ -2663,18 +2663,47 @@ def _need_shafts() -> bool:
             gears, spacers, shaft_obbs
         )
 
+    shaft_counts = get_shaft_counts(shaft_obbs)
+    spacer_counts = get_spacer_counts(spacers)
+
     errors: List[Dict[str, str]] = []
-    if ENABLE_ERROR_CHECKS and shaft_obbs:
-        errors = evaluate_assembly_errors(
-            gears=gears,
-            spacers=spacers,
-            shafts=shaft_obbs,
-            mesh_boxes=mesh_boxes,
-            mismesh_boxes=mismesh_boxes,
-            gear11_gid=int(gear11_gid),
-            gear_to_si=gear_to_si,
-            spacer_to_si=spacer_to_si,
-        )
+    if ENABLE_ERROR_CHECKS:
+        if not shaft_obbs:
+            errors = [{"code": "E_NO_SHAFTS", "message": "No shafts detected."}]
+        else:
+            errors = evaluate_shaft_step_errors(
+                gears=gears,
+                shafts=shaft_obbs,
+                gear11_gid=int(gear11_gid),
+            )
+
+        if not errors:
+            errors = evaluate_spacer_step_errors(
+                gears=gears,
+                spacers=spacers,
+                shafts=shaft_obbs,
+                gear11_gid=int(gear11_gid),
+                spacer_to_si=spacer_to_si,
+            )
+
+        if not errors:
+            errors, _gear_counts = evaluate_gear_inventory_step(
+                gears=gears,
+                mesh_boxes=mesh_boxes,
+                mismesh_boxes=mismesh_boxes,
+            )
+
+        if not errors:
+            errors = evaluate_assembly_errors(
+                gears=gears,
+                spacers=spacers,
+                shafts=shaft_obbs,
+                mesh_boxes=mesh_boxes,
+                mismesh_boxes=mismesh_boxes,
+                gear11_gid=int(gear11_gid),
+                gear_to_si=gear_to_si,
+                spacer_to_si=spacer_to_si,
+            )
 
     gear_names, gear_stage, chain_pairs = stage_role_naming_chain(
         gears=gears,
@@ -2703,6 +2732,8 @@ def _need_shafts() -> bool:
             "stages": num_stages,
         },
         "counts": get_gear_counts(gears),
+        "shaft_counts": shaft_counts,
+        "spacer_counts": spacer_counts,
         "detections": {
             "gear_dets": gear_dets,
             "aux_dets": aux_dets,