diff --git a/examples/rvc-app/rvc-common/include/rvc-device.h b/examples/rvc-app/rvc-common/include/rvc-device.h
index b66ce32..e2011f6 100644
--- a/examples/rvc-app/rvc-common/include/rvc-device.h
+++ b/examples/rvc-app/rvc-common/include/rvc-device.h
@@ -61,7 +61,7 @@
         mOperationalStateDelegate.SetGoHomeCallback(&RvcDevice::HandleOpStateGoHomeCallback, this);
 
         mServiceAreaDelegate.SetIsSetSelectedAreasAllowedCallback(&RvcDevice::SaIsSetSelectedAreasAllowed, this);
-        mServiceAreaDelegate.SetHandleSkipCurrentAreaCallback(&RvcDevice::SaHandleSkipCurrentArea, this);
+        mServiceAreaDelegate.SetHandleSkipAreaCallback(&RvcDevice::SaHandleSkipArea, this);
         mServiceAreaDelegate.SetIsSupportedAreasChangeAllowedCallback(&RvcDevice::SaIsSupportedAreasChangeAllowed, this);
         mServiceAreaDelegate.SetIsSupportedMapChangeAllowedCallback(&RvcDevice::SaIsSupportedMapChangeAllowed, this);
     }
@@ -104,7 +104,7 @@
 
     bool SaIsSetSelectedAreasAllowed(MutableCharSpan & statusText);
 
-    bool SaHandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText);
+    bool SaHandleSkipArea(uint32_t skippedArea, MutableCharSpan & skipStatusText);
 
     bool SaIsSupportedAreasChangeAllowed();
 
diff --git a/examples/rvc-app/rvc-common/include/rvc-service-area-delegate.h b/examples/rvc-app/rvc-common/include/rvc-service-area-delegate.h
index fdad4f8..c6be8aa 100644
--- a/examples/rvc-app/rvc-common/include/rvc-service-area-delegate.h
+++ b/examples/rvc-app/rvc-common/include/rvc-service-area-delegate.h
@@ -30,7 +30,7 @@
 class RvcDevice;
 
 typedef bool (RvcDevice::*IsSetSelectedAreasAllowedCallback)(MutableCharSpan & statusText);
-typedef bool (RvcDevice::*HandleSkipCurrentAreaCallback)(uint32_t skippedArea, MutableCharSpan & skipStatusText);
+typedef bool (RvcDevice::*HandleSkipAreaCallback)(uint32_t skippedArea, MutableCharSpan & skipStatusText);
 typedef bool (RvcDevice::*IsChangeAllowedSimpleCallback)();
 
 namespace ServiceArea {
@@ -46,8 +46,8 @@
 
     RvcDevice * mIsSetSelectedAreasAllowedDeviceInstance;
     IsSetSelectedAreasAllowedCallback mIsSetSelectedAreasAllowedCallback;
-    RvcDevice * mHandleSkipCurrentAreaDeviceInstance;
-    HandleSkipCurrentAreaCallback mHandleSkipCurrentAreaCallback;
+    RvcDevice * mHandleSkipAreaDeviceInstance;
+    HandleSkipAreaCallback mHandleSkipAreaCallback;
     RvcDevice * mIsSupportedAreasChangeAllowedDeviceInstance;
     IsChangeAllowedSimpleCallback mIsSupportedAreasChangeAllowedCallback;
     RvcDevice * mIsSupportedMapChangeAllowedDeviceInstance;
@@ -82,7 +82,7 @@
     bool IsValidSelectAreasSet(const ServiceArea::Commands::SelectAreas::DecodableType & req,
                                ServiceArea::SelectAreasStatus & areaStatus, MutableCharSpan & statusText) override;
 
-    bool HandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText) override;
+    bool HandleSkipArea(uint32_t skippedArea, MutableCharSpan & skipStatusText) override;
 
     //*************************************************************************
     // Supported Areas accessors
@@ -169,10 +169,10 @@
         mIsSetSelectedAreasAllowedDeviceInstance = instance;
     }
 
-    void SetHandleSkipCurrentAreaCallback(HandleSkipCurrentAreaCallback callback, RvcDevice * instance)
+    void SetHandleSkipAreaCallback(HandleSkipAreaCallback callback, RvcDevice * instance)
     {
-        mHandleSkipCurrentAreaCallback       = callback;
-        mHandleSkipCurrentAreaDeviceInstance = instance;
+        mHandleSkipAreaCallback       = callback;
+        mHandleSkipAreaDeviceInstance = instance;
     }
 
     void SetIsSupportedAreasChangeAllowedCallback(IsChangeAllowedSimpleCallback callback, RvcDevice * instance)
diff --git a/examples/rvc-app/rvc-common/pics/RVC Clean Mode Cluster Test Plan.xml b/examples/rvc-app/rvc-common/pics/RVC Clean Mode Cluster Test Plan.xml
index ce0ddaa..fa0b258 100644
--- a/examples/rvc-app/rvc-common/pics/RVC Clean Mode Cluster Test Plan.xml
+++ b/examples/rvc-app/rvc-common/pics/RVC Clean Mode Cluster Test Plan.xml
@@ -1,13 +1,20 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-Autogenerated xml file - Version No:V_21_TE2-FALL2023
-Generated date:2023-08-03 21:56:43
+Autogenerated xml file - Version No:V_32_1_4_TE2_FALL_2024
+Generated date:2024-08-09 05:01:19
 Cluster Name -RVC Clean Mode Cluster Test Plan
 XML PICS -Ref Document:
-version master a35005c,
+version master 8f9bd8c,
 Draft
-2023-08-03 08:35:53 -0700
+2024-08-08 16:19:15 -0700
 --><clusterPICS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Generic-PICS-XML-Schema.xsd">
-	<!--General cluster information-->
+	<!--General cluster information
+	Notes:
+	- PICS definition table contains PICS from other clusters that may be needed to run all the test cases.
+	- To load these PICS, refer to the following clusters.
+	PICS                                               Cluster Name                                       Reference
+	RVCRUNM.S.A0000                                    RVC Run Mode Cluster Test Plan                     103.2.2. [TC-RVCCLEANM-2.2] Change to Mode restrictions with DUT as Server - allclusters.html[pdf]
+	RVCRUNM.S.A0001                                    RVC Run Mode Cluster Test Plan                     103.2.2. [TC-RVCCLEANM-2.2] Change to Mode restrictions with DUT as Server - allclusters.html[pdf]
+	-->
 	<name>RVC Clean Mode Cluster Test Plan</name>
 	<clusterId> </clusterId>
 	<picsRoot> </picsRoot>
@@ -16,7 +23,7 @@
 		<picsItem>
 			<itemNumber>RVCCLEANM.S</itemNumber>
 			<feature>Does the device implement the RVCCLEANM cluster as a server?</feature>
-			<reference>89.1. Role - allclusters.html[pdf]</reference>
+			<reference>99.1. Role - allclusters.html[pdf]</reference>
 			<status>O</status>
 			<support>true</support>
 		</picsItem>
@@ -26,16 +33,14 @@
 		<pixitItem>
 			<itemNumber>PIXIT.RVCCLEANM.MODE_CHANGE_FAIL</itemNumber>
 			<feature>Id of mode the device will fail to transition to, given its current state</feature>
-			<reference>90. PIXIT Definition - allclusters.html[pdf]</reference>
-			<status cond="RVCCLEANM.S">O</status>
-			<support>0x01</support>
+			<reference>100. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCCLEANM.S">O</status><support>n/a</support>
 		</pixitItem>
 		<pixitItem>
 			<itemNumber>PIXIT.RVCCLEANM.MODE_CHANGE_OK</itemNumber>
 			<feature>Id of mode the device will successfully transition to, given its current state</feature>
-			<reference>90. PIXIT Definition - allclusters.html[pdf]</reference>
-			<status cond="RVCCLEANM.S">O</status>
-			<support>0x01</support>
+			<reference>100. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCCLEANM.S">O</status><support>n/a</support>
 		</pixitItem>
 	</pixit>
 	<!--Server side PICS-->
@@ -45,31 +50,17 @@
 			<picsItem>
 				<itemNumber>RVCCLEANM.S.A0000</itemNumber>
 				<feature>Does the device implement the SupportedModes attribute?</feature>
-				<reference>89.2.2. Attributes - allclusters.html[pdf]</reference>
+				<reference>99.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCCLEANM.S.A0001</itemNumber>
 				<feature>Does the device implement the CurrentMode attribute?</feature>
-				<reference>89.2.2. Attributes - allclusters.html[pdf]</reference>
+				<reference>99.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">M</status>
 				<support>true</support>
 			</picsItem>
-			<picsItem>
-				<itemNumber>RVCCLEANM.S.A0002</itemNumber>
-				<feature>Does the device implement the StartUpMode attribute?</feature>
-				<reference>89.2.2. Attributes - allclusters.html[pdf]</reference>
-				<status cond="RVCCLEANM.S">O</status>
-				<support>false</support>
-			</picsItem>
-			<picsItem>
-				<itemNumber>RVCCLEANM.S.A0003</itemNumber>
-				<feature>Does the device implement the OnMode attribute?</feature>
-				<reference>89.2.2. Attributes - allclusters.html[pdf]</reference>
-				<status cond="RVCCLEANM.S.F00">M</status>
-				<support>false</support>
-			</picsItem>
 		</attributes>
 		<!--Events PICS write-->
 		<events/>
@@ -78,7 +69,7 @@
 			<picsItem>
 				<itemNumber>RVCCLEANM.S.C01.Tx</itemNumber>
 				<feature>Does the device implement sending the ChangeToModeResponse command?</feature>
-				<reference>89.2.4. Commands generated - allclusters.html[pdf]</reference>
+				<reference>99.2.3. Commands generated - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">M</status>
 				<support>true</support>
 			</picsItem>
@@ -88,7 +79,7 @@
 			<picsItem>
 				<itemNumber>RVCCLEANM.S.C00.Rsp</itemNumber>
 				<feature>Does the device implement receiving the ChangeToMode command?</feature>
-				<reference>89.2.3. Commands received - allclusters.html[pdf]</reference>
+				<reference>99.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">M</status>
 				<support>true</support>
 			</picsItem>
@@ -96,9 +87,9 @@
 		<!--Features PICS write-->
 		<features>
 			<picsItem>
-				<itemNumber>RVCCLEANM.S.F00</itemNumber>
-				<feature>Does the device support depending on an On/Off cluster implemented on the same endpoint?</feature>
-				<reference>89.2.1. Features - allclusters.html[pdf]</reference>
+				<itemNumber>RVCCLEANM.S.F16</itemNumber>
+				<feature>Does the device support changing clean modes from non-Idle states?</feature>
+				<reference>101.1. Features - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">O</status>
 				<support>false</support>
 			</picsItem>
@@ -108,10 +99,17 @@
 			<picsItem>
 				<itemNumber>RVCCLEANM.S.M.CAN_TEST_MODE_FAILURE</itemNumber>
 				<feature>Does the DUT support testing the failed ChangeToMode command?</feature>
-				<reference>89.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>99.2.4. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCCLEANM.S">O</status>
 				<support>true</support>
 			</picsItem>
+			<picsItem>
+				<itemNumber>RVCCLEANM.S.M.CAN_MANUALLY_CONTROLLED</itemNumber>
+				<feature>Can the mode change be manually controlled?</feature>
+				<reference>99.2.4. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="RVCCLEANM.S">O</status>
+				<support>false</support>
+			</picsItem>
 		</manually>
 	</clusterSide>
 	<!--Client side PICS-->
diff --git a/examples/rvc-app/rvc-common/pics/RVC Operational State Cluster Test Plan.xml b/examples/rvc-app/rvc-common/pics/RVC Operational State Cluster Test Plan.xml
index c600445..59028fa 100644
--- a/examples/rvc-app/rvc-common/pics/RVC Operational State Cluster Test Plan.xml
+++ b/examples/rvc-app/rvc-common/pics/RVC Operational State Cluster Test Plan.xml
@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-Autogenerated xml file - Version No:V_21_TE2-FALL2023
-Generated date:2023-08-03 21:56:43
+Autogenerated xml file - Version No:V_32_1_4_TE2_FALL_2024
+Generated date:2024-08-09 05:01:19
 Cluster Name -RVC Operational State Cluster Test Plan
 XML PICS -Ref Document:
-version master a35005c,
+version master 8f9bd8c,
 Draft
-2023-08-03 08:35:53 -0700
+2024-08-08 16:19:15 -0700
 --><clusterPICS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Generic-PICS-XML-Schema.xsd">
 	<!--General cluster information-->
 	<name>RVC Operational State Cluster Test Plan</name>
@@ -15,8 +15,8 @@
 	<usage>
 		<picsItem>
 			<itemNumber>RVCOPSTATE.S</itemNumber>
-			<feature>Does the device implement the RVC Operational State cluster as a server?</feature>
-			<reference>223.1. Role - allclusters.html[pdf]</reference>
+			<feature>Does the device implement the RVC Operational State Cluster as a server?</feature>
+			<reference>238.1. Role - allclusters.html[pdf]</reference>
 			<status>O</status>
 			<support>true</support>
 		</picsItem>
@@ -30,42 +30,42 @@
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0000</itemNumber>
 				<feature>Does the device implement the PhaseList attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0001</itemNumber>
 				<feature>Does the device implement the CurrentPhase attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0002</itemNumber>
 				<feature>Does the device implement the CountdownTime attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>false</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0003</itemNumber>
 				<feature>Does the device implement the OperationalStateList attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0004</itemNumber>
 				<feature>Does the device implement the OperationalState attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.A0005</itemNumber>
 				<feature>Does the device implement the OperationalError attribute?</feature>
-				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
+				<reference>238.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
@@ -75,14 +75,14 @@
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.E00</itemNumber>
 				<feature>Does the device implement the OperationalError Event ?</feature>
-				<reference>223.2.4. Events - allclusters.html[pdf]</reference>
+				<reference>238.2.4. Events - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.E01</itemNumber>
 				<feature>Does the device implement the OperationCompletion Event ?</feature>
-				<reference>223.2.4. Events - allclusters.html[pdf]</reference>
+				<reference>238.2.4. Events - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
@@ -92,8 +92,8 @@
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.C04.Tx</itemNumber>
 				<feature>Does the device implement generating the OperationalCommandResponse command?</feature>
-				<reference>223.2.3. Commands generated - allclusters.html[pdf]</reference>
-				<status cond="RVCOPSTATE.S.C00.Rsp  OR  RVCOPSTATE.S.C01.Rsp  OR  RVCOPSTATE.S.C02.Rsp  OR  RVCOPSTATE.S.C03.Rsp">M</status>
+				<reference>238.2.3. Commands generated - allclusters.html[pdf]</reference>
+				<status cond="RVCOPSTATE.S AND (RVCOPSTATE.S.C00.Rsp  OR  RVCOPSTATE.S.C01.Rsp  OR  RVCOPSTATE.S.C02.Rsp  OR  RVCOPSTATE.S.C03.Rsp)">M</status>
 				<support>true</support>
 			</picsItem>
 		</commandsGenerated>
@@ -102,28 +102,35 @@
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.C00.Rsp</itemNumber>
 				<feature>Does the device implement receiving the Pause command?</feature>
-				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
+				<reference>238.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.C01.Rsp</itemNumber>
 				<feature>Does the device implement receiving the Stop command?</feature>
-				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
+				<reference>238.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>false</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.C02.Rsp</itemNumber>
 				<feature>Does the device implement receiving the Start command?</feature>
-				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
+				<reference>238.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>false</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.C03.Rsp</itemNumber>
 				<feature>Does the device implement receiving the Resume command?</feature>
-				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
+				<reference>238.2.2. Commands received - allclusters.html[pdf]</reference>
+				<status cond="RVCOPSTATE.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>RVCOPSTATE.S.C80.Rsp</itemNumber>
+				<feature>Does the device implement receiving the GoHome command?</feature>
+				<reference>238.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
@@ -135,136 +142,143 @@
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_STOPPED</itemNumber>
 				<feature>Does the DUT support testing the Stopped(0x00) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_RUNNING</itemNumber>
 				<feature>Does the DUT support testing the Running(0x01) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_PAUSED</itemNumber>
 				<feature>Does the DUT support testing the Paused(0x02) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_ERROR</itemNumber>
 				<feature>Does the DUT support testing the Error(0x03) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_SEEKING_CHARGER</itemNumber>
 				<feature>Does the DUT support testing the SeekingCharger(0x40) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_CHARGING</itemNumber>
 				<feature>Does the DUT support testing the Charging(0x41) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ST_DOCKED</itemNumber>
 				<feature>Does the DUT support testing the Docked(0x42) operational state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_NO_ERROR</itemNumber>
 				<feature>Does the DUT support testing the NoError(0x00) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_UNABLE_TO_START_OR_RESUME</itemNumber>
 				<feature>Does the DUT support testing the UnableToStartOrResume(0x01) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_UNABLE_TO_COMPLETE_OPERATION</itemNumber>
 				<feature>Does the DUT support testing the UnableToCompleteOperation(0x02) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_COMMAND_INVALID_IN_STATE</itemNumber>
 				<feature>Does the DUT support testing the CommandInvalidInState(0x03) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_FAILED_TO_FIND_CHARGING_DOCK</itemNumber>
 				<feature>Does the DUT support testing the FailedToFindChargingDock(0x40) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_STUCK</itemNumber>
 				<feature>Does the DUT support testing the Stuck(0x41) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_DUST_BIN_MISSING</itemNumber>
 				<feature>Does the DUT support testing the DustBinMissing(0x42) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_DUST_BIN_FULL</itemNumber>
 				<feature>Does the DUT support testing the DustBinFull(0x43) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_EMPTY</itemNumber>
 				<feature>Does the DUT support testing the WaterTankEmpty(0x44) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_MISSING</itemNumber>
 				<feature>Does the DUT support testing the WaterTankMissing(0x45) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_LID_OPEN</itemNumber>
 				<feature>Does the DUT support testing the WaterTankLidOpen(0x46) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCOPSTATE.S.M.ERR_MOP_CLEANING_PAD_MISSING</itemNumber>
 				<feature>Does the DUT support testing the MopCleaningPadMissing(0x47) error state?</feature>
-				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCOPSTATE.S">O</status>
 				<support>true</support>
 			</picsItem>
+			<picsItem>
+				<itemNumber>RVCOPSTATE.S.M.RESUME_AFTER_ERR</itemNumber>
+				<feature>Does the DUT support testing the Resume command after cleared error?</feature>
+				<reference>238.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="RVCOPSTATE.S">O</status>
+				<support>false</support>
+			</picsItem>
 		</manually>
 	</clusterSide>
 	<!--Client side PICS-->
diff --git a/examples/rvc-app/rvc-common/pics/RVC Run Mode Cluster Test Plan.xml b/examples/rvc-app/rvc-common/pics/RVC Run Mode Cluster Test Plan.xml
index 0bdd953..a3305b8 100644
--- a/examples/rvc-app/rvc-common/pics/RVC Run Mode Cluster Test Plan.xml
+++ b/examples/rvc-app/rvc-common/pics/RVC Run Mode Cluster Test Plan.xml
@@ -1,13 +1,19 @@
 <?xml version="1.0" encoding="utf-8"?><!--
-Autogenerated xml file - Version No:V_21_TE2-FALL2023
-Generated date:2023-08-03 21:56:43
+Autogenerated xml file - Version No:V_32_1_4_TE2_FALL_2024
+Generated date:2024-08-09 05:01:19
 Cluster Name -RVC Run Mode Cluster Test Plan
 XML PICS -Ref Document:
-version master a35005c,
+version master 8f9bd8c,
 Draft
-2023-08-03 08:35:53 -0700
+2024-08-08 16:19:15 -0700
 --><clusterPICS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Generic-PICS-XML-Schema.xsd">
-	<!--General cluster information-->
+	<!--General cluster information
+	Notes:
+	- PICS definition table contains PICS from other clusters that may be needed to run all the test cases.
+	- To load these PICS, refer to the following clusters.
+	PICS                                               Cluster Name                                       Reference
+	RVCOPSTATE.S.A0004                                 RVC Operational State Cluster Test Plan            97.2.2. [TC-RVCRUNM-2.2] Change to Mode restrictions with DUT as Server - allclusters.html[pdf]
+	-->
 	<name>RVC Run Mode Cluster Test Plan</name>
 	<clusterId> </clusterId>
 	<picsRoot> </picsRoot>
@@ -16,7 +22,7 @@
 		<picsItem>
 			<itemNumber>RVCRUNM.S</itemNumber>
 			<feature>Does the device implement the RVCRUNM cluster as a server?</feature>
-			<reference>84.1. Role - allclusters.html[pdf]</reference>
+			<reference>93.1. Role - allclusters.html[pdf]</reference>
 			<status>O</status>
 			<support>true</support>
 		</picsItem>
@@ -26,16 +32,26 @@
 		<pixitItem>
 			<itemNumber>PIXIT.RVCRUNM.MODE_CHANGE_FAIL</itemNumber>
 			<feature>Id of mode the device will fail to transition to, given its current state</feature>
-			<reference>85. PIXIT Definition - allclusters.html[pdf]</reference>
-			<status cond="RVCRUNM.S">O</status>
-			<support>0x02</support>
+			<reference>95. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCRUNM.S">O</status><support/>
 		</pixitItem>
 		<pixitItem>
 			<itemNumber>PIXIT.RVCRUNM.MODE_CHANGE_OK</itemNumber>
 			<feature>Id of mode the device will successfully transition to, given its current state</feature>
-			<reference>85. PIXIT Definition - allclusters.html[pdf]</reference>
-			<status cond="RVCRUNM.S">O</status>
-			<support>0x00</support>
+			<reference>95. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCRUNM.S">O</status><support/>
+		</pixitItem>
+		<pixitItem>
+			<itemNumber>PIXIT.RVCRUNM.MODE_A</itemNumber>
+			<feature>Id of non-Idle mode the device can successfully switch to, given its current state</feature>
+			<reference>95. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCRUNM.S">O</status><support>0x01</support>
+		</pixitItem>
+		<pixitItem>
+			<itemNumber>PIXIT.RVCRUNM.MODE_B</itemNumber>
+			<feature>Id of non-Idle mode the device can successfully switch to, given its current state</feature>
+			<reference>95. PIXIT Definition - allclusters.html[pdf]</reference>
+			<status cond="RVCRUNM.S">O</status><support>0x02</support>
 		</pixitItem>
 	</pixit>
 	<!--Server side PICS-->
@@ -45,31 +61,17 @@
 			<picsItem>
 				<itemNumber>RVCRUNM.S.A0000</itemNumber>
 				<feature>Does the device implement the SupportedModes attribute?</feature>
-				<reference>84.2.2. Attributes - allclusters.html[pdf]</reference>
+				<reference>93.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">M</status>
 				<support>true</support>
 			</picsItem>
 			<picsItem>
 				<itemNumber>RVCRUNM.S.A0001</itemNumber>
 				<feature>Does the device implement the CurrentMode attribute?</feature>
-				<reference>84.2.2. Attributes - allclusters.html[pdf]</reference>
+				<reference>93.2.1. Attributes - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">M</status>
 				<support>true</support>
 			</picsItem>
-			<picsItem>
-				<itemNumber>RVCRUNM.S.A0002</itemNumber>
-				<feature>Does the device implement the StartUpMode attribute?</feature>
-				<reference>84.2.2. Attributes - allclusters.html[pdf]</reference>
-				<status cond="RVCRUNM.S">O</status>
-				<support>false</support>
-			</picsItem>
-			<picsItem>
-				<itemNumber>RVCRUNM.S.A0003</itemNumber>
-				<feature>Does the device implement the OnMode attribute?</feature>
-				<reference>84.2.2. Attributes - allclusters.html[pdf]</reference>
-				<status cond="RVCRUNM.S.F00">M</status>
-				<support>false</support>
-			</picsItem>
 		</attributes>
 		<!--Events PICS write-->
 		<events/>
@@ -78,7 +80,7 @@
 			<picsItem>
 				<itemNumber>RVCRUNM.S.C01.Tx</itemNumber>
 				<feature>Does the device implement sending the ChangeToModeResponse command?</feature>
-				<reference>84.2.4. Commands generated - allclusters.html[pdf]</reference>
+				<reference>93.2.3. Commands generated - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">M</status>
 				<support>true</support>
 			</picsItem>
@@ -88,7 +90,7 @@
 			<picsItem>
 				<itemNumber>RVCRUNM.S.C00.Rsp</itemNumber>
 				<feature>Does the device implement receiving the ChangeToMode command?</feature>
-				<reference>84.2.3. Commands received - allclusters.html[pdf]</reference>
+				<reference>93.2.2. Commands received - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">M</status>
 				<support>true</support>
 			</picsItem>
@@ -96,9 +98,9 @@
 		<!--Features PICS write-->
 		<features>
 			<picsItem>
-				<itemNumber>RVCRUNM.S.F00</itemNumber>
-				<feature>Does the device support depending on an On/Off cluster implemented on the same endpoint?</feature>
-				<reference>84.2.1. Features - allclusters.html[pdf]</reference>
+				<itemNumber>RVCRUNM.S.F16</itemNumber>
+				<feature>Does the device support support changing run modes from non-Idle states?</feature>
+				<reference>94.1. Features - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">O</status>
 				<support>false</support>
 			</picsItem>
@@ -108,10 +110,23 @@
 			<picsItem>
 				<itemNumber>RVCRUNM.S.M.CAN_TEST_MODE_FAILURE</itemNumber>
 				<feature>Does the DUT support testing the failed ChangeToMode command?</feature>
-				<reference>84.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<reference>93.2.4. Manual controllable - allclusters.html[pdf]</reference>
 				<status cond="RVCRUNM.S">O</status>
 				<support>true</support>
 			</picsItem>
+			<picsItem>
+				<itemNumber>RVCRUNM.S.M.CAN_MANUALLY_CONTROLLED</itemNumber>
+				<feature>Can the mode change be manually controlled?</feature>
+				<reference>93.2.4. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="RVCRUNM.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>RVCOPSTATE.M.ST_STOPPED | RVCOPSTATE.M.ST_PAUSED | RVCOPSTATE.M.ST_CHARGING | RVCOPSTATE.M.ST_DOCKED</itemNumber><feature/>
+				<reference>97.2.2. [TC-RVCRUNM-2.2] Change to Mode restrictions with DUT as Server - allclusters.html[pdf]</reference>
+				<status>O</status>
+				<support>true</support>
+			</picsItem>
 		</manually>
 	</clusterSide>
 	<!--Client side PICS-->
diff --git a/examples/rvc-app/rvc-common/pics/Service Area Cluster Test Plan.xml b/examples/rvc-app/rvc-common/pics/Service Area Cluster Test Plan.xml
new file mode 100644
index 0000000..665504f
--- /dev/null
+++ b/examples/rvc-app/rvc-common/pics/Service Area Cluster Test Plan.xml
@@ -0,0 +1,243 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+Autogenerated xml file - Version No:V_32_1_4_TE2_FALL_2024
+Generated date:2024-08-09 05:01:19
+Cluster Name -Service Area Cluster Test Plan
+XML PICS -Ref Document:
+version master 8f9bd8c,
+Draft
+2024-08-08 16:19:15 -0700
+--><clusterPICS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Generic-PICS-XML-Schema.xsd">
+	<!--General cluster information-->
+	<name>Service Area Cluster Test Plan</name>
+	<clusterId> </clusterId>
+	<picsRoot> </picsRoot>
+	<!--Cluster role information-->
+	<usage>
+		<picsItem>
+			<itemNumber>SEAR.S</itemNumber>
+			<feature>Does the device implement the Service Area cluster as a server?</feature>
+			<reference>306.1. Role - allclusters.html[pdf]</reference>
+			<status>O</status>
+			<support>true</support>
+		</picsItem>
+	</usage>
+	<!--PIXIT-->
+	<pixit/>
+	<!--Server side PICS-->
+	<clusterSide type="Server">
+		<!--Attributes PICS write-->
+		<attributes>
+			<picsItem>
+				<itemNumber>SEAR.S.A0000</itemNumber>
+				<feature>Does the device implement the SupportedAreas attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">M</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.A0001</itemNumber>
+				<feature>Does the device implement the SupportedMaps attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S AND SEAR.S.F02">M</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.A0002</itemNumber>
+				<feature>Does the device implement the SelectedAreas attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">M</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.A0003</itemNumber>
+				<feature>Does the device implement the CurrentArea attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.A0004</itemNumber>
+				<feature>Does the device implement the EstimatedEndTime attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S AND SEAR.S.A0003">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.A0005</itemNumber>
+				<feature>Does the device implement the Progress attribute?</feature>
+				<reference>306.2.2. Attributes - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S AND SEAR.S.F01">M</status>
+				<support>true</support>
+			</picsItem>
+		</attributes>
+		<!--Events PICS write-->
+		<events/>
+		<!--Commands generated PICS write-->
+		<commandsGenerated>
+			<picsItem>
+				<itemNumber>SEAR.S.C01.Tx</itemNumber>
+				<feature>Does the device implement generating the SelectAreasResponse command?</feature>
+				<reference>306.2.4. Commands generated - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">M</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.C03.Tx</itemNumber>
+				<feature>Does the device implement generating the SkipAreaResponse command?</feature>
+				<reference>306.2.4. Commands generated - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S AND SEAR.S.C02.Rsp">M</status>
+				<support>true</support>
+			</picsItem>
+		</commandsGenerated>
+		<!--Commands received PICS write-->
+		<commandsReceived>
+			<picsItem>
+				<itemNumber>SEAR.S.C00.Rsp</itemNumber>
+				<feature>Does the device implement receiving the SelectAreas command?</feature>
+				<reference>306.2.3. Commands received - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">M</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.C02.Rsp</itemNumber>
+				<feature>Does the device implement receiving the SkipArea command?</feature>
+				<reference>306.2.3. Commands received - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+		</commandsReceived>
+		<!--Features PICS write-->
+		<features>
+			<picsItem>
+				<itemNumber>SEAR.S.F00</itemNumber>
+				<feature>Does the device support changing the selected areas while running?</feature>
+				<reference>306.2.1. Features - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>false</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.F01</itemNumber>
+				<feature>Does the device support reporting the progress?</feature>
+				<reference>306.2.1. Features - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.F02</itemNumber>
+				<feature>Does the device support the maps feature?</feature>
+				<reference>306.2.1. Features - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+		</features>
+		<!--Manual controllable PICS write-->
+		<manually>
+			<picsItem>
+				<itemNumber>SEAR.S.M.REMOVE_AREA</itemNumber>
+				<feature>Does the DUT support testing the effects of removing a SupportedAreas entry?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.ADD_AREA</itemNumber>
+				<feature>Does the DUT support testing the effects of adding a SupportedAreas entry?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.REMOVE_MAP</itemNumber>
+				<feature>Does the DUT support testing the effects of removing a SupportedMaps entry?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.ADD_MAP</itemNumber>
+				<feature>Does the DUT support testing the effects of adding a SupportedMaps entry?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.INVALID_STATE_FOR_SELECT_AREAS</itemNumber>
+				<feature>Does the DUT support testing the selecting areas while the device doesn’t allow that?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.VALID_STATE_FOR_SELECT_AREAS</itemNumber>
+				<feature>Does the DUT support testing the selecting areas while the device allows that?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>false</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.SELECT_AREAS_WHILE_NON_IDLE</itemNumber>
+				<feature>Does the DUT support testing the selecting areas while the device is a non-idle state?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.HAS_MANUAL_SELAREA_STATE_CONTROL</itemNumber>
+				<feature>Can the device state affecting SelectAreas be manually controlled?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.HAS_MANUAL_SKIP_STATE_CONTROL</itemNumber>
+				<feature>Can the device state affecting SkipArea be manually controlled?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.INVALID_STATE_FOR_SKIP</itemNumber>
+				<feature>Does the DUT support testing the SkipArea command while the device doesn’t allow that?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.NO_SELAREA_FOR_SKIP</itemNumber>
+				<feature>Does the DUT support testing the SkipArea command while SelectedAreas is null?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.VALID_STATE_FOR_SKIP</itemNumber>
+				<feature>Does the DUT support testing the SkipArea command while the device allows that?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+			<picsItem>
+				<itemNumber>SEAR.S.M.HAS_MANUAL_OPERATING_STATE_CONTROL</itemNumber>
+				<feature>Can the device operating state (idle, operating, terminate operating) be manually controlled?</feature>
+				<reference>306.2.5. Manual controllable - allclusters.html[pdf]</reference>
+				<status cond="SEAR.S">O</status>
+				<support>true</support>
+			</picsItem>
+		</manually>
+	</clusterSide>
+	<!--Client side PICS-->
+	<clusterSide type="Client">
+		<!--Attributes PICS write-->
+		<attributes/>
+		<!--Events PICS write-->
+		<events/>
+		<!--Commands generated PICS write-->
+		<commandsGenerated/>
+		<!--Commands received PICS write-->
+		<commandsReceived/>
+		<!--Features PICS write-->
+		<features/>
+		<!--Manual controllable PICS write-->
+		<manually/>
+	</clusterSide>
+</clusterPICS>
\ No newline at end of file
diff --git a/examples/rvc-app/rvc-common/src/rvc-device.cpp b/examples/rvc-app/rvc-common/src/rvc-device.cpp
index 623c959..dac7db9 100644
--- a/examples/rvc-app/rvc-common/src/rvc-device.cpp
+++ b/examples/rvc-app/rvc-common/src/rvc-device.cpp
@@ -174,7 +174,7 @@
     return true;
 }
 
-bool RvcDevice::SaHandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
+bool RvcDevice::SaHandleSkipArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
 {
     if (mServiceAreaInstance.GetCurrentArea() != skippedArea)
     {
diff --git a/examples/rvc-app/rvc-common/src/rvc-service-area-delegate.cpp b/examples/rvc-app/rvc-common/src/rvc-service-area-delegate.cpp
index 9844729..9041efd 100644
--- a/examples/rvc-app/rvc-common/src/rvc-service-area-delegate.cpp
+++ b/examples/rvc-app/rvc-common/src/rvc-service-area-delegate.cpp
@@ -180,9 +180,9 @@
     return true;
 };
 
-bool RvcServiceAreaDelegate::HandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
+bool RvcServiceAreaDelegate::HandleSkipArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
 {
-    return (mHandleSkipCurrentAreaDeviceInstance->*mHandleSkipCurrentAreaCallback)(skippedArea, skipStatusText);
+    return (mHandleSkipAreaDeviceInstance->*mHandleSkipAreaCallback)(skippedArea, skipStatusText);
 };
 
 //*************************************************************************
diff --git a/src/app/clusters/service-area-server/service-area-delegate.h b/src/app/clusters/service-area-server/service-area-delegate.h
index 01df2fa..2e94228 100644
--- a/src/app/clusters/service-area-server/service-area-delegate.h
+++ b/src/app/clusters/service-area-server/service-area-delegate.h
@@ -120,7 +120,7 @@
      *       InvalidInMode, the StatusText field SHOULD indicate why the request is not allowed, given the current mode of the
      *       device, which may involve other clusters.
      */
-    virtual bool HandleSkipCurrentArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
+    virtual bool HandleSkipArea(uint32_t skippedArea, MutableCharSpan & skipStatusText)
     {
         // device support of this command is optional
         CopyCharSpanToMutableCharSpan("Skip Current Area command not supported by device"_span, skipStatusText);
diff --git a/src/app/clusters/service-area-server/service-area-server.cpp b/src/app/clusters/service-area-server/service-area-server.cpp
index 0e562c7..a7e8127 100644
--- a/src/app/clusters/service-area-server/service-area-server.cpp
+++ b/src/app/clusters/service-area-server/service-area-server.cpp
@@ -123,7 +123,7 @@
 
     case Commands::SkipArea::Id:
         return CommandHandlerInterface::HandleCommand<Commands::SkipArea::DecodableType>(
-            handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleSkipCurrentAreaCmd(ctx, req); });
+            handlerContext, [this](HandlerContext & ctx, const auto & req) { HandleSkipAreaCmd(ctx, req); });
     }
 }
 
@@ -356,11 +356,11 @@
     exitResponse(SelectAreasStatus::kSuccess, ""_span);
 }
 
-void Instance::HandleSkipCurrentAreaCmd(HandlerContext & ctx, const Commands::SkipArea::DecodableType & req)
+void Instance::HandleSkipAreaCmd(HandlerContext & ctx, const Commands::SkipArea::DecodableType & req)
 {
-    ChipLogDetail(Zcl, "Service Area: HandleSkipCurrentArea");
+    ChipLogDetail(Zcl, "Service Area: HandleSkipArea");
 
-    // On receipt of this command the device SHALL respond with a SkipCurrentAreaResponse command.
+    // On receipt of this command the device SHALL respond with a SkipAreaResponse command.
     auto exitResponse = [ctx](SkipAreaStatus status, CharSpan statusText) {
         Commands::SkipAreaResponse::Type response{
             .status     = status,
@@ -369,11 +369,11 @@
         ctx.mCommandHandler.AddResponse(ctx.mRequestPath, response);
     };
 
-    // If the SelectedAreas attribute is null, the response status should be set to InvalidAreaList.
+    // The SkippedArea field SHALL match an entry in the SupportedAreas list.
     // If the Status field is set to InvalidAreaList, the StatusText field SHALL be an empty string.
-    if (mDelegate->GetNumberOfSelectedAreas() == 0)
+    if (!IsSupportedArea(req.skippedArea))
     {
-        ChipLogError(Zcl, "Selected Areas attribute is null");
+        ChipLogError(Zcl, "SkippedArea (%u) is not in the SupportedAreas attribute.", req.skippedArea);
         exitResponse(SkipAreaStatus::kInvalidAreaList, ""_span);
         return;
     }
@@ -394,7 +394,7 @@
     char skipStatusBuffer[kMaxSizeStatusText];
     MutableCharSpan skipStatusText(skipStatusBuffer);
 
-    if (!mDelegate->HandleSkipCurrentArea(req.skippedArea, skipStatusText))
+    if (!mDelegate->HandleSkipArea(req.skippedArea, skipStatusText))
     {
         exitResponse(SkipAreaStatus::kInvalidInMode, skipStatusText);
         return;
diff --git a/src/app/clusters/service-area-server/service-area-server.h b/src/app/clusters/service-area-server/service-area-server.h
index 811499f..e023f24 100644
--- a/src/app/clusters/service-area-server/service-area-server.h
+++ b/src/app/clusters/service-area-server/service-area-server.h
@@ -124,7 +124,7 @@
      *                     If the input value is invalid, returns the Interaction Model status code of INVALID_COMMAND.
      * @param[in] req the command parameters.
      */
-    void HandleSkipCurrentAreaCmd(HandlerContext & ctx, const Commands::SkipArea::DecodableType & req);
+    void HandleSkipAreaCmd(HandlerContext & ctx, const Commands::SkipArea::DecodableType & req);
 
     //*************************************************************************
     // attribute notifications
