diff --git a/include/AsstCaller.h b/include/AsstCaller.h
index 8343f1d3a1..cde6c9fc1e 100644
--- a/include/AsstCaller.h
+++ b/include/AsstCaller.h
@@ -10,40 +10,41 @@ namespace asst
 #ifdef __cplusplus
 extern "C" {
 #endif
-    typedef void(ASST_CALL* AsstCallback)(int msg, const char* detail_json, void* custom_arg);
+    typedef asst::Assistant* AsstHandle;
+    typedef void(ASST_CALL* AsstApiCallback)(int msg, const char* detail_json, void* custom_arg);
 
     bool ASSTAPI AsstLoadResource(const char* path);
-    ASSTAPI_PORT asst::Assistant* ASST_CALL AsstCreate();
-    ASSTAPI_PORT asst::Assistant* ASST_CALL AsstCreateEx(AsstCallback callback, void* custom_arg);
-    void ASSTAPI AsstDestroy(asst::Assistant* p_asst);
+    ASSTAPI_PORT AsstHandle ASST_CALL AsstCreate();
+    ASSTAPI_PORT AsstHandle ASST_CALL AsstCreateEx(AsstApiCallback callback, void* custom_arg);
+    void ASSTAPI AsstDestroy(AsstHandle handle);
 
-    bool ASSTAPI AsstConnect(asst::Assistant* p_asst, const char* adb_path, const char* address, const char* config);
+    bool ASSTAPI AsstConnect(AsstHandle handle, const char* adb_path, const char* address, const char* config);
 
-    bool ASSTAPI AsstAppendStartUp(asst::Assistant* p_asst);
-    bool ASSTAPI AsstAppendFight(asst::Assistant* p_asst, const char* stage, int max_mecidine, int max_stone, int max_times);
-    bool ASSTAPI AsstAppendAward(asst::Assistant* p_asst);
-    bool ASSTAPI AsstAppendVisit(asst::Assistant* p_asst);
-    bool ASSTAPI AsstAppendMall(asst::Assistant* p_asst, bool with_shopping);
-    // bool ASSTAPI AsstAppendProcessTask(asst::Assistant* p_asst, const char* task_name);
-    bool ASSTAPI AsstAppendInfrast(asst::Assistant* p_asst, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold);
-    bool ASSTAPI AsstAppendRecruit(asst::Assistant* p_asst, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited);
-    bool ASSTAPI AsstAppendRoguelike(asst::Assistant* p_asst, int mode);
+    bool ASSTAPI AsstAppendStartUp(AsstHandle handle);
+    bool ASSTAPI AsstAppendFight(AsstHandle handle, const char* stage, int max_mecidine, int max_stone, int max_times);
+    bool ASSTAPI AsstAppendAward(AsstHandle handle);
+    bool ASSTAPI AsstAppendVisit(AsstHandle handle);
+    bool ASSTAPI AsstAppendMall(AsstHandle handle, bool with_shopping);
+    // bool ASSTAPI AsstAppendProcessTask(AsstHandle handle, const char* task_name);
+    bool ASSTAPI AsstAppendInfrast(AsstHandle handle, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold);
+    bool ASSTAPI AsstAppendRecruit(AsstHandle handle, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited);
+    bool ASSTAPI AsstAppendRoguelike(AsstHandle handle, int mode);
 
-    bool ASSTAPI AsstAppendDebug(asst::Assistant* p_asst);
+    bool ASSTAPI AsstAppendDebug(AsstHandle handle);
 
-    bool ASSTAPI AsstStartRecruitCalc(asst::Assistant* p_asst, const int select_level[], int required_len, bool set_time);
-    bool ASSTAPI AsstStart(asst::Assistant* p_asst);
-    bool ASSTAPI AsstStop(asst::Assistant* p_asst);
+    bool ASSTAPI AsstStartRecruitCalc(AsstHandle handle, const int select_level[], int required_len, bool set_time);
+    bool ASSTAPI AsstStart(AsstHandle handle);
+    bool ASSTAPI AsstStop(AsstHandle handle);
 
-    bool ASSTAPI AsstSetPenguinId(asst::Assistant* p_asst, const char* id);
-    // bool ASSTAPI AsstSetParam(asst::Assistant* p_asst, const char* type, const char* param, const char* value);
+    bool ASSTAPI AsstSetPenguinId(AsstHandle handle, const char* id);
+    // bool ASSTAPI AsstSetParam(AsstHandle handle, const char* type, const char* param, const char* value);
 
-    unsigned long long ASSTAPI AsstGetImage(asst::Assistant* p_asst, void* buff, unsigned long long buff_size);
-    bool ASSTAPI AsstCtrlerClick(asst::Assistant* p_asst, int x, int y, bool block);
+    unsigned long long ASSTAPI AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size);
+    bool ASSTAPI AsstCtrlerClick(AsstHandle handle, int x, int y, bool block);
 
     ASSTAPI_PORT const char* ASST_CALL AsstGetVersion();
 
-    void ASSTAPI AsstLog(asst::Assistant* p_asst, const char* level, const char* message);
+    void ASSTAPI AsstLog(AsstHandle handle, const char* level, const char* message);
 
 #ifdef __cplusplus
 }
diff --git a/src/MeoAssistant/AbstractTask.cpp b/src/MeoAssistant/AbstractTask.cpp
index d7326f8f56..8d109b3360 100644
--- a/src/MeoAssistant/AbstractTask.cpp
+++ b/src/MeoAssistant/AbstractTask.cpp
@@ -64,6 +64,12 @@ AbstractTask& asst::AbstractTask::set_ctrler(std::shared_ptr<Controller> ctrler)
     return *this;
 }
 
+AbstractTask& asst::AbstractTask::set_status(std::shared_ptr<RuntimeStatus> status) noexcept
+{
+    m_status = status;
+    return *this;
+}
+
 void asst::AbstractTask::clear_plugin() noexcept
 {
     m_plugins.clear();
diff --git a/src/MeoAssistant/AbstractTask.h b/src/MeoAssistant/AbstractTask.h
index 96da644455..602f01c9db 100644
--- a/src/MeoAssistant/AbstractTask.h
+++ b/src/MeoAssistant/AbstractTask.h
@@ -18,6 +18,7 @@ namespace asst
     using TaskPluginPtr = std::shared_ptr<AbstractTaskPlugin>;
 
     class Controller;
+    class RuntimeStatus;
 
     class AbstractTask
     {
@@ -32,6 +33,7 @@ namespace asst
         AbstractTask& set_exit_flag(bool* exit_flag) noexcept;
         AbstractTask& set_retry_times(int times) noexcept;
         AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
+        AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
 
         template<typename PluginType>
         std::shared_ptr<PluginType> regiseter_plugin()
@@ -70,5 +72,6 @@ namespace asst
         mutable json::value m_basic_info_cache;
         std::set<TaskPluginPtr> m_plugins;
         std::shared_ptr<Controller> m_ctrler = nullptr;
+        std::shared_ptr<RuntimeStatus> m_status = nullptr;
     };
 }
diff --git a/src/MeoAssistant/Assistant.cpp b/src/MeoAssistant/Assistant.cpp
index ec2b393dbd..0ede6531b0 100644
--- a/src/MeoAssistant/Assistant.cpp
+++ b/src/MeoAssistant/Assistant.cpp
@@ -30,16 +30,17 @@
 
 using namespace asst;
 
-Assistant::Assistant(AsstCallback callback, void* callback_arg)
+Assistant::Assistant(AsstApiCallback callback, void* callback_arg)
     : m_callback(callback),
     m_callback_arg(callback_arg)
 {
     LogTraceFunction;
 
+    m_status = std::make_shared<RuntimeStatus>();
     m_ctrler = std::make_shared<Controller>(task_callback, (void*)this);
 
-    m_working_thread = std::thread(std::bind(&Assistant::working_proc, this));
-    m_msg_thread = std::thread(std::bind(&Assistant::msg_proc, this));
+    m_working_thread = std::thread(&Assistant::working_proc, this);
+    m_msg_thread = std::thread(&Assistant::msg_proc, this);
 }
 
 Assistant::~Assistant()
@@ -489,8 +490,10 @@ void Assistant::working_proc()
                 task_callback(AsstMsg::TaskChainStart, callback_json, this);
             }
 
-            task_ptr->set_exit_flag(&m_thread_idle);
-            task_ptr->set_ctrler(m_ctrler);
+            task_ptr->set_exit_flag(&m_thread_idle)
+                .set_ctrler(m_ctrler)
+                .set_status(m_status);
+
             bool ret = task_ptr->run();
 
             if (cur_taskchain != next_taskchain) {
@@ -536,7 +539,7 @@ void Assistant::msg_proc()
             lock.unlock();
 
             if (m_callback) {
-                m_callback(msg, detail, m_callback_arg);
+                m_callback(static_cast<int>(msg), detail.to_string().c_str(), m_callback_arg);
             }
         }
         else {
@@ -575,6 +578,6 @@ void asst::Assistant::append_callback(AsstMsg msg, json::value detail)
 
 void Assistant::clear_cache()
 {
-    Status.clear();
+    m_status->clear_data();
     //Task.clear_cache();
 }
diff --git a/src/MeoAssistant/Assistant.h b/src/MeoAssistant/Assistant.h
index d047f39bdb..78017542f2 100644
--- a/src/MeoAssistant/Assistant.h
+++ b/src/MeoAssistant/Assistant.h
@@ -29,7 +29,7 @@ namespace asst
     class Assistant
     {
     public:
-        Assistant(AsstCallback callback = nullptr, void* callback_arg = nullptr);
+        Assistant(AsstApiCallback callback = nullptr, void* callback_arg = nullptr);
         ~Assistant();
 
         // 连接adb
@@ -101,11 +101,12 @@ namespace asst
         bool m_inited = false;
         std::string m_uuid;
 
-        std::shared_ptr<Controller> m_ctrler;
+        std::shared_ptr<Controller> m_ctrler = nullptr;
+        std::shared_ptr<RuntimeStatus> m_status = nullptr;
 
         bool m_thread_exit = false;
         std::queue<std::shared_ptr<AbstractTask>> m_tasks_queue;
-        AsstCallback m_callback = nullptr;
+        AsstApiCallback m_callback = nullptr;
         void* m_callback_arg = nullptr;
 
         bool m_thread_idle = true;
diff --git a/src/MeoAssistant/AsstCaller.cpp b/src/MeoAssistant/AsstCaller.cpp
index 24d4beebdb..df3646a847 100644
--- a/src/MeoAssistant/AsstCaller.cpp
+++ b/src/MeoAssistant/AsstCaller.cpp
@@ -35,159 +35,123 @@ BOOL APIENTRY DllMain(HINSTANCE hModule,
 #endif
 #endif
 
-AsstCallback _callback = nullptr;
-
-void CallbackTrans(asst::AsstMsg msg, const json::value& json, void* custom_arg)
-{
-    _callback(static_cast<int>(msg), json.to_string().c_str(), custom_arg);
-}
-
 bool AsstLoadResource(const char* path)
 {
     return asst::Logger::set_dirname(std::string(path) + "/")
         && asst::Resrc.load(std::string(path) + "/resource/");
 }
 
-asst::Assistant* AsstCreate()
+AsstHandle AsstCreate()
 {
-    if (_callback != nullptr) {
-        std::cerr << "An instance of Asst already exists" << std::endl;
-        return nullptr;
-    }
-    try {
-        _callback = nullptr;
-        return new asst::Assistant();
-    }
-    catch (std::exception& e) {
-        std::cerr << "create failed: " << e.what() << std::endl;
-    }
-    catch (...) {
-        std::cerr << "create failed: unknown exception" << std::endl;
-    }
-    return nullptr;
+    return new asst::Assistant();
 }
 
-asst::Assistant* AsstCreateEx(AsstCallback callback, void* custom_arg)
+AsstHandle AsstCreateEx(AsstApiCallback callback, void* custom_arg)
 {
-    if (_callback != nullptr) {
-        std::cerr << "An instance of Asst already exists" << std::endl;
-        return nullptr;
-    }
-    try {
-        _callback = callback;
-        return new asst::Assistant(CallbackTrans, custom_arg);
-    }
-    catch (std::exception& e) {
-        std::cerr << "create failed: " << e.what() << std::endl;
-    }
-    catch (...) {
-        std::cerr << "create failed: unknown exception" << std::endl;
-    }
-    return nullptr;
+    return new asst::Assistant(callback, custom_arg);
 }
 
-void AsstDestroy(asst::Assistant* p_asst)
+void AsstDestroy(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return;
     }
 
-    delete p_asst;
-    p_asst = nullptr;
-    _callback = nullptr;
+    delete handle;
+    handle = nullptr;
 }
 
-bool AsstConnect(asst::Assistant* p_asst, const char* adb_path, const char* address, const char* config)
+bool AsstConnect(AsstHandle handle, const char* adb_path, const char* address, const char* config)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->connect(adb_path, address, config ? config : std::string());
+    return handle->connect(adb_path, address, config ? config : std::string());
 }
 
-bool ASSTAPI AsstAppendStartUp(asst::Assistant* p_asst)
+bool ASSTAPI AsstAppendStartUp(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->append_start_up();
+    return handle->append_start_up();
 }
 
-bool AsstAppendFight(asst::Assistant* p_asst, const char* stage, int max_mecidine, int max_stone, int max_times)
+bool AsstAppendFight(AsstHandle handle, const char* stage, int max_mecidine, int max_stone, int max_times)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->append_fight(stage, max_mecidine, max_stone, max_times);
+    return handle->append_fight(stage, max_mecidine, max_stone, max_times);
 }
 
-bool AsstAppendAward(asst::Assistant* p_asst)
+bool AsstAppendAward(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->append_award();
+    return handle->append_award();
 }
 
-bool AsstAppendVisit(asst::Assistant* p_asst)
+bool AsstAppendVisit(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->append_visit();
+    return handle->append_visit();
 }
 
-bool AsstAppendMall(asst::Assistant* p_asst, bool with_shopping)
+bool AsstAppendMall(AsstHandle handle, bool with_shopping)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->append_mall(with_shopping);
+    return handle->append_mall(with_shopping);
 }
 
-//bool AsstAppendProcessTask(asst::Assistant* p_asst, const char* task_name)
+//bool AsstAppendProcessTask(AsstHandle handle, const char* task_name)
 //{
-//    if (p_asst == nullptr) {
+//    if (handle == nullptr) {
 //        return false;
 //    }
 //
-//    return p_asst->append_process_task(task_name);
+//    return handle->append_process_task(task_name);
 //}
 
-bool AsstStartRecruitCalc(asst::Assistant* p_asst, const int select_level[], int required_len, bool set_time)
+bool AsstStartRecruitCalc(AsstHandle handle, const int select_level[], int required_len, bool set_time)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
     std::vector<int> level_vector;
     level_vector.assign(select_level, select_level + required_len);
-    return p_asst->start_recruit_calc(level_vector, set_time);
+    return handle->start_recruit_calc(level_vector, set_time);
 }
 
-bool AsstAppendInfrast(asst::Assistant* p_asst, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold)
+bool AsstAppendInfrast(AsstHandle handle, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
     std::vector<std::string> order_vector;
     order_vector.assign(order, order + order_size);
 
-    return p_asst->append_infrast(
+    return handle->append_infrast(
         static_cast<asst::infrast::WorkMode>(work_mode),
         order_vector,
         uses_of_drones,
         dorm_threshold);
 }
 
-bool AsstAppendRecruit(asst::Assistant* p_asst, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited)
+bool AsstAppendRecruit(AsstHandle handle, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
     std::vector<int> required_vector;
@@ -195,51 +159,51 @@ bool AsstAppendRecruit(asst::Assistant* p_asst, int max_times, const int select_
     std::vector<int> confirm_vector;
     confirm_vector.assign(confirm_level, confirm_level + confirm_len);
 
-    return p_asst->append_recruit(max_times, required_vector, confirm_vector, need_refresh, use_expedited);
+    return handle->append_recruit(max_times, required_vector, confirm_vector, need_refresh, use_expedited);
 }
 
-bool AsstAppendRoguelike(asst::Assistant* p_asst, int mode)
+bool AsstAppendRoguelike(AsstHandle handle, int mode)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
-    return p_asst->append_roguelike(mode);
+    return handle->append_roguelike(mode);
 }
 
-bool AsstStart(asst::Assistant* p_asst)
+bool AsstStart(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->start();
+    return handle->start();
 }
 
-bool AsstStop(asst::Assistant* p_asst)
+bool AsstStop(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    return p_asst->stop();
+    return handle->stop();
 }
 
-bool AsstSetPenguinId(asst::Assistant* p_asst, const char* id)
+bool AsstSetPenguinId(AsstHandle handle, const char* id)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 
-    p_asst->set_penguin_id(id);
+    handle->set_penguin_id(id);
     return true;
 }
 
-unsigned long long AsstGetImage(asst::Assistant* p_asst, void* buff, unsigned long long buff_size)
+unsigned long long AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size)
 {
-    if (p_asst == nullptr || buff == nullptr) {
+    if (handle == nullptr || buff == nullptr) {
         return 0;
     }
-    auto img_data = p_asst->get_image();
+    auto img_data = handle->get_image();
     size_t data_size = img_data.size();
     if (buff_size < data_size) {
         return 0;
@@ -248,21 +212,21 @@ unsigned long long AsstGetImage(asst::Assistant* p_asst, void* buff, unsigned lo
     return data_size;
 }
 
-bool AsstCtrlerClick(asst::Assistant* p_asst, int x, int y, bool block)
+bool AsstCtrlerClick(AsstHandle handle, int x, int y, bool block)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
-    return p_asst->ctrler_click(x, y, block);
+    return handle->ctrler_click(x, y, block);
 }
 
-//bool AsstSetParam(asst::Assistant* p_asst, const char* type, const char* param, const char* value)
+//bool AsstSetParam(AsstHandle handle, const char* type, const char* param, const char* value)
 //{
-//    if (p_asst == nullptr) {
+//    if (handle == nullptr) {
 //        return false;
 //    }
 //
-//    return p_asst->set_param(type, param, value);
+//    return handle->set_param(type, param, value);
 //}
 
 const char* AsstGetVersion()
@@ -270,22 +234,22 @@ const char* AsstGetVersion()
     return asst::Version;
 }
 
-void AsstLog(asst::Assistant* p_asst, const char* level, const char* message)
+void AsstLog(AsstHandle handle, const char* level, const char* message)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return;
     }
 
     asst::Log.log_with_custom_level(level, message);
 }
 
-bool AsstAppendDebug(asst::Assistant* p_asst)
+bool AsstAppendDebug(AsstHandle handle)
 {
-    if (p_asst == nullptr) {
+    if (handle == nullptr) {
         return false;
     }
 #ifdef ASST_DEBUG
-    return p_asst->append_debug();
+    return handle->append_debug();
 #else
     return false;
 #endif // ASST_DEBUG
diff --git a/src/MeoAssistant/AsstDef.h b/src/MeoAssistant/AsstDef.h
index 042b08f7e4..782bc5d3b4 100644
--- a/src/MeoAssistant/AsstDef.h
+++ b/src/MeoAssistant/AsstDef.h
@@ -224,7 +224,6 @@ namespace asst
         Rect roi;                                    // 要识别的区域，若为0则全图识别
         Rect rect_move;                              // 识别结果移动：有些结果识别到的，和要点击的不是同一个位置。即识别到了res，点击res + result_move的位置
         bool cache = false;                          // 是否使用缓存区域
-        Rect region_of_appeared;                     // 缓存区域：上次识别成功过，本次只在这个rect里识别，省点性能
     };
 
     // 文字识别任务的信息
diff --git a/src/MeoAssistant/AsstMsg.h b/src/MeoAssistant/AsstMsg.h
index 7afc753c65..bf50639965 100644
--- a/src/MeoAssistant/AsstMsg.h
+++ b/src/MeoAssistant/AsstMsg.h
@@ -55,4 +55,6 @@ namespace asst
     // const json::value& 消息详情json，每种消息不同，Todo，需要补充个协议文档啥的
     // void* 外部调用者自定义参数，每次回调会带出去，建议传个(void*)this指针进来
     using AsstCallback = std::function<void(AsstMsg, const json::value&, void*)>;
+
+    using AsstApiCallback = void(*)(int msg, const char* detail_json, void* custom_arg);
 }
diff --git a/src/MeoAssistant/Controller.cpp b/src/MeoAssistant/Controller.cpp
index 3c7692b264..ba30a391c0 100644
--- a/src/MeoAssistant/Controller.cpp
+++ b/src/MeoAssistant/Controller.cpp
@@ -66,8 +66,7 @@ asst::Controller::Controller(AsstCallback callback, void* callback_arg)
         throw "controller pipe buffer allocated failed";
     }
 
-    auto bind_pipe_working_proc = std::bind(&Controller::pipe_working_proc, this);
-    m_cmd_thread = std::thread(bind_pipe_working_proc);
+    m_cmd_thread = std::thread(&Controller::pipe_working_proc, this);
 }
 
 asst::Controller::~Controller()
diff --git a/src/MeoAssistant/InfrastInfoTask.cpp b/src/MeoAssistant/InfrastInfoTask.cpp
index 75300dcd42..b0adacdb73 100644
--- a/src/MeoAssistant/InfrastInfoTask.cpp
+++ b/src/MeoAssistant/InfrastInfoTask.cpp
@@ -19,7 +19,7 @@ bool asst::InfrastInfoTask::_run()
     for (auto&& [name, res] : analyzer.get_result()) {
         std::string key = "NumOf" + name;
         //int size = static_cast<int>(res.size());
-        Status.set(key, res.size());
+        m_status->set_data(key, res.size());
         Log.trace("InfrastInfoTask | ", key, res.size());
     }
 
diff --git a/src/MeoAssistant/InfrastProductionTask.cpp b/src/MeoAssistant/InfrastProductionTask.cpp
index 3b9813d3c9..a215e74365 100644
--- a/src/MeoAssistant/InfrastProductionTask.cpp
+++ b/src/MeoAssistant/InfrastProductionTask.cpp
@@ -306,11 +306,11 @@ bool asst::InfrastProductionTask::optimal_calc()
         // 条件判断，不符合的直接过滤掉
         bool meet_condition = true;
         for (const auto& [cond, cond_value] : group.conditions) {
-            if (!Status.contains(cond)) {
+            if (!m_status->contains_data(cond)) {
                 continue;
             }
             // TODO：这里做成除了不等于，还可计算大于、小于等不同条件的
-            int cur_value = static_cast<int>(Status.get(cond));
+            int cur_value = static_cast<int>(m_status->get_data(cond));
             if (cur_value != cond_value) {
                 meet_condition = false;
                 break;
@@ -600,7 +600,7 @@ asst::InfrastProductionTask::efficient_regex_calc(
                 // TODO 报错！
             }
             std::string status_key = cur_formula.substr(pos + 1, rp_pos - pos - 1);
-            int64_t status_value = Status.get(status_key);
+            int64_t status_value = m_status->get_data(status_key);
             cur_formula.replace(pos, rp_pos - pos + 1, std::to_string(status_value));
         }
 
diff --git a/src/MeoAssistant/MatchImageAnalyzer.cpp b/src/MeoAssistant/MatchImageAnalyzer.cpp
index 9af95d6a1b..b10b682583 100644
--- a/src/MeoAssistant/MatchImageAnalyzer.cpp
+++ b/src/MeoAssistant/MatchImageAnalyzer.cpp
@@ -57,6 +57,14 @@ void asst::MatchImageAnalyzer::set_task_info(const std::string& task_name)
     set_task_info(Task.get(task_name));
 }
 
+void asst::MatchImageAnalyzer::set_region_of_appeared(Rect region) noexcept
+{
+    m_region_of_appeared = std::move(region);
+    if (m_use_cache && !m_region_of_appeared.empty()) {
+        m_roi = m_region_of_appeared;
+    }
+}
+
 const asst::MatchRect& asst::MatchImageAnalyzer::get_result() const noexcept
 {
     return m_result;
@@ -67,9 +75,10 @@ void asst::MatchImageAnalyzer::set_task_info(MatchTaskInfo task_info) noexcept
     m_mask_range = std::move(task_info.mask_range);
     m_templ_name = std::move(task_info.templ_name);
     m_templ_thres = task_info.templ_threshold;
+    m_use_cache = task_info.cache;
 
-    if (task_info.cache && !task_info.region_of_appeared.empty()) {
-        m_roi = task_info.region_of_appeared;
+    if (m_use_cache && !m_region_of_appeared.empty()) {
+        m_roi = m_region_of_appeared;
     }
     else {
         set_roi(task_info.roi);
diff --git a/src/MeoAssistant/MatchImageAnalyzer.h b/src/MeoAssistant/MatchImageAnalyzer.h
index aa059f3e5c..f057d1bb56 100644
--- a/src/MeoAssistant/MatchImageAnalyzer.h
+++ b/src/MeoAssistant/MatchImageAnalyzer.h
@@ -19,6 +19,7 @@ namespace asst
         void set_threshold(double templ_thres) noexcept;
         void set_task_info(std::shared_ptr<TaskInfo> task_ptr);
         void set_task_info(const std::string& task_name);
+        void set_region_of_appeared(Rect region) noexcept;
 
         const MatchRect& get_result() const noexcept;
 
@@ -30,6 +31,7 @@ namespace asst
         MatchRect m_result;
         double m_templ_thres = 0.0;
         bool m_use_cache = false;
+        Rect m_region_of_appeared;
         std::pair<int, int> m_mask_range;
     };
 }
diff --git a/src/MeoAssistant/OcrImageAnalyzer.cpp b/src/MeoAssistant/OcrImageAnalyzer.cpp
index 8164b8eacd..b27da36ca2 100644
--- a/src/MeoAssistant/OcrImageAnalyzer.cpp
+++ b/src/MeoAssistant/OcrImageAnalyzer.cpp
@@ -48,7 +48,7 @@ bool asst::OcrImageAnalyzer::analyze()
     preds_vec.emplace_back(m_pred);
 
     TextRectProc all_pred = [&](TextRect& tr) -> bool {
-        for (const auto &pred : preds_vec) {
+        for (const auto& pred : preds_vec) {
             if (pred && !pred(tr)) {
                 return false;
             }
@@ -73,6 +73,11 @@ bool asst::OcrImageAnalyzer::analyze()
     return !m_ocr_result.empty();
 }
 
+void asst::OcrImageAnalyzer::set_use_cache(bool is_use) noexcept
+{
+    m_use_cache = is_use;
+}
+
 void asst::OcrImageAnalyzer::set_required(std::vector<std::string> required, bool full_match) noexcept
 {
     m_required = std::move(required);
@@ -89,14 +94,14 @@ void asst::OcrImageAnalyzer::set_task_info(OcrTaskInfo task_info) noexcept
     m_required = std::move(task_info.text);
     m_full_match = task_info.need_full_match;
     m_replace = std::move(task_info.replace_map);
+    m_use_cache = task_info.cache;
 
-    set_roi(task_info.roi);
-    auto& cache_roi = task_info.region_of_appeared;
-    if (task_info.cache && !cache_roi.empty()) {
-        m_roi = cache_roi;
+    if (m_use_cache && !m_region_of_appeared.empty()) {
+        m_roi = m_region_of_appeared;
         m_without_det = true;
     }
     else {
+        set_roi(task_info.roi);
         m_without_det = false;
     }
 }
@@ -111,6 +116,15 @@ void asst::OcrImageAnalyzer::set_task_info(const std::string& task_name)
     set_task_info(Task.get(task_name));
 }
 
+void asst::OcrImageAnalyzer::set_region_of_appeared(Rect region) noexcept
+{
+    m_region_of_appeared = std::move(region);
+    if (m_use_cache && !m_region_of_appeared.empty()) {
+        m_roi = m_region_of_appeared;
+        m_without_det = true;
+    }
+}
+
 void asst::OcrImageAnalyzer::set_pred(const TextRectProc& pred)
 {
     m_pred = pred;
diff --git a/src/MeoAssistant/OcrImageAnalyzer.h b/src/MeoAssistant/OcrImageAnalyzer.h
index 55b3e2f876..cf6b97fc11 100644
--- a/src/MeoAssistant/OcrImageAnalyzer.h
+++ b/src/MeoAssistant/OcrImageAnalyzer.h
@@ -20,10 +20,12 @@ namespace asst
         void sort_result();             // 按位置排序，左上角的排在前面
         void sort_result_by_required(); // 按传入的需求数组排序，传入的在前面结果接在前面
 
+        void set_use_cache(bool is_use) noexcept;
         void set_required(std::vector<std::string> required, bool full_match = false) noexcept;
         void set_replace(std::unordered_map<std::string, std::string> replace) noexcept;
         void set_task_info(std::shared_ptr<TaskInfo> task_ptr);
         void set_task_info(const std::string& task_name);
+        void set_region_of_appeared(Rect region) noexcept;
 
         void set_pred(const TextRectProc& pred);
         const std::vector<TextRect>& get_result() const noexcept;
@@ -37,5 +39,7 @@ namespace asst
         std::unordered_map<std::string, std::string> m_replace;
         TextRectProc m_pred = nullptr;
         bool m_without_det = false;
+        bool m_use_cache = false;
+        Rect m_region_of_appeared;
     };
 }
diff --git a/src/MeoAssistant/ProcessTask.cpp b/src/MeoAssistant/ProcessTask.cpp
index 032dbcf88c..1934046875 100644
--- a/src/MeoAssistant/ProcessTask.cpp
+++ b/src/MeoAssistant/ProcessTask.cpp
@@ -95,6 +95,7 @@ bool ProcessTask::_run()
         else {
             const auto image = m_ctrler->get_image();
             ProcessTaskImageAnalyzer analyzer(image, m_cur_tasks_name);
+            analyzer.set_status(m_status);
             if (!analyzer.analyze()) {
                 return false;
             }
@@ -174,7 +175,7 @@ bool ProcessTask::_run()
             break;
         }
 
-        Status.set("Last" + cur_name, time(nullptr));
+        m_status->set_data("Last" + cur_name, time(nullptr));
 
         // 减少其他任务的执行次数
         // 例如，进入吃理智药的界面了，相当于上一次点蓝色开始行动没生效
diff --git a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
index 4230644a7a..a6d1ceb266 100644
--- a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
+++ b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
@@ -7,6 +7,7 @@
 #include "MatchImageAnalyzer.h"
 #include "OcrImageAnalyzer.h"
 #include "Resource.h"
+#include "RuntimeStatus.h"
 
 asst::ProcessTaskImageAnalyzer::ProcessTaskImageAnalyzer(const cv::Mat image, std::vector<std::string> tasks_name)
     : AbstractImageAnalyzer(image),
@@ -24,11 +25,12 @@ bool asst::ProcessTaskImageAnalyzer::match_analyze(std::shared_ptr<TaskInfo> tas
     }
     const auto match_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(task_ptr);
     m_match_analyzer->set_task_info(match_task_ptr);
+    m_match_analyzer->set_region_of_appeared(m_status->get_region(match_task_ptr->name));
 
     if (m_match_analyzer->analyze()) {
         m_result = match_task_ptr;
         m_result_rect = m_match_analyzer->get_result().rect;
-        task_ptr->region_of_appeared = m_result_rect;
+        m_status->set_region(match_task_ptr->name, m_result_rect);
         return true;
     }
     return false;
@@ -68,6 +70,7 @@ bool asst::ProcessTaskImageAnalyzer::ocr_analyze(std::shared_ptr<TaskInfo> task_
         m_ocr_analyzer = std::make_unique<OcrImageAnalyzer>(m_image);
     }
     m_ocr_analyzer->set_task_info(ocr_task_ptr);
+    m_ocr_analyzer->set_region_of_appeared(m_status->get_region(ocr_task_ptr->name));
 
     bool ret = m_ocr_analyzer->analyze();
 
@@ -77,7 +80,7 @@ bool asst::ProcessTaskImageAnalyzer::ocr_analyze(std::shared_ptr<TaskInfo> task_
         auto& res = ocr_result.front();
         m_result = ocr_task_ptr;
         m_result_rect = res.rect;
-        ocr_task_ptr->region_of_appeared = res.rect;
+        m_status->set_region(ocr_task_ptr->name, m_result_rect);
         //m_ocr_cache.insert(m_ocr_cache.end(), ocr_result.begin(), ocr_result.end());
         Log.trace("ProcessTaskImageAnalyzer::ocr_analyze | found", res.to_string());
     }
@@ -125,3 +128,13 @@ void asst::ProcessTaskImageAnalyzer::set_image(const cv::Mat image)
     AbstractImageAnalyzer::set_image(image);
     reset();
 }
+
+void asst::ProcessTaskImageAnalyzer::set_tasks(std::vector<std::string> tasks_name)
+{
+    m_tasks_name = std::move(tasks_name);
+}
+
+void asst::ProcessTaskImageAnalyzer::set_status(std::shared_ptr<RuntimeStatus> status) noexcept
+{
+    m_status = status;
+}
diff --git a/src/MeoAssistant/ProcessTaskImageAnalyzer.h b/src/MeoAssistant/ProcessTaskImageAnalyzer.h
index 48a244cb35..61b6c17a6c 100644
--- a/src/MeoAssistant/ProcessTaskImageAnalyzer.h
+++ b/src/MeoAssistant/ProcessTaskImageAnalyzer.h
@@ -11,6 +11,7 @@ namespace asst
 {
     class OcrImageAnalyzer;
     class MatchImageAnalyzer;
+    class RuntimeStatus;
 
     class ProcessTaskImageAnalyzer final : public AbstractImageAnalyzer
     {
@@ -23,10 +24,9 @@ namespace asst
         virtual bool analyze() override;
         void set_image(const cv::Mat image);
 
-        void set_tasks(std::vector<std::string> tasks_name)
-        {
-            m_tasks_name = std::move(tasks_name);
-        }
+        void set_tasks(std::vector<std::string> tasks_name);
+        void set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
+
         std::shared_ptr<TaskInfo> get_result() const noexcept
         {
             return m_result;
@@ -56,7 +56,8 @@ namespace asst
         std::unique_ptr<OcrImageAnalyzer> m_ocr_analyzer;
         std::unique_ptr<MatchImageAnalyzer> m_match_analyzer;
         std::vector<std::string> m_tasks_name;
-        std::shared_ptr<TaskInfo> m_result;
+        std::shared_ptr<TaskInfo> m_result = nullptr;
+        std::shared_ptr<RuntimeStatus> m_status = nullptr;
         Rect m_result_rect;
         //std::vector<TextRect> m_ocr_cache;
     };
diff --git a/src/MeoAssistant/RuntimeStatus.cpp b/src/MeoAssistant/RuntimeStatus.cpp
index 384cc345c1..27a3ce972e 100644
--- a/src/MeoAssistant/RuntimeStatus.cpp
+++ b/src/MeoAssistant/RuntimeStatus.cpp
@@ -1 +1,43 @@
 #include "RuntimeStatus.h"
+
+int64_t asst::RuntimeStatus::get_data(const std::string& key) const noexcept
+{
+    if (auto iter = m_data.find(key);
+        iter != m_data.cend()) {
+        return iter->second;
+    }
+    else {
+        return 0;
+    }
+}
+
+bool asst::RuntimeStatus::contains_data(const std::string& key) const noexcept
+{
+    return m_data.find(key) != m_data.cend();
+}
+
+void asst::RuntimeStatus::set_data(std::string key, int64_t value)
+{
+    m_data[std::move(key)] = value;
+}
+
+void asst::RuntimeStatus::clear_data() noexcept
+{
+    m_data.clear();
+}
+
+asst::Rect asst::RuntimeStatus::get_region(const std::string& key) const noexcept
+{
+    if (auto iter = m_region_of_appeared.find(key);
+        iter != m_region_of_appeared.cend()) {
+        return iter->second;
+    }
+    else {
+        return Rect();
+    }
+}
+
+void asst::RuntimeStatus::set_region(std::string key, Rect rect)
+{
+    m_region_of_appeared[std::move(key)] = std::move(rect);
+}
diff --git a/src/MeoAssistant/RuntimeStatus.h b/src/MeoAssistant/RuntimeStatus.h
index af5d55f697..00aad74cf8 100644
--- a/src/MeoAssistant/RuntimeStatus.h
+++ b/src/MeoAssistant/RuntimeStatus.h
@@ -4,54 +4,32 @@
 #include <unordered_map>
 #include <string>
 
+#include "AsstDef.h"
+
 namespace asst
 {
     class RuntimeStatus
     {
     public:
+        RuntimeStatus() = default;
         RuntimeStatus(const RuntimeStatus& rhs) = delete;
         RuntimeStatus(RuntimeStatus&& rhs) noexcept = delete;
         ~RuntimeStatus() = default;
 
-        static RuntimeStatus& get_instance()
-        {
-            static RuntimeStatus unique_instance;
-            return unique_instance;
-        }
+        int64_t get_data(const std::string& key) const noexcept;
+        bool contains_data(const std::string& key) const noexcept;
+        void set_data(std::string key, int64_t value);
+        void clear_data() noexcept;
 
-        int64_t get(const std::string& key) const noexcept
-        {
-            if (auto iter = m_data.find(key);
-                iter != m_data.cend()) {
-                return iter->second;
-            }
-            else {
-                return 0;
-            }
-        }
-        bool contains(const std::string& key) const noexcept
-        {
-            return m_data.find(key) != m_data.cend();
-        }
-
-        void set(std::string key, int64_t value)
-        {
-            m_data[std::move(key)] = value;
-        }
-
-        void clear() noexcept
-        {
-            m_data.clear();
-        }
+        Rect get_region(const std::string& key) const noexcept;
+        void set_region(std::string key, Rect rect);
 
         RuntimeStatus& operator=(const RuntimeStatus& rhs) = delete;
         RuntimeStatus& operator=(RuntimeStatus&& rhs) noexcept = delete;
 
     private:
-        RuntimeStatus() = default;
 
         std::unordered_map<std::string, int64_t> m_data;
+        std::unordered_map<std::string, Rect> m_region_of_appeared;
     };
-
-    static auto& Status = RuntimeStatus::get_instance();
 }
diff --git a/src/MeoAssistant/StageDropsTaskPlugin.cpp b/src/MeoAssistant/StageDropsTaskPlugin.cpp
index 83de49d00f..69ba92f13c 100644
--- a/src/MeoAssistant/StageDropsTaskPlugin.cpp
+++ b/src/MeoAssistant/StageDropsTaskPlugin.cpp
@@ -21,8 +21,8 @@ bool asst::StageDropsTaskPlugin::verify(AsstMsg msg, const json::value& details)
     }
 
     if (details.at("details").at("task").as_string() == "EndOfAction") {
-        int64_t pre_start_time = Status.get("LastStartButton2");
-        int64_t pre_recognize_time = Status.get("LastRecognizeDrops");
+        int64_t pre_start_time = m_status->get_data("LastStartButton2");
+        int64_t pre_recognize_time = m_status->get_data("LastRecognizeDrops");
         if (pre_start_time + RecognizationTimeOffset == pre_recognize_time) {
             Log.info("Recognization time too close, pass", pre_start_time, pre_recognize_time);
             return false;
@@ -59,7 +59,7 @@ bool asst::StageDropsTaskPlugin::_run()
     if (opt.penguin_report.enable) {
         auto upload_future = std::async(
             std::launch::async,
-            std::bind(&StageDropsTaskPlugin::upload_to_penguin, this));
+            &StageDropsTaskPlugin::upload_to_penguin, this);
         m_upload_pending.emplace_back(std::move(upload_future));
     }
 
@@ -79,7 +79,7 @@ bool asst::StageDropsTaskPlugin::recognize_drops()
     Log.trace("Results of penguin recognition:\n", res);
     m_cur_drops = json::parse(res).value();
 
-    Status.set("LastRecognizeDrops", Status.get("LastStartButton2") + RecognizationTimeOffset);
+    m_status->set_data("LastRecognizeDrops", m_status->get_data("LastStartButton2") + RecognizationTimeOffset);
 
     return true;
 }
@@ -125,7 +125,7 @@ void asst::StageDropsTaskPlugin::set_startbutton_delay()
     LogTraceFunction;
 
     if (!m_startbutton_delay_setted) {
-        int64_t pre_start_time = Status.get("LastStartButton2");
+        int64_t pre_start_time = m_status->get_data("LastStartButton2");
 
         if (pre_start_time > 0) {
             int64_t duration = time(nullptr) - pre_start_time;
diff --git a/src/MeoAssistant/TaskData.cpp b/src/MeoAssistant/TaskData.cpp
index 9f4018076d..9a4852416d 100644
--- a/src/MeoAssistant/TaskData.cpp
+++ b/src/MeoAssistant/TaskData.cpp
@@ -30,13 +30,6 @@ std::shared_ptr<asst::TaskInfo> asst::TaskData::get(std::string name)
     return m_all_tasks_info[std::move(name)];
 }
 
-void asst::TaskData::clear_cache() noexcept
-{
-    for (auto&& [name, ptr] : m_all_tasks_info) {
-        ptr->region_of_appeared = Rect();
-    }
-}
-
 bool asst::TaskData::parse(const json::value& json)
 {
     LogTraceFunction;
diff --git a/src/MeoAssistant/TaskData.h b/src/MeoAssistant/TaskData.h
index e28b34293a..a92dd5dfdc 100644
--- a/src/MeoAssistant/TaskData.h
+++ b/src/MeoAssistant/TaskData.h
@@ -27,7 +27,6 @@ namespace asst
         const std::shared_ptr<TaskInfo> get(const std::string& name) const noexcept;
         const std::unordered_set<std::string>& get_templ_required() const noexcept;
         std::shared_ptr<TaskInfo> get(std::string name);
-        void clear_cache() noexcept;
 
     protected:
         TaskData() = default;