diff --git a/frameworks/ability_lite/src/slite/slite_ability.cpp b/frameworks/ability_lite/src/slite/slite_ability.cpp
index 0188c51d48bda1e919a4ca7dd7ad5c1dade8461c..77fec28d966d70bd1bf8ec38adb8205f7291fb81 100755
--- a/frameworks/ability_lite/src/slite/slite_ability.cpp
+++ b/frameworks/ability_lite/src/slite/slite_ability.cpp
@@ -33,25 +33,25 @@ SliteAbility::~SliteAbility()
 void SliteAbility::OnCreate(const Want &want)
 {
     abilityState_ = SLITE_STATE_INITIAL;
-    (void) AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_INITIAL);
+    (void)AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_INITIAL);
 }
 
 void SliteAbility::OnForeground(const Want &want)
 {
     abilityState_ = SLITE_STATE_FOREGROUND;
-    (void) AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_FOREGROUND);
+    (void)AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_FOREGROUND);
 }
 
 void SliteAbility::OnBackground()
 {
     abilityState_ = SLITE_STATE_BACKGROUND;
-    (void) AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_BACKGROUND);
+    (void)AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_BACKGROUND);
 }
 
 void SliteAbility::OnDestroy()
 {
     abilityState_ = SLITE_STATE_UNINITIALIZED;
-    (void) AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_UNINITIALIZED);
+    (void)AbilityMsClient::GetInstance().SchedulerLifecycleDone(token_, SLITE_STATE_UNINITIALIZED);
 }
 
 void SliteAbility::HandleExtraMessage(const SliteAbilityInnerMsg &innerMsg)
diff --git a/frameworks/abilitymgr_lite/include/slite/abilityms_slite_client.h b/frameworks/abilitymgr_lite/include/slite/abilityms_slite_client.h
index 883cc93755ee1a47b73f801116839d9ef49c5d03..4c959e877c33c9579b0a315478385e2a0a37bc3d 100755
--- a/frameworks/abilitymgr_lite/include/slite/abilityms_slite_client.h
+++ b/frameworks/abilitymgr_lite/include/slite/abilityms_slite_client.h
@@ -13,8 +13,8 @@
  * limitations under the License.
  */
 
-#ifndef OHOS_ABILITYMS_SLITE_CLIENT_H
-#define OHOS_ABILITYMS_SLITE_CLIENT_H
+#ifndef OHOS_ABILITY_SLITE_ABILITYMS_SLITE_CLIENT_H
+#define OHOS_ABILITY_SLITE_ABILITYMS_SLITE_CLIENT_H
 
 #include "ability_service_interface.h"
 #include "nocopyable.h"
@@ -35,15 +35,13 @@ public:
         return instance;
     }
 
-    ~AbilityMsClient() = default;
-
     bool Initialize() const;
 
     int32_t StartAbility(const Want *want) const;
 
     int32_t TerminateAbility(uint64_t token) const;
 
-    int32_t SchedulerLifecycleDone(uint64_t token, int state) const;
+    int32_t SchedulerLifecycleDone(uint64_t token, int32_t state) const;
 
     int32_t ForceStopBundle(uint64_t token) const;
 
@@ -56,6 +54,8 @@ public:
 private:
     AbilityMsClient() = default;
 
+    ~AbilityMsClient() = default;
+
     AmsSliteInterface *amsProxy_ { nullptr };
     const Identity *identity_ { nullptr };
 
@@ -64,4 +64,4 @@ private:
 } // namespace AbilitySlite
 } // namespace OHOS
 
-#endif // OHOS_ABILITYMS_SLITE_CLIENT_H
+#endif // OHOS_ABILITY_SLITE_ABILITYMS_SLITE_CLIENT_H
diff --git a/frameworks/abilitymgr_lite/src/slite/abilityms_slite_client.cpp b/frameworks/abilitymgr_lite/src/slite/abilityms_slite_client.cpp
index cd0e5c27b8fbdf0ec25fe454449d363dcc9794d6..480c562862fe12231053af1fddc1f8a3538e53c5 100644
--- a/frameworks/abilitymgr_lite/src/slite/abilityms_slite_client.cpp
+++ b/frameworks/abilitymgr_lite/src/slite/abilityms_slite_client.cpp
@@ -41,7 +41,7 @@ bool AbilityMsClient::Initialize() const
             continue;
         }
 
-        (void) iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **) &amsProxy_);
+        (void)iUnknown->QueryInterface(iUnknown, DEFAULT_VERSION, (void **)&amsProxy_);
         if (amsProxy_ == nullptr) {
             HILOG_ERROR(HILOG_MODULE_APP, "ams proxy is null");
             osDelay(ERROR_SLEEP_TIMES); // sleep 300ms
@@ -102,7 +102,7 @@ int32_t AbilityMsClient::TerminateAbility(uint64_t token) const
     return SAMGR_SendRequest(identity_, &request, nullptr);
 }
 
-int32_t AbilityMsClient::SchedulerLifecycleDone(uint64_t token, int state) const
+int32_t AbilityMsClient::SchedulerLifecycleDone(uint64_t token, int32_t state) const
 {
     if (identity_ == nullptr) {
         return PARAM_CHECK_ERROR;
diff --git a/services/abilitymgr_lite/include/slite/bms_helper.h b/interfaces/inner_api/abilitymgr_lite/slite/bms_helper.h
similarity index 97%
rename from services/abilitymgr_lite/include/slite/bms_helper.h
rename to interfaces/inner_api/abilitymgr_lite/slite/bms_helper.h
index 7cc432e3f9614a5f910f5d10130657d40bb9b85d..fde767dfa3d8dee24811aaf0fb4dbbac6e28e43f 100644
--- a/services/abilitymgr_lite/include/slite/bms_helper.h
+++ b/interfaces/inner_api/abilitymgr_lite/slite/bms_helper.h
@@ -30,7 +30,7 @@ struct AbilitySvcInfo {
     bool isNativeApp;
     uint16_t dataLength;
 };
-    
+
 class BMSHelper final {
 public:
     static BMSHelper &GetInstance()
@@ -60,4 +60,4 @@ private:
 } // namespace AbilitySlite
 } // namespace OHOS
 
-#endif //ABILITYLITE_BMS_HELPER_H
\ No newline at end of file
+#endif //ABILITYLITE_BMS_HELPER_H
diff --git a/services/abilitymgr_lite/include/slite/slite_ability_loader.h b/interfaces/inner_api/abilitymgr_lite/slite/slite_ability_loader.h
similarity index 100%
rename from services/abilitymgr_lite/include/slite/slite_ability_loader.h
rename to interfaces/inner_api/abilitymgr_lite/slite/slite_ability_loader.h
diff --git a/services/abilitymgr_lite/BUILD.gn b/services/abilitymgr_lite/BUILD.gn
index a6b188ff2e46d4181c9287bfe0cd1203413bfac2..15a532901a1960c99e717d6c4f55247ae9f800d6 100644
--- a/services/abilitymgr_lite/BUILD.gn
+++ b/services/abilitymgr_lite/BUILD.gn
@@ -28,11 +28,9 @@ lite_library("abilityms") {
       "src/slite/ability_mgr_service_slite.cpp",
       "src/slite/ability_record.cpp",
       "src/slite/ability_record_manager.cpp",
-      "src/slite/ability_stack.cpp",
       "src/slite/ability_thread.cpp",
       "src/slite/ability_thread_loader.cpp",
       "src/slite/bms_helper.cpp",
-      "src/slite/dummy_js_ability.cpp",
       "src/slite/js_ability_thread.cpp",
       "src/slite/native_ability_thread.cpp",
       "src/slite/slite_ability_loader.cpp",
diff --git a/services/abilitymgr_lite/include/slite/ability_list.h b/services/abilitymgr_lite/include/slite/ability_list.h
index b76f339afb24347afb42425f49f84da0a3310c23..fca05239a9d4b388f66b40e3fabfbbfc22c973fb 100644
--- a/services/abilitymgr_lite/include/slite/ability_list.h
+++ b/services/abilitymgr_lite/include/slite/ability_list.h
@@ -37,6 +37,14 @@ public:
 
     void Erase(uint16_t token);
 
+    uint32_t Size() const;
+
+    bool MoveToTop(uint16_t token);
+
+    void PopAbility();
+
+    AbilityRecord *GetTopAbility() const;
+
 private:
     List<AbilityRecord *> abilityList_ {};
 };
diff --git a/services/abilitymgr_lite/include/slite/ability_record_manager.h b/services/abilitymgr_lite/include/slite/ability_record_manager.h
index c32be15703f1efd7ec9bc99edd7ed8d5680393bf..bbc575b31cfdd0a494ccef42b8e18d478952a539 100644
--- a/services/abilitymgr_lite/include/slite/ability_record_manager.h
+++ b/services/abilitymgr_lite/include/slite/ability_record_manager.h
@@ -20,7 +20,6 @@
 
 #include "ability_list.h"
 #include "ability_record.h"
-#include "ability_stack.h"
 #include "adapter.h"
 #include "bms_helper.h"
 #include "js_ability_thread.h"
@@ -31,7 +30,6 @@
 
 namespace OHOS {
 namespace AbilitySlite {
-
 class AbilityRecordManager : public NoCopyable {
 public:
     typedef void (AbilityRecordManager::*LifecycleFunc)(uint16_t token);
@@ -85,9 +83,7 @@ private:
 
     int32_t SchedulerLifecycle(uint64_t token, int32_t state);
 
-    int32_t SchedulerLifecycleInner(const AbilityRecord *record, int32_t state);
-
-    bool SendMsgToJsAbility(int32_t state, const AbilityRecord *record);
+    int32_t ScheduleLifecycleInner(const AbilityRecord *record, int32_t state);
 
     void SchedulerAbilityLifecycle(SliteAbility *ability, const Want &want, int32_t state);
 
@@ -105,7 +101,7 @@ private:
 
     void DeleteAbilityThread(AbilityRecord *record);
 
-    bool SendMsgToAbilityThread(const AbilityRecord *record, int32_t msgId);
+    int32_t SendMsgToAbilityThread(int32_t state, const AbilityRecord *record);
 
     void SetAbilityState(uint64_t token, int32_t state);
 
@@ -118,8 +114,10 @@ private:
     Want *CreateWant(const AbilityRecord *record);
 
     uint16_t pendingToken_ { 0 };
+#ifndef _MINI_MULTI_TASKS_
+    AbilityRecord *pendingRecord = nullptr;
+#endif
     AbilityList abilityList_ {};
-    AbilityStack abilityStack_ {};
     SliteAbility *nativeAbility_ = nullptr;
 };
 } // namespace AbilitySlite
diff --git a/services/abilitymgr_lite/include/slite/ability_stack.h b/services/abilitymgr_lite/include/slite/ability_stack.h
deleted file mode 100755
index d475de381484618e2bc3764178e6e8689311ee67..0000000000000000000000000000000000000000
--- a/services/abilitymgr_lite/include/slite/ability_stack.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2020 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef OHOS_ABILITY_SLITE_ABILITY_STACK_H
-#define OHOS_ABILITY_SLITE_ABILITY_STACK_H
-
-#include "ability_record.h"
-#include "utils_list.h"
-#include <new>
-
-namespace OHOS {
-namespace AbilitySlite {
-class AbilityStack {
-public:
-    AbilityStack() = default;
-
-    ~AbilityStack() = default;
-
-    const AbilityRecord *GetTopAbility() const;
-
-    void PushAbility(AbilityRecord *record);
-
-    void PopAbility();
-
-    void Erase(AbilityRecord *record);
-
-    uint32_t Size() const;
-
-private:
-    List<AbilityRecord *> abilityStack_ {};
-};
-} // namespace AbilitySlite
-} // namespace OHOS
-#endif  // OHOS_ABILITY_SLITE_ABILITY_STACK_H
diff --git a/services/abilitymgr_lite/include/slite/ability_thread.h b/services/abilitymgr_lite/include/slite/ability_thread.h
index aa806c97d3f970b4b8d35c3ff181ae2977d9a12b..304895d35bcc9c1ab12f3793a5a24da25fe044ee 100644
--- a/services/abilitymgr_lite/include/slite/ability_thread.h
+++ b/services/abilitymgr_lite/include/slite/ability_thread.h
@@ -29,6 +29,7 @@ namespace AbilitySlite {
 constexpr char LAUNCHER_BUNDLE_NAME[] = "com.ohos.launcher";
 
 class AbilityRecord;
+
 enum class AbilityThreadState : int8_t {
     ABILITY_THREAD_UNINITIALIZED,
     ABILITY_THREAD_INITIALIZED,
@@ -45,6 +46,10 @@ public:
 
     virtual int32_t ReleaseAbilityThread() = 0;
 
+    virtual osMessageQueueId_t GetMessageQueueId() const = 0;
+
+    virtual UINT32 GetAppTaskId() const = 0;
+
     int32_t HandleCreate(const Want *want);
 
     int32_t HandleForeground(const Want *want);
@@ -53,10 +58,7 @@ public:
 
     int32_t HandleDestroy();
 
-    osMessageQueueId_t messageQueueId_ = nullptr;
-    UINT32 appTaskId_ = 0;
     SliteAbility *ability_ = nullptr;
-
 protected:
     AbilityThreadState state_ = AbilityThreadState::ABILITY_THREAD_UNINITIALIZED;
 };
diff --git a/services/abilitymgr_lite/include/slite/dummy_js_ability.h b/services/abilitymgr_lite/include/slite/dummy_js_ability.h
deleted file mode 100644
index c0e203ad1591f0d50dcc21817cf659b3df3fde18..0000000000000000000000000000000000000000
--- a/services/abilitymgr_lite/include/slite/dummy_js_ability.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef OHOS_ABILITY_SLITE_DUMMY_JS_ABILITY_H
-#define OHOS_ABILITY_SLITE_DUMMY_JS_ABILITY_H
-
-#include "slite_ability.h"
-#include "js_ability.h"
-
-namespace OHOS {
-namespace AbilitySlite {
-class DummyJsAbility : public SliteAbility {
-public:
-    DummyJsAbility(const char *bundleName) : SliteAbility(bundleName) {}
-
-    ~DummyJsAbility() override = default;
-
-    void OnCreate(const Want &want) override;
-
-    void OnForeground(const Want &want) override;
-
-    void OnBackground() override;
-
-    void OnDestroy() override;
-
-    void HandleExtraMessage(const SliteAbilityInnerMsg &innerMsg) override;
-
-private:
-    bool isBackground_ = false;
-    ACELite::JSAbility jsAbility_;
-};
-} // namespace AbilitySlite
-} // namespace OHOS
-#endif // OHOS_ABILITY_SLITE_DUMMY_JS_ABILITY_H
diff --git a/services/abilitymgr_lite/include/slite/js_ability_thread.h b/services/abilitymgr_lite/include/slite/js_ability_thread.h
index 3a1e107087a0169bc9ad47ef8fc32b4c02e56fd9..8619d054ed2058d2f01edbf332c9a7fa45c11c29 100644
--- a/services/abilitymgr_lite/include/slite/js_ability_thread.h
+++ b/services/abilitymgr_lite/include/slite/js_ability_thread.h
@@ -32,7 +32,14 @@ public:
 
     int32_t ReleaseAbilityThread() override;
 
+    osMessageQueueId_t GetMessageQueueId() const override;
+
+    UINT32 GetAppTaskId() const override;
+
     static void AppTaskHandler(UINT32 uwArg);
+private:
+    osMessageQueueId_t messageQueueId_ = nullptr;
+    UINT32 appTaskId_ = 0;
 };
 } // namespace AbilitySlite
 } // namespace OHOS
diff --git a/services/abilitymgr_lite/include/slite/native_ability_thread.h b/services/abilitymgr_lite/include/slite/native_ability_thread.h
index 464f4dccdf13d40653335fd4f7764f12e405e874..14a05677c0288aa89f5a3df02f535de092396ec2 100644
--- a/services/abilitymgr_lite/include/slite/native_ability_thread.h
+++ b/services/abilitymgr_lite/include/slite/native_ability_thread.h
@@ -30,10 +30,16 @@ public:
 
     int32_t ReleaseAbilityThread() override;
 
-    static void NativeAppTaskHandler(UINT32 uwArg);
+    osMessageQueueId_t GetMessageQueueId() const override;
+
+    UINT32 GetAppTaskId() const override;
 
-    static osMessageQueueId_t nativeQueueId;
-    static UINT32 nativeTaskId;
+    static void Reset();
+
+    static void NativeAppTaskHandler(UINT32 uwArg);
+private:
+    static osMessageQueueId_t nativeQueueId_;
+    static UINT32 nativeTaskId_;
     static SliteAbility *nativeAbility_;
 };
 }
diff --git a/services/abilitymgr_lite/src/slite/ability_list.cpp b/services/abilitymgr_lite/src/slite/ability_list.cpp
index 5b35fb183d9f8c0204b079e5451fb63327cf1d09..b89492a41692e9754183c7e3561985521ee8c746 100644
--- a/services/abilitymgr_lite/src/slite/ability_list.cpp
+++ b/services/abilitymgr_lite/src/slite/ability_list.cpp
@@ -17,7 +17,6 @@
 #include "ability_record.h"
 #include "ability_list.h"
 
-
 namespace OHOS {
 namespace AbilitySlite {
 namespace {
@@ -31,7 +30,7 @@ void AbilityList::Add(AbilityRecord *abilityRecord)
     }
 
     if (Get(abilityRecord->token) == nullptr) {
-        abilityList_.PushBack(abilityRecord);
+        abilityList_.PushFront(abilityRecord);
     }
 }
 
@@ -95,5 +94,34 @@ void AbilityList::Erase(uint16_t token)
         }
     }
 }
+
+uint32_t AbilityList::Size() const
+{
+    return abilityList_.Size();
+}
+
+bool AbilityList::MoveToTop(uint16_t token)
+{
+    AbilityRecord *abilityRecord = Get(token);
+    if (abilityRecord == nullptr) {
+        return false;
+    }
+    Erase(token);
+    Add(abilityRecord);
+    return true;
+}
+
+void AbilityList::PopAbility()
+{
+    abilityList_.PopFront();
+}
+
+AbilityRecord *AbilityList::GetTopAbility() const
+{
+    if (abilityList_.Size() != 0) {
+        return abilityList_.Front();
+    }
+    return nullptr;
+}
 } // namespace AbilitySlite
 } // namespace OHOS
diff --git a/services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp b/services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp
index 68c5a4312bfb9a158a18dd021b93b6fd4ed21a5d..94054c54d80d17ccec75b3e0b252388c80da06c8 100755
--- a/services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp
+++ b/services/abilitymgr_lite/src/slite/ability_mgr_service_slite.cpp
@@ -16,19 +16,17 @@
 #include "ability_mgr_service_slite.h"
 
 #include "ability_errors.h"
-#include "ability_info.h"
 #include "ability_service_interface.h"
 #include "ability_thread_loader.h"
 #include "abilityms_slite_client.h"
 #include "abilityms_log.h"
-#include "dummy_js_ability.h"
 #include "iunknown.h"
 #include "js_ability_thread.h"
 #include "native_ability_thread.h"
 #include "ohos_init.h"
 #include "samgr_lite.h"
 #include "slite_ability_loader.h"
-#include "dummy_js_ability.h"
+#include "slite_ace_ability.h"
 #include "want.h"
 
 namespace OHOS {
@@ -101,25 +99,21 @@ const Identity *AbilityMgrServiceSlite::GetIdentity()
     return &serviceIdentity_;
 }
 
-const char *AbilityMgrServiceSlite::GetFeatureName(Feature *feature)
+const char *AbilityMgrServiceSlite::GetFeatureName([[maybe_unused]] Feature *feature)
 {
-    (void) feature;
     return AMS_SLITE_FEATURE;
 }
 
-void AbilityMgrServiceSlite::OnFeatureInitialize(Feature *feature, Service *parent, Identity identity)
+void AbilityMgrServiceSlite::OnFeatureInitialize(Feature *feature, [[maybe_unused]] Service *parent, Identity identity)
 {
-    (void) parent;
     CHECK_NULLPTR_RETURN(feature, "AbilityMgrServiceSlite", "feature initialize fail");
     auto *abilityMgrService = static_cast<AbilityMgrServiceSlite *>(feature);
     abilityMgrService->featureIdentity_ = identity;
     AbilityRecordManager::GetInstance().StartLauncher();
 }
 
-void AbilityMgrServiceSlite::OnFeatureStop(Feature *feature, Identity identity)
+void AbilityMgrServiceSlite::OnFeatureStop([[maybe_unused]] Feature *feature, [[maybe_unused]] Identity identity)
 {
-    (void) feature;
-    (void) identity;
 }
 
 BOOL AbilityMgrServiceSlite::OnFeatureMessage(Feature *feature, Request *request)
@@ -130,9 +124,8 @@ BOOL AbilityMgrServiceSlite::OnFeatureMessage(Feature *feature, Request *request
     return TRUE;
 }
 
-const char *AbilityMgrServiceSlite::GetServiceName(Service *service)
+const char *AbilityMgrServiceSlite::GetServiceName([[maybe_unused]] Service *service)
 {
-    (void) service;
     return AMS_SERVICE;
 }
 
@@ -218,13 +211,13 @@ ElementName *AbilityMgrServiceSlite::GetTopAbility()
     return AbilityRecordManager::GetInstance().GetTopAbility();
 }
 
-static AbilityThread *createJsAbilityThread()
+static AbilityThread *CreateJsAbilityThread()
 {
     auto *jsThread = new JsAbilityThread();
     return jsThread;
 }
 
-static AbilityThread *createNativeAbilityThread()
+static AbilityThread *CreateNativeAbilityThread()
 {
     auto *nativeThread = new NativeAbilityThread();
     return nativeThread;
@@ -232,20 +225,20 @@ static AbilityThread *createNativeAbilityThread()
 
 void AbilityMgrServiceSlite::InitAbilityThreadLoad()
 {
-    AbilityThreadLoader::GetInstance().SetCreatorFunc(AbilityThreadCreatorType::JS_CREATOR, createJsAbilityThread);
+    AbilityThreadLoader::GetInstance().SetCreatorFunc(AbilityThreadCreatorType::JS_CREATOR, CreateJsAbilityThread);
     AbilityThreadLoader::GetInstance().SetCreatorFunc(AbilityThreadCreatorType::NATIVE_CREATOR,
-        createNativeAbilityThread);
+        CreateNativeAbilityThread);
 }
 
-static SliteAbility *createJsAbility(const char *bundleName)
+static SliteAbility *CreateJsAbility(const char *bundleName)
 {
-    SliteAbility *jsAbility = new DummyJsAbility(bundleName);
+    SliteAbility *jsAbility = new ACELite::SliteAceAbility(bundleName);
     return jsAbility;
 }
 
 void AbilityMgrServiceSlite::InitAbilityLoad()
 {
-    SliteAbilityLoader::GetInstance().SetAbilityCreatorFunc(SliteAbilityType::JS_ABILITY, createJsAbility);
+    SliteAbilityLoader::GetInstance().SetAbilityCreatorFunc(SliteAbilityType::JS_ABILITY, CreateJsAbility);
 }
 } // namespace AbilitySlite
 } // namespace OHOS
diff --git a/services/abilitymgr_lite/src/slite/ability_record.cpp b/services/abilitymgr_lite/src/slite/ability_record.cpp
index 8f158615675f821799cebd065513fb583bd60193..defa43d76af9169778830f6078039eff238293b1 100755
--- a/services/abilitymgr_lite/src/slite/ability_record.cpp
+++ b/services/abilitymgr_lite/src/slite/ability_record.cpp
@@ -35,6 +35,8 @@ AbilityRecord::~AbilityRecord()
     AdapterFree(appPath);
     delete abilityData;
     abilityData = nullptr;
+    delete abilityThread;
+    abilityThread = nullptr;
 }
 
 void AbilityRecord::SetAppName(const char *name)
diff --git a/services/abilitymgr_lite/src/slite/ability_record_manager.cpp b/services/abilitymgr_lite/src/slite/ability_record_manager.cpp
index aee10b32c452e1f4353d86b73e35c5f2d3217443..42cf7590f0c0479b15db7c119eb15544adbafb09 100644
--- a/services/abilitymgr_lite/src/slite/ability_record_manager.cpp
+++ b/services/abilitymgr_lite/src/slite/ability_record_manager.cpp
@@ -19,8 +19,6 @@
 #include "ability_errors.h"
 #include "ability_inner_message.h"
 #include "ability_record.h"
-#include "ability_stack.h"
-#include "slite_ability_state.h"
 #include "ability_thread_loader.h"
 #include "abilityms_log.h"
 #include "ability_manager_inner.h"
@@ -69,8 +67,7 @@ void AbilityRecordManager::StartLauncher()
     record->state = SCHEDULE_FOREGROUND;
     record->taskId = LOS_CurTaskIDGet();
     abilityList_.Add(record);
-    abilityStack_.PushAbility(record);
-    (void) SchedulerLifecycleInner(record, SLITE_STATE_FOREGROUND);
+    (void)ScheduleLifecycleInner(record, SLITE_STATE_FOREGROUND);
 #else // define _MINI_MULTI_TASKS_
     StartAbility(launcherRecord);
 #endif
@@ -103,6 +100,7 @@ int32_t AbilityRecordManager::StartAbility(const AbilityRecord *record)
     if (ret != ERR_OK) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "start ability failed [%{public}d]", ret);
     }
+    AdapterFree(want);
     return ret;
 }
 
@@ -175,24 +173,37 @@ int32_t AbilityRecordManager::StartAbility(const Want *want)
     }
 #endif
 
+#ifdef _MINI_MULTI_TASKS_
+    AbilityRecord *abilityRecord = abilityList_.Get(bundleName);
+    if (abilityRecord != nullptr) {
+        auto topRecord = abilityList_.GetTopAbility();
+        if (topRecord == abilityRecord) {
+            return ERR_OK;
+        }
+        abilityList_.MoveToTop(abilityRecord->token);
+        return SendMsgToAbilityThread(SLITE_STATE_BACKGROUND, topRecord);
+    }
+#endif
+
     auto *info = static_cast<AbilitySvcInfo *>(AdapterMalloc(sizeof(AbilitySvcInfo)));
     if (info == nullptr) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "Ability Service AbilitySvcInfo is null");
         return PARAM_NULL_ERROR;
     }
-    if (IsLauncher(bundleName) || BMSHelper::GetInstance().IsNativeApp(bundleName)) {
-        // Launcher  or other Native App
-        info->bundleName = Utils::Strdup(bundleName);
+    if (IsLauncher(bundleName)) {
+        // delete it
+        want->element->bundleName = Utils::Strdup(LAUNCHER_BUNDLE_NAME);
+        AdapterFree(bundleName);
+        bundleName = nullptr;
         info->path = nullptr;
-        info->isNativeApp = true;
-    } else {
-        uint8_t queryRet = BMSHelper::GetInstance().QueryAbilitySvcInfo(want, info);
-        if (queryRet != ERR_OK) {
-            HILOG_ERROR(HILOG_MODULE_AAFWK, "Ability BMS Helper return abilitySvcInfo failed");
-            AdapterFree(info);
-            return PARAM_CHECK_ERROR;
-        }
     }
+    uint8_t queryRet = BMSHelper::GetInstance().QueryAbilitySvcInfo(want, info);
+    if (queryRet != ERR_OK) {
+        HILOG_ERROR(HILOG_MODULE_AAFWK, "Ability BMS Helper return abilitySvcInfo failed");
+        AdapterFree(info);
+        return PARAM_CHECK_ERROR;
+    }
+
     info->data = OHOS::Utils::Memdup(want->data, want->dataLength);
     info->dataLength = want->dataLength;
     auto ret = StartAbility(info);
@@ -224,7 +235,7 @@ int32_t AbilityRecordManager::StartAbility(AbilitySvcInfo *info)
     }
     HILOG_INFO(HILOG_MODULE_AAFWK, "StartAbility");
 
-    auto topRecord = abilityStack_.GetTopAbility();
+    auto topRecord = abilityList_.GetTopAbility();
 #ifndef _MINI_MULTI_TASKS_
     if ((topRecord == nullptr) || (topRecord->appName == nullptr)) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "StartAbility top null.");
@@ -236,7 +247,7 @@ int32_t AbilityRecordManager::StartAbility(AbilitySvcInfo *info)
         UpdateRecord(info);
         if (topToken != LAUNCHER_TOKEN && topRecord->state != SCHEDULE_BACKGROUND) {
             HILOG_INFO(HILOG_MODULE_AAFWK, "Change Js app to background.");
-            (void) SchedulerLifecycleInner(topRecord, SLITE_STATE_BACKGROUND);
+            (void)ScheduleLifecycleInner(topRecord, SLITE_STATE_BACKGROUND);
         } else {
             (void) SchedulerLifecycle(LAUNCHER_TOKEN, SLITE_STATE_FOREGROUND);
         }
@@ -289,7 +300,7 @@ int32_t AbilityRecordManager::StartAbility(AbilitySvcInfo *info)
         }
         return ERR_OK;
     }
-    (void) SendMsgToAbilityThread(topRecord, SLITE_STATE_BACKGROUND);
+    (void) SendMsgToAbilityThread(SLITE_STATE_BACKGROUND, topRecord);
     pendingToken_ = GenerateToken();
 
     // application has not been launched and then to check priority and permission.
@@ -300,7 +311,7 @@ int32_t AbilityRecordManager::StartAbility(AbilitySvcInfo *info)
 int32_t AbilityRecordManager::TerminateAbility(uint16_t token)
 {
     HILOG_INFO(HILOG_MODULE_AAFWK, "TerminateAbility [%{public}u]", token);
-    AbilityRecord *topRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    AbilityRecord *topRecord = const_cast<AbilityRecord *>(abilityList_.GetTopAbility());
     if (topRecord == nullptr) {
         APP_ERRCODE_EXTRA(EXCE_ACE_APP_START, EXCE_ACE_APP_STOP_NO_ABILITY_RUNNING);
         return PARAM_NULL_ERROR;
@@ -323,21 +334,25 @@ int32_t AbilityRecordManager::TerminateAbility(uint16_t token)
     }
     topRecord->isTerminated = true;
     // TerminateAbility top js
-    return SchedulerLifecycleInner(topRecord, SLITE_STATE_BACKGROUND);
+    return ScheduleLifecycleInner(topRecord, SLITE_STATE_BACKGROUND);
 #else
     // 1. only launcher in the ability stack
-    if (abilityStack_.Size() == 1 && topToken == LAUNCHER_TOKEN) {
+    if (abilityList_.Size() == 1 && topToken == LAUNCHER_TOKEN) {
         return ERR_OK;
     }
     // 2. terminate non-top ability
     if (token != topToken) {
+        AbilityRecord* abilityRecord = abilityList_.Get(token);
+        if ((abilityRecord == nullptr) || (abilityRecord->token == LAUNCHER_TOKEN)) {
+            return PARAM_CHECK_ERROR;
+        }
         APP_ERRCODE_EXTRA(EXCE_ACE_APP_START, EXCE_ACE_APP_STOP_UNKNOWN_ABILITY_TOKEN);
         DeleteRecordInfo(token);
-        return -1;
+        return ERR_OK;
     }
     // 3. terminate top ability
-    abilityStack_.PopAbility();
-    AbilityRecord *newTopRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    abilityList_.PopAbility();
+    AbilityRecord *newTopRecord = const_cast<AbilityRecord *>(abilityList_.GetTopAbility());
     if (newTopRecord == nullptr) {
         APP_ERRCODE_EXTRA(EXCE_ACE_APP_START, EXCE_ACE_APP_STOP_NO_ABILITY_RUNNING);
         return PARAM_NULL_ERROR;
@@ -345,17 +360,17 @@ int32_t AbilityRecordManager::TerminateAbility(uint16_t token)
 
     if (token != LAUNCHER_TOKEN) {
         topRecord->isTerminated = true;
-        abilityStack_.PushAbility(topRecord);
+        abilityList_.Add(topRecord);
     } else {
         // launcher will not pop ability stack
-        abilityStack_.PopAbility();
-        abilityStack_.PushAbility(topRecord);
-        abilityStack_.PushAbility(newTopRecord);
+        abilityList_.PopAbility();
+        abilityList_.Add(topRecord);
+        abilityList_.Add(newTopRecord);
     }
 
     // TerminateAbility top js
     pendingToken_ = newTopRecord->token;
-    return SendMsgToAbilityThread(topRecord, SLITE_STATE_BACKGROUND);
+    return SendMsgToAbilityThread(SLITE_STATE_BACKGROUND, topRecord);
 #endif
 }
 
@@ -401,8 +416,8 @@ int32_t AbilityRecordManager::ForceStop(const char *bundleName)
     }
 
     // stop js app
-    if (strcmp(abilityStack_.GetTopAbility()->appName, bundleName) == 0) {
-        AbilityRecord *topRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    if (strcmp(abilityList_.GetTopAbility()->appName, bundleName) == 0) {
+        AbilityRecord *topRecord = const_cast<AbilityRecord *>(abilityList_.GetTopAbility());
         HILOG_INFO(HILOG_MODULE_AAFWK, "ForceStop [%{public}u]", topRecord->token);
         return TerminateAbility(topRecord->token);
     }
@@ -432,17 +447,18 @@ int32_t AbilityRecordManager::PreCheckStartAbility(
         return ERR_OK;
     }
     auto record = new AbilityRecord();
-    if (pendingToken_ != 0) {
-        record->token = pendingToken_;
-    } else {
-        record->token = GenerateToken();
-    }
     record->SetAppName(bundleName);
     record->SetAppPath(path);
     record->SetWantData(data, dataLength);
     record->isNativeApp = BMSHelper::GetInstance().IsNativeApp(bundleName);
     record->state = SCHEDULE_STOP;
-    abilityList_.Add(record);
+    if (pendingToken_ != 0) {
+        record->token = pendingToken_;
+        pendingRecord = record;
+    } else {
+        record->token = GenerateToken();
+        abilityList_.Add(record);
+    }
     if (pendingToken_ == 0 && CreateAppTask(record) != ERR_OK) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "CheckResponse CreateAppTask fail");
         abilityList_.Erase(record->token);
@@ -461,8 +477,7 @@ int32_t AbilityRecordManager::PreCheckStartAbility(
             HILOG_ERROR(HILOG_MODULE_AAFWK, "PreCheckStartAbility current state active.");
         } else {
             // update ability stack and move the ability to the top of ability stack
-            abilityStack_.Erase(curRecord);
-            abilityStack_.PushAbility(curRecord);
+            abilityList_.MoveToTop(curRecord->token);
             pendingToken_ = curRecord->token;
             return ERR_OK;
         }
@@ -479,13 +494,11 @@ int32_t AbilityRecordManager::PreCheckStartAbility(
         record->state = SCHEDULE_STOP;
         record->isNativeApp = isNative;
         abilityList_.Add(record);
-        abilityStack_.PushAbility(record);
     }
 
     if (pendingToken_ == 0 && CreateAppTask(record) != ERR_OK) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "CheckResponse CreateAppTask fail");
         abilityList_.Erase(record->token);
-        abilityStack_.Erase(record);
         delete record;
         return CREATE_APPTASK_ERROR;
     }
@@ -532,17 +545,16 @@ int32_t AbilityRecordManager::CreateAppTask(AbilityRecord *record)
         record->abilityThread = nullptr;
         return ret;
     }
-    record->taskId = record->abilityThread->appTaskId_;
-    record->jsAppQueueId = record->abilityThread->messageQueueId_;
+    record->taskId = record->abilityThread->GetAppTaskId();
+    record->jsAppQueueId = record->abilityThread->GetMessageQueueId();
     record->state = SCHEDULE_STOP;
 #ifndef _MINI_MULTI_TASKS_
-    abilityStack_.PushAbility(record);
     APP_EVENT(MT_ACE_APP_START);
+    abilityList_.Add(record);
     if (nativeAbility_ != nullptr) {
         if (SchedulerLifecycle(LAUNCHER_TOKEN, SLITE_STATE_BACKGROUND) != 0) {
             APP_ERRCODE_EXTRA(EXCE_ACE_APP_START, EXCE_ACE_APP_START_LAUNCHER_EXIT_FAILED);
             HILOG_INFO(HILOG_MODULE_AAFWK, "CreateAppTask Fail to hide launcher");
-            abilityStack_.PopAbility();
             return SCHEDULER_LIFECYCLE_ERROR;
         }
     } else {
@@ -579,7 +591,6 @@ void AbilityRecordManager::DeleteRecordInfo(uint16_t token)
         // record app info event when stop app
         RecordAbiityInfoEvt(record->GetAppName());
     }
-    abilityStack_.Erase(record);
     abilityList_.Erase(token);
     delete record;
 }
@@ -607,7 +618,7 @@ void AbilityRecordManager::OnForegroundDone(uint16_t token)
 {
     HILOG_INFO(HILOG_MODULE_AAFWK, "OnForegroundDone [%{public}u]", token);
     SetAbilityState(token, SCHEDULE_FOREGROUND);
-    auto topRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    auto topRecord = const_cast<AbilityRecord *>(abilityList_.GetTopAbility());
     if (topRecord == nullptr) {
         return;
     }
@@ -633,13 +644,12 @@ void AbilityRecordManager::OnForegroundDone(uint16_t token)
                 APP_ERRCODE_EXTRA(EXCE_ACE_APP_START, EXCE_ACE_APP_START_LAUNCHER_EXIT_FAILED);
                 HILOG_ERROR(HILOG_MODULE_AAFWK,
                     "Active launcher js bg fail, native state is %{public}d", abilityState);
-                abilityStack_.PopAbility();
                 DeleteRecordInfo(topRecord->token);
             } else if (topRecord->isTerminated) {
 #ifndef _MINI_MULTI_TASKS_
-                (void) SchedulerLifecycleInner(topRecord, SLITE_STATE_UNINITIALIZED);
+                (void)ScheduleLifecycleInner(topRecord, SLITE_STATE_UNINITIALIZED);
 #else
-                (void) SendMsgToAbilityThread(topRecord, SLITE_STATE_UNINITIALIZED);
+                (void)SendMsgToAbilityThread(SLITE_STATE_UNINITIALIZED, topRecord);
 #endif
             }
         }
@@ -656,7 +666,7 @@ void AbilityRecordManager::OnBackgroundDone(uint16_t token)
     HILOG_INFO(HILOG_MODULE_AAFWK, "OnBackgroundDone [%{public}u]", token);
 #ifndef _MINI_MULTI_TASKS_
     SetAbilityState(token, SCHEDULE_BACKGROUND);
-    auto topRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    const AbilityRecord *topRecord = abilityList_.GetTopAbility();
     if (topRecord == nullptr) {
         return;
     }
@@ -671,9 +681,9 @@ void AbilityRecordManager::OnBackgroundDone(uint16_t token)
     // the launcher background
     if (topRecord->token != LAUNCHER_TOKEN) {
         if (topRecord->state == SCHEDULE_STOP) {
-            (void) SchedulerLifecycleInner(topRecord, SLITE_STATE_INITIAL);
+            (void)ScheduleLifecycleInner(topRecord, SLITE_STATE_INITIAL);
         } else {
-            (void) SchedulerLifecycleInner(topRecord, SLITE_STATE_FOREGROUND);
+            (void)ScheduleLifecycleInner(topRecord, SLITE_STATE_FOREGROUND);
         }
         if (GetCleanAbilityDataFlag()) {
             HILOG_INFO(HILOG_MODULE_AAFWK, "OnBackgroundDone clean launcher record data");
@@ -713,14 +723,13 @@ void AbilityRecordManager::OnDestroyDone(uint16_t token)
         SetAbilityState(token, SCHEDULE_STOP);
         return;
     }
-    auto topRecord = abilityStack_.GetTopAbility();
+    auto topRecord = abilityList_.GetTopAbility();
     if ((topRecord == nullptr) || (topRecord->token != token)) {
         SetAbilityState(token, SCHEDULE_STOP);
         DeleteRecordInfo(token);
         return;
     }
     APP_EVENT(MT_ACE_APP_STOP);
-    abilityStack_.PopAbility();
     DeleteRecordInfo(token);
     SetAbilityState(token, SCHEDULE_STOP);
 
@@ -731,16 +740,17 @@ void AbilityRecordManager::OnDestroyDone(uint16_t token)
     }
 
     // start pending token
-    auto record = abilityList_.Get(pendingToken_);
+    auto record = pendingRecord;
     if (record == nullptr) {
         return;
     }
     if (CreateAppTask(record) != ERR_OK) {
-        abilityList_.Erase(pendingToken_);
         delete record;
+        pendingRecord = nullptr;
         (void) SchedulerLifecycle(LAUNCHER_TOKEN, SLITE_STATE_FOREGROUND);
     }
     pendingToken_ = 0;
+    pendingRecord = nullptr;
 #else
     auto onDestroyRecord = abilityList_.Get(token);
     if (onDestroyRecord == nullptr) {
@@ -765,9 +775,8 @@ void AbilityRecordManager::OnDestroyDone(uint16_t token)
         }
         if (CreateAppTask(record) != ERR_OK) {
             abilityList_.Erase(pendingToken_);
-            abilityStack_.Erase(record);
             delete record;
-            auto topRecord = abilityStack_.GetTopAbility();
+            auto topRecord = abilityList_.GetTopAbility();
             if (topRecord == nullptr) {
                 HILOG_ERROR(HILOG_MODULE_AAFWK, "record stack is empty");
                 return;
@@ -776,9 +785,12 @@ void AbilityRecordManager::OnDestroyDone(uint16_t token)
         }
         pendingToken_ = 0;
     } else {
-        // start launcher
-        auto launcherRecord = abilityStack_.GetTopAbility();
-        StartAbility(launcherRecord);
+        // start top ability
+        auto topAbilityRecord = abilityList_.GetTopAbility();
+        if (pendingToken_ == 0 && CreateAppTask(topAbilityRecord) != ERR_OK) {
+            abilityList_.Erase(topAbilityRecord->token);
+            delete topAbilityRecord;
+        }
     }
 #endif
 }
@@ -790,9 +802,9 @@ int32_t AbilityRecordManager::SchedulerLifecycle(uint64_t token, int32_t state)
         return PARAM_NULL_ERROR;
     }
 #ifndef _MINI_MULTI_TASKS_
-    return SchedulerLifecycleInner(record, state);
+    return ScheduleLifecycleInner(record, state);
 #else
-    return SendMsgToAbilityThread(record, state);
+    return SendMsgToAbilityThread(state, record);
 #endif
 }
 
@@ -805,14 +817,15 @@ void AbilityRecordManager::SetAbilityState(uint64_t token, int32_t state)
     record->state = state;
 }
 
-int32_t AbilityRecordManager::SchedulerLifecycleInner(const AbilityRecord *record, int32_t state)
+#ifndef _MINI_MULTI_TASKS_
+int32_t AbilityRecordManager::ScheduleLifecycleInner(const AbilityRecord *record, int32_t state)
 {
     if (record == nullptr) {
         return PARAM_NULL_ERROR;
     }
     // dispatch js life cycle
     if (record->token != LAUNCHER_TOKEN) {
-        (void) SendMsgToJsAbility(state, record);
+        (void) SendMsgToAbilityThread(state, record);
         return ERR_OK;
     }
     // dispatch native life cycle
@@ -843,6 +856,7 @@ int32_t AbilityRecordManager::SchedulerLifecycleInner(const AbilityRecord *recor
     AdapterFree(info);
     return ERR_OK;
 }
+#endif
 
 void AbilityRecordManager::SchedulerAbilityLifecycle(SliteAbility *ability, const Want &want, int32_t state)
 {
@@ -891,14 +905,10 @@ int32_t AbilityRecordManager::SchedulerLifecycleDone(uint64_t token, int32_t sta
     return ERR_OK;
 }
 
-#ifndef _MINI_MULTI_TASKS_
-bool AbilityRecordManager::SendMsgToJsAbility(int32_t state, const AbilityRecord *record)
-#else
-bool AbilityRecordManager::SendMsgToAbilityThread(const AbilityRecord *record, int32_t state)
-#endif
+int32_t AbilityRecordManager::SendMsgToAbilityThread(int32_t state, const AbilityRecord *record)
 {
     if (record == nullptr) {
-        return false;
+        return PARAM_NULL_ERROR;
     }
 
     SliteAbilityInnerMsg innerMsg;
@@ -925,7 +935,10 @@ bool AbilityRecordManager::SendMsgToAbilityThread(const AbilityRecord *record, i
     }
     osMessageQueueId_t appQueueId = record->jsAppQueueId;
     osStatus_t ret = osMessageQueuePut(appQueueId, static_cast<void *>(&innerMsg), 0, 0);
-    return ret == osOK;
+    if (ret != osOK) {
+        return IPC_REQUEST_ERROR;
+    }
+    return ERR_OK;
 }
 
 Want *AbilityRecordManager::CreateWant(const AbilityRecord *record)
@@ -944,7 +957,7 @@ Want *AbilityRecordManager::CreateWant(const AbilityRecord *record)
 
 ElementName *AbilityRecordManager::GetTopAbility()
 {
-    auto topRecord = const_cast<AbilityRecord *>(abilityStack_.GetTopAbility());
+    auto topRecord = const_cast<AbilityRecord *>(abilityList_.GetTopAbility());
     AbilityRecord *launcherRecord = abilityList_.Get(LAUNCHER_TOKEN);
     if (topRecord == nullptr || launcherRecord == nullptr) {
         return nullptr;
diff --git a/services/abilitymgr_lite/src/slite/ability_stack.cpp b/services/abilitymgr_lite/src/slite/ability_stack.cpp
deleted file mode 100644
index b475e948e6b49a0e4c5c553e142e72e9fee15a9d..0000000000000000000000000000000000000000
--- a/services/abilitymgr_lite/src/slite/ability_stack.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2020 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "ability_stack.h"
-
-#include "ability_record.h"
-
-namespace OHOS {
-namespace AbilitySlite {
-const AbilityRecord *AbilityStack::GetTopAbility() const
-{
-    if (abilityStack_.Size() != 0) {
-        return abilityStack_.Front();
-    }
-    return nullptr;
-}
-
-void AbilityStack::PushAbility(AbilityRecord *record)
-{
-    if (record != nullptr) {
-        abilityStack_.PushFront(record);
-    }
-}
-
-void AbilityStack::PopAbility()
-{
-    abilityStack_.PopFront();
-}
-
-void AbilityStack::Erase(AbilityRecord *record)
-{
-    Node<AbilityRecord *> *node = abilityStack_.Begin();
-    const Node<AbilityRecord *> *end = abilityStack_.End();
-    while (node != end) {
-        if (node == nullptr) {
-            break;
-        }
-        if (node->value_ == record) {
-            abilityStack_.Remove(node);
-            break;
-        }
-        node = node->next_;
-    }
-}
-
-uint32_t AbilityStack::Size() const
-{
-    return abilityStack_.Size();
-}
-} // namespace AbilitySlite
-} // namespace OHOS
\ No newline at end of file
diff --git a/services/abilitymgr_lite/src/slite/ability_thread.cpp b/services/abilitymgr_lite/src/slite/ability_thread.cpp
index 1ebcddaed5b1972e82e8ef281c672664f7deca9d..fa5abb6b7dfb8bf94fdd6d1c36411bcabd4ad51e 100644
--- a/services/abilitymgr_lite/src/slite/ability_thread.cpp
+++ b/services/abilitymgr_lite/src/slite/ability_thread.cpp
@@ -15,41 +15,15 @@
 
 #include "ability_thread.h"
 
-#include <string.h>
-
 #include "ability_errors.h"
-#include "ability_manager_inner.h"
-#include "bms_helper.h"
-#include "slite_ability_state.h"
-#include "los_task.h"
 #include "ability_inner_message.h"
-#include "adapter.h"
 
 namespace OHOS {
 namespace AbilitySlite {
 
 AbilityThread::AbilityThread() = default;
 
-AbilityThread::~AbilityThread()
-{
-    if (ability_ != nullptr && ability_->bundleName_ != nullptr) {
-        if (!BMSHelper::GetInstance().IsNativeApp(ability_->bundleName_)) {
-            // js ability thread deconstruction
-            delete ability_;
-            ability_ = nullptr;
-            if (messageQueueId_ != nullptr) {
-                osMessageQueueDelete(messageQueueId_);
-            }
-            messageQueueId_ = nullptr;
-        } else {
-            // native ability thread deconstruction
-            if (strcmp(ability_->bundleName_, LAUNCHER_BUNDLE_NAME) != 0) {
-                delete ability_;
-                ability_ = nullptr;
-            }
-        }
-    }
-}
+AbilityThread::~AbilityThread() = default;
 
 int32_t AbilityThread::HandleCreate(const Want *want)
 {
diff --git a/services/abilitymgr_lite/src/slite/bms_helper.cpp b/services/abilitymgr_lite/src/slite/bms_helper.cpp
index eabe33d928d71760d79fe0b9e44001221fd82246..52c9eaa7fe7d4b059ad912a4013e47f6b2f9f1b5 100644
--- a/services/abilitymgr_lite/src/slite/bms_helper.cpp
+++ b/services/abilitymgr_lite/src/slite/bms_helper.cpp
@@ -117,4 +117,4 @@ void BMSHelper::ClearAbilitySvcInfo(AbilitySvcInfo *abilitySvcInfo)
     AdapterFree(abilitySvcInfo->bundleName);
     AdapterFree(abilitySvcInfo->path);
 }
-}
\ No newline at end of file
+}
diff --git a/services/abilitymgr_lite/src/slite/dummy_js_ability.cpp b/services/abilitymgr_lite/src/slite/dummy_js_ability.cpp
deleted file mode 100644
index 2cae6c1919e2d6076b995710133ee52d3c877f23..0000000000000000000000000000000000000000
--- a/services/abilitymgr_lite/src/slite/dummy_js_ability.cpp
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "dummy_js_ability.h"
-#include "js_async_work.h"
-
-namespace OHOS {
-namespace AbilitySlite {
-void DummyJsAbility::OnCreate(const Want &want)
-{
-    jsAbility_.Launch(want.appPath, want.element->bundleName, token_);
-    SliteAbility::OnCreate(want);
-}
-
-void DummyJsAbility::OnForeground(const Want &want)
-{
-    jsAbility_.Show();
-    isBackground_ = false;
-    SliteAbility::OnForeground(want);
-}
-
-void DummyJsAbility::OnBackground()
-{
-    isBackground_ = true;
-    jsAbility_.Hide();
-    SliteAbility::OnBackground();
-}
-
-void DummyJsAbility::OnDestroy()
-{
-    ACELite::JsAsyncWork::SetAppQueueHandler(nullptr);
-    // the TE owner will be JS application after JS application start up except for it's lying in background,
-    // call render once to make sure the last TE message is processed properly
-    if (!isBackground_) {
-        jsAbility_.HandleRenderTick();
-    }
-    jsAbility_.TransferToDestroy();
-    SliteAbility::OnDestroy();
-}
-
-void DummyJsAbility::HandleExtraMessage(const SliteAbilityInnerMsg &innerMsg)
-{
-    switch (innerMsg.msgId) {
-        case SliteAbilityMsgId::BACKPRESSED:
-            jsAbility_.BackPressed();
-            break;
-        case SliteAbilityMsgId::ASYNCWORK: {
-            auto* work = reinterpret_cast<ACELite::AsyncWork *>(innerMsg.data);
-            ACELite::JsAsyncWork::ExecuteAsyncWork(work);
-            break;
-        }
-        case SliteAbilityMsgId::TE_EVENT:
-            jsAbility_.HandleRenderTick();
-            break;
-        default:
-            break;
-    }
-}
-} // namespace AbilitySlite
-} // namespace OHOS
diff --git a/services/abilitymgr_lite/src/slite/js_ability_thread.cpp b/services/abilitymgr_lite/src/slite/js_ability_thread.cpp
index 7eefedba3492f150ca8967bae09353c4a827cfdf..1bb8b9f2504a0d54e6a4d477caaa523aa07245ea 100644
--- a/services/abilitymgr_lite/src/slite/js_ability_thread.cpp
+++ b/services/abilitymgr_lite/src/slite/js_ability_thread.cpp
@@ -18,9 +18,7 @@
 #include "abilityms_log.h"
 #include "ability_errors.h"
 #include "ability_inner_message.h"
-#include "ability_manager_inner.h"
 #include "adapter.h"
-#include "dummy_js_ability.h"
 #include "js_ability.h"
 #include "js_async_work.h"
 #include "los_task.h"
@@ -34,7 +32,15 @@ static char g_jsAppTask[] = "AppTask";
 
 JsAbilityThread::JsAbilityThread() = default;
 
-JsAbilityThread::~JsAbilityThread() = default;
+JsAbilityThread::~JsAbilityThread()
+{
+    delete ability_;
+    ability_ = nullptr;
+    if (messageQueueId_ != nullptr) {
+        osMessageQueueDelete(messageQueueId_);
+        messageQueueId_ = nullptr;
+    }
+}
 
 int32_t JsAbilityThread::InitAbilityThread(const AbilityRecord *abilityRecord)
 {
@@ -100,6 +106,16 @@ int32_t JsAbilityThread::ReleaseAbilityThread()
     return ERR_OK;
 }
 
+osMessageQueueId_t JsAbilityThread::GetMessageQueueId() const
+{
+    return messageQueueId_;
+}
+
+UINT32 JsAbilityThread::GetAppTaskId() const
+{
+    return appTaskId_;
+}
+
 void JsAbilityThread::AppTaskHandler(UINT32 uwArg)
 {
     auto messageQueueId = reinterpret_cast<osMessageQueueId_t>(uwArg);
diff --git a/services/abilitymgr_lite/src/slite/native_ability_thread.cpp b/services/abilitymgr_lite/src/slite/native_ability_thread.cpp
index 36a6ffce815901cbe591dd3409ad1761a7cbaad8..e4a9ab44faaad5d50f4aede3bd0cbc8c261511a6 100644
--- a/services/abilitymgr_lite/src/slite/native_ability_thread.cpp
+++ b/services/abilitymgr_lite/src/slite/native_ability_thread.cpp
@@ -15,16 +15,12 @@
 
 #include "native_ability_thread.h"
 
-#include <string.h>
-
-#include "aafwk_event_error_id.h"
+#include <cstring>
 #include "aafwk_event_error_code.h"
-#include "ability_manager_inner.h"
 #include "ability_errors.h"
 #include "ability_inner_message.h"
 #include "ability_record_manager.h"
 #include "adapter.h"
-#include "slite_ability_state.h"
 #include "ability_thread.h"
 #include "abilityms_log.h"
 #include "los_task.h"
@@ -36,13 +32,22 @@ static char g_NativeAppTask[] = "NativeAppTask";
 constexpr int32_t APP_TASK_PRI = 25;
 constexpr int32_t QUEUE_LENGTH = 32;
 
-osMessageQueueId_t NativeAbilityThread::nativeQueueId = nullptr;
-UINT32 NativeAbilityThread::nativeTaskId = 0;
+osMessageQueueId_t NativeAbilityThread::nativeQueueId_ = nullptr;
+UINT32 NativeAbilityThread::nativeTaskId_ = UINT32_MAX;
 SliteAbility *NativeAbilityThread::nativeAbility_ = nullptr;
 
 NativeAbilityThread::NativeAbilityThread() = default;
 
-NativeAbilityThread::~NativeAbilityThread() = default;
+NativeAbilityThread::~NativeAbilityThread()
+{
+    if (ability_ == nullptr) {
+        return;
+    }
+    if ((ability_->bundleName_ == nullptr) || (strcmp(ability_->bundleName_, LAUNCHER_BUNDLE_NAME) != 0)) {
+        delete ability_;
+        ability_ = nullptr;
+    }
+}
 
 int32_t NativeAbilityThread::InitAbilityThread(const AbilityRecord *abilityRecord)
 {
@@ -59,17 +64,16 @@ int32_t NativeAbilityThread::InitAbilityThread(const AbilityRecord *abilityRecor
         return PARAM_CHECK_ERROR;
     }
 
-    if (nativeQueueId == nullptr) {
-        nativeQueueId = osMessageQueueNew(QUEUE_LENGTH, sizeof(SliteAbilityInnerMsg), nullptr);
+    if (nativeQueueId_ == nullptr) {
+        nativeQueueId_ = osMessageQueueNew(QUEUE_LENGTH, sizeof(SliteAbilityInnerMsg), nullptr);
     }
-    messageQueueId_ = nativeQueueId;
-    if (messageQueueId_ == nullptr) {
+    if (nativeQueueId_ == nullptr) {
         HILOG_ERROR(HILOG_MODULE_AAFWK, "NativeAbilityThread init fail: messageQueueId is null");
         return MEMORY_MALLOC_ERROR;
     }
 
     HILOG_INFO(HILOG_MODULE_AAFWK, "CreateAppTask.");
-    if (nativeTaskId == 0) {
+    if (nativeTaskId_ == UINT32_MAX) {
         TSK_INIT_PARAM_S stTskInitParam = { 0 };
         LOS_TaskLock();
         stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC) (NativeAbilityThread::NativeAppTaskHandler);
@@ -77,37 +81,31 @@ int32_t NativeAbilityThread::InitAbilityThread(const AbilityRecord *abilityRecor
         stTskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST - APP_TASK_PRI;
         stTskInitParam.pcName = g_NativeAppTask;
         stTskInitParam.uwResved = 0;
-        stTskInitParam.uwArg = reinterpret_cast<UINT32>((uintptr_t) messageQueueId_);
-        uint32_t ret = LOS_TaskCreate(&nativeTaskId, &stTskInitParam);
+        stTskInitParam.uwArg = reinterpret_cast<UINT32>((uintptr_t) nativeQueueId_);
+        uint32_t ret = LOS_TaskCreate(&nativeTaskId_, &stTskInitParam);
         if (ret != LOS_OK) {
             HILOG_ERROR(HILOG_MODULE_AAFWK, "NativeAbilityThread init fail: LOS_TaskCreate ret %{public}d", ret);
-            osMessageQueueDelete(messageQueueId_);
+            osMessageQueueDelete(nativeQueueId_);
             LOS_TaskUnlock();
             return CREATE_APPTASK_ERROR;
         }
     }
-    appTaskId_ = nativeTaskId;
+
     state_ = AbilityThreadState::ABILITY_THREAD_INITIALIZED;
-    if (nativeAbility_ != nullptr) {
-        if (nativeAbility_->bundleName_ == nullptr) {
-            return PARAM_NULL_ERROR;
-        }
-        if (strcmp(nativeAbility_->bundleName_, abilityRecord->appName) != 0) {
-            ability_ = SliteAbilityLoader::GetInstance().CreateAbility(SliteAbilityType::NATIVE_ABILITY,
-                abilityRecord->appName);
-        } else {
-            ability_ = nativeAbility_;
-        }
-    } else {
-        if (strcmp(abilityRecord->appName, LAUNCHER_BUNDLE_NAME) == 0) {
+
+    if (strcmp(abilityRecord->appName, LAUNCHER_BUNDLE_NAME) == 0) {
+        if (nativeAbility_ == nullptr) {
             nativeAbility_ = SliteAbilityLoader::GetInstance().CreateAbility(SliteAbilityType::NATIVE_ABILITY,
                 abilityRecord->appName);
         }
         ability_ = nativeAbility_;
+    } else {
+        ability_ = SliteAbilityLoader::GetInstance().CreateAbility(SliteAbilityType::NATIVE_ABILITY,
+            abilityRecord->appName);
     }
-
     if (ability_ == nullptr) {
         HILOG_INFO(HILOG_MODULE_AAFWK, "NativeAbility create fail");
+        LOS_TaskUnlock();
         return MEMORY_MALLOC_ERROR;
     }
     ability_->SetToken(abilityRecord->token);
@@ -122,15 +120,27 @@ int32_t NativeAbilityThread::ReleaseAbilityThread()
         HILOG_ERROR(HILOG_MODULE_AAFWK, "NativeAbilityThread release fail, the AbilityThread is not inited");
         return PARAM_CHECK_ERROR;
     }
-    if (ability_->bundleName_ == nullptr) {
-        return PARAM_NULL_ERROR;
-    }
+    return ERR_OK;
+}
 
-    if (strcmp(ability_->bundleName_, LAUNCHER_BUNDLE_NAME) != 0) {
-        delete ability_;
-        ability_ = nullptr;
+osMessageQueueId_t NativeAbilityThread::GetMessageQueueId() const
+{
+    return nativeQueueId_;
+}
+
+UINT32 NativeAbilityThread::GetAppTaskId() const
+{
+    return nativeTaskId_;
+}
+
+void NativeAbilityThread::Reset()
+{
+    if (nativeQueueId_ != nullptr) {
+        osMessageQueueDelete(nativeQueueId_);
     }
-    return ERR_OK;
+    nativeQueueId_ = nullptr;
+    nativeTaskId_ = 0;
+    nativeAbility_ = nullptr;
 }
 
 void NativeAbilityThread::NativeAppTaskHandler(UINT32 uwArg)