diff --git a/include/AsstCaller.h b/include/AsstCaller.h
index 1630c7bf38..b60172ff40 100644
--- a/include/AsstCaller.h
+++ b/include/AsstCaller.h
@@ -28,8 +28,6 @@ extern "C" {
     bool ASSTAPI AsstStart(AsstHandle handle);
     bool ASSTAPI AsstStop(AsstHandle handle);
 
-    bool ASSTAPI AsstSetParam(AsstHandle handle, const char* param_id, const char* param_value);
-
     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);
 
diff --git a/src/MeoAssistant/AbstractImageAnalyzer.cpp b/src/MeoAssistant/AbstractImageAnalyzer.cpp
index 22b39bb820..a43a86762d 100644
--- a/src/MeoAssistant/AbstractImageAnalyzer.cpp
+++ b/src/MeoAssistant/AbstractImageAnalyzer.cpp
@@ -11,15 +11,6 @@ asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image)
 #endif
 {}
 
-asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
-    : m_image(image), m_roi(empty_rect_to_full(Rect(), image)),
-    m_task_data(task_data)
-#ifdef ASST_DEBUG
-    ,
-    m_image_draw(image.clone())
-#endif
-{}
-
 asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image, const Rect& roi)
     : m_image(image),
     m_roi(empty_rect_to_full(roi, image))
@@ -50,11 +41,6 @@ void asst::AbstractImageAnalyzer::set_roi(const Rect& roi) noexcept
     m_roi = empty_rect_to_full(roi, m_image);
 }
 
-void asst::AbstractImageAnalyzer::set_task_data(std::shared_ptr<TaskData> task_data)
-{
-    m_task_data = task_data;
-}
-
 asst::Rect asst::AbstractImageAnalyzer::empty_rect_to_full(const Rect& rect, const cv::Mat image) noexcept
 {
     return rect.empty() ? Rect(0, 0, image.cols, image.rows) : rect;
diff --git a/src/MeoAssistant/AbstractImageAnalyzer.h b/src/MeoAssistant/AbstractImageAnalyzer.h
index 2a6401f956..131be58a0a 100644
--- a/src/MeoAssistant/AbstractImageAnalyzer.h
+++ b/src/MeoAssistant/AbstractImageAnalyzer.h
@@ -12,7 +12,6 @@ namespace asst
     public:
         AbstractImageAnalyzer() = default;
         AbstractImageAnalyzer(const cv::Mat image);
-        AbstractImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
         AbstractImageAnalyzer(const cv::Mat image, const Rect& roi);
         AbstractImageAnalyzer(const AbstractImageAnalyzer&) = delete;
         AbstractImageAnalyzer(AbstractImageAnalyzer&&) = delete;
@@ -33,7 +32,6 @@ namespace asst
 
         cv::Mat m_image;
         Rect m_roi;
-        std::shared_ptr<TaskData> m_task_data = nullptr;
 
 #ifdef ASST_DEBUG
         cv::Mat m_image_draw;
diff --git a/src/MeoAssistant/AbstractTask.cpp b/src/MeoAssistant/AbstractTask.cpp
index 65137e682c..ac888ab11b 100644
--- a/src/MeoAssistant/AbstractTask.cpp
+++ b/src/MeoAssistant/AbstractTask.cpp
@@ -70,12 +70,6 @@ AbstractTask& asst::AbstractTask::set_status(std::shared_ptr<RuntimeStatus> stat
     return *this;
 }
 
-AbstractTask& asst::AbstractTask::set_task_data(std::shared_ptr<TaskData> task_data) noexcept
-{
-    m_task_data = task_data;
-    return *this;
-}
-
 void asst::AbstractTask::clear_plugin() noexcept
 {
     m_plugins.clear();
@@ -162,7 +156,6 @@ void asst::AbstractTask::callback(AsstMsg msg, const json::value& detail)
         plugin->set_exit_flag(m_exit_flag);
         plugin->set_ctrler(m_ctrler);
         plugin->set_status(m_status);
-        plugin->set_task_data(m_task_data);
         plugin->set_task_ptr(this);
 
         if (!plugin->verify(msg, detail)) {
@@ -181,7 +174,7 @@ void asst::AbstractTask::callback(AsstMsg msg, const json::value& detail)
 void asst::AbstractTask::click_return_button()
 {
     LogTraceFunction;
-    const auto return_task_ptr = m_task_data->get("Return");
+    const auto return_task_ptr = Task.get("Return");
 
     Rect ReturnButtonRect = return_task_ptr->specific_rect;
 
diff --git a/src/MeoAssistant/AbstractTask.h b/src/MeoAssistant/AbstractTask.h
index d388249b9e..9969dbc79f 100644
--- a/src/MeoAssistant/AbstractTask.h
+++ b/src/MeoAssistant/AbstractTask.h
@@ -35,7 +35,6 @@ namespace asst
         virtual AbstractTask& set_retry_times(int times) noexcept;
         virtual AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
         virtual AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
-        virtual AbstractTask& set_task_data(std::shared_ptr<TaskData> task_data) noexcept;
 
         template<typename PluginType>
         std::shared_ptr<PluginType> regiseter_plugin()
@@ -75,6 +74,5 @@ namespace asst
         std::set<TaskPluginPtr> m_plugins;
         std::shared_ptr<Controller> m_ctrler = nullptr;
         std::shared_ptr<RuntimeStatus> m_status = nullptr;
-        std::shared_ptr<TaskData> m_task_data = nullptr;
     };
 }
diff --git a/src/MeoAssistant/Assistant.cpp b/src/MeoAssistant/Assistant.cpp
index bc81d8df2a..4f7ffbabcc 100644
--- a/src/MeoAssistant/Assistant.cpp
+++ b/src/MeoAssistant/Assistant.cpp
@@ -27,7 +27,6 @@ Assistant::Assistant(AsstApiCallback callback, void* callback_arg)
     LogTraceFunction;
 
     m_status = std::make_shared<RuntimeStatus>();
-    m_task_data = std::make_shared<TaskData>();
     m_ctrler = std::make_shared<Controller>(task_callback, (void*)this);
 
     m_working_thread = std::thread(&Assistant::working_proc, this);
@@ -148,35 +147,6 @@ bool asst::Assistant::ctrler_click(int x, int y, bool block)
     return true;
 }
 
-bool asst::Assistant::set_param(const std::string& param_id, const std::string& param_value)
-{
-    Log.info(__FUNCTION__, param_id, param_value);
-
-    using SetParamFuncType = std::function<bool(const json::value&)>;
-
-    static const std::unordered_map<std::string, SetParamFuncType> ParamsMapping = {
-        {AsstParamIdPenguinId, std::bind(&Assistant::set_penguid_id, this, std::placeholders::_1)},
-        {AsstParamIdOcrText, std::bind(&Assistant::set_ocr_text, this, std::placeholders::_1)},
-    };
-
-    if (const auto iter = ParamsMapping.find(param_id);
-        iter != ParamsMapping.cend()) {
-        const auto& json_opt = json::parse(param_value);
-        if (!json_opt) {
-            Log.error("Param Value Parsing Failed", param_value);
-            return false;
-        }
-        const auto& root = json_opt.value();
-
-        std::unique_lock<std::mutex> lock(m_mutex);
-        return iter->second(root);
-    }
-    else {
-        Log.error("Invaild Param Id", param_id);
-        return false;
-    }
-}
-
 bool asst::Assistant::start(bool block)
 {
     LogTraceFunction;
@@ -233,8 +203,7 @@ void Assistant::working_proc()
 
             task_ptr->set_exit_flag(&m_thread_idle)
                 .set_ctrler(m_ctrler)
-                .set_status(m_status)
-                .set_task_data(m_task_data);
+                .set_status(m_status);
 
             bool ret = task_ptr->run();
 
@@ -321,42 +290,3 @@ void Assistant::clear_cache()
     m_status->clear_data();
     //Task.clear_cache();
 }
-
-bool asst::Assistant::set_penguid_id(const json::value& root)
-{
-    if (!(root.is_object() && root.contains("id") && root.at("id").is_string())) {
-        Log.error("Json Field error");
-        return false;
-    }
-    auto& param = Resrc.cfg().get_options().penguin_report.extra_param;
-    std::string id = root.at("id").as_string();
-    if (id.empty()) {
-        param.clear();
-    }
-    else {
-        param = "-H \"authorization: PenguinID " + id + "\"";
-    }
-    return true;
-}
-
-bool asst::Assistant::set_ocr_text(const json::value& root)
-{
-    bool ret = true;
-    for (auto&& [key, text_arr] : root.as_object()) {
-        if (!text_arr.is_array()) {
-            Log.error("Json Field error");
-            return false;
-        }
-        std::vector<std::string> text_vec;
-        for (auto&& text : text_arr.as_array()) {
-            if (!text.is_string()) {
-                Log.error("Json Field error");
-                return false;
-            }
-            text_vec.emplace_back(text.as_string());
-        }
-        ret &= m_task_data->set_ocr_text(key, std::move(text_vec));
-    }
-
-    return ret;
-}
diff --git a/src/MeoAssistant/Assistant.h b/src/MeoAssistant/Assistant.h
index 58d5b23036..0bb520cb26 100644
--- a/src/MeoAssistant/Assistant.h
+++ b/src/MeoAssistant/Assistant.h
@@ -3,15 +3,11 @@
 #include <condition_variable>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <queue>
 #include <thread>
-#include <unordered_map>
 
-#include "AbstractTask.h"
 #include "AsstTypes.h"
 #include "AsstMsg.h"
-#include "AsstInfrastDef.h"
 
 typedef unsigned char uchar;
 
@@ -23,10 +19,8 @@ namespace cv
 namespace asst
 {
     class Controller;
-    class Identify;
-    class Controller;
-    class TaskData;
     class PackageTask;
+    class RuntimeStatus;
 
     class Assistant
     {
@@ -50,31 +44,19 @@ namespace asst
         std::vector<uchar> get_image() const;
         bool ctrler_click(int x, int y, bool block = true);
 
-        bool set_param(const std::string& param_id, const std::string& param_value);
-
-        static constexpr int ProcessTaskRetryTimesDefault = AbstractTask::RetryTimesDefault;
-        static constexpr int OpenRecruitTaskRetryTimesDefault = 5;
-        static constexpr int AutoRecruitTaskRetryTimesDefault = 5;
-
     private:
         void working_proc();
         void msg_proc();
         static void task_callback(AsstMsg msg, const json::value& detail, void* custom_arg);
 
-        bool append_process_task(const std::string& task_name, std::string task_chain = std::string(), int retry_times = ProcessTaskRetryTimesDefault);
         void append_callback(AsstMsg msg, json::value detail);
         void clear_cache();
 
-        /* set params */
-        bool set_penguid_id(const json::value& root);
-        bool set_ocr_text(const json::value& root);
-
         bool m_inited = false;
         std::string m_uuid;
 
         std::shared_ptr<Controller> m_ctrler = nullptr;
         std::shared_ptr<RuntimeStatus> m_status = nullptr;
-        std::shared_ptr<TaskData> m_task_data = nullptr;
 
         bool m_thread_exit = false;
         std::list<std::pair<int, std::shared_ptr<PackageTask>>> m_tasks_list;
diff --git a/src/MeoAssistant/AsstCaller.cpp b/src/MeoAssistant/AsstCaller.cpp
index d0b49b13b0..6e66d1a4a1 100644
--- a/src/MeoAssistant/AsstCaller.cpp
+++ b/src/MeoAssistant/AsstCaller.cpp
@@ -97,15 +97,6 @@ bool AsstStop(AsstHandle handle)
     return handle->stop();
 }
 
-bool AsstSetParam(AsstHandle handle, const char* param_id, const char* param_value)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->set_param(param_id, param_value);
-}
-
 TaskId AsstAppendTask(AsstHandle handle, const char* type, const char* params)
 {
     if (!inited || handle == nullptr) {
@@ -115,14 +106,6 @@ TaskId AsstAppendTask(AsstHandle handle, const char* type, const char* params)
     return handle->append_task(type, params);
 }
 
-bool AsstSetTaskParams(AsstHandle handle, TaskId id, const char* params)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-    return handle->set_task_params(id, params);
-}
-
 unsigned long long AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size)
 {
     if (!inited || handle == nullptr || buff == nullptr) {
diff --git a/src/MeoAssistant/AutoRecruitTask.cpp b/src/MeoAssistant/AutoRecruitTask.cpp
index 86345653da..979b83e747 100644
--- a/src/MeoAssistant/AutoRecruitTask.cpp
+++ b/src/MeoAssistant/AutoRecruitTask.cpp
@@ -80,8 +80,7 @@ bool asst::AutoRecruitTask::_run()
 bool asst::AutoRecruitTask::analyze_start_buttons()
 {
     OcrImageAnalyzer start_analyzer;
-    start_analyzer.set_task_info(m_task_data->get("StartRecruit"));
-    start_analyzer.set_task_data(m_task_data);
+    start_analyzer.set_task_info(Task.get("StartRecruit"));
 
     auto image = m_ctrler->get_image();
     start_analyzer.set_image(image);
diff --git a/src/MeoAssistant/BattleImageAnalyzer.cpp b/src/MeoAssistant/BattleImageAnalyzer.cpp
index e8cc075abb..83d30ae495 100644
--- a/src/MeoAssistant/BattleImageAnalyzer.cpp
+++ b/src/MeoAssistant/BattleImageAnalyzer.cpp
@@ -8,10 +8,6 @@
 #include "Logger.hpp"
 #include "TaskData.h"
 
-asst::BattleImageAnalyzer::BattleImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
-    : AbstractImageAnalyzer(image, task_data)
-{}
-
 bool asst::BattleImageAnalyzer::analyze()
 {
     // 生命值和家门，只要识别到了任一个，就可以说明当前是在战斗场景
@@ -50,17 +46,16 @@ bool asst::BattleImageAnalyzer::opers_analyze()
     LogTraceFunction;
 
     MultiMatchImageAnalyzer flags_analyzer(m_image);
-    flags_analyzer.set_task_info(m_task_data->get("BattleOpersFlag"));
-    flags_analyzer.set_task_data(m_task_data);
+    flags_analyzer.set_task_info(Task.get("BattleOpersFlag"));
     if (!flags_analyzer.analyze()) {
         return false;
     }
     flags_analyzer.sort_result();
 
-    const auto click_move = m_task_data->get("BattleOperClickRange")->rect_move;
-    const auto role_move = m_task_data->get("BattleOperRoleRange")->rect_move;
-    const auto cost_move = m_task_data->get("BattleOperCostRange")->rect_move;
-    const auto avlb_move = m_task_data->get("BattleOperAvailable")->rect_move;
+    const auto click_move = Task.get("BattleOperClickRange")->rect_move;
+    const auto role_move = Task.get("BattleOperRoleRange")->rect_move;
+    const auto cost_move = Task.get("BattleOperCostRange")->rect_move;
+    const auto avlb_move = Task.get("BattleOperAvailable")->rect_move;
 
     for (const MatchRect& flag_mrect : flags_analyzer.get_result()) {
         Oper oper;
@@ -105,12 +100,11 @@ asst::BattleImageAnalyzer::Role asst::BattleImageAnalyzer::oper_role_analyze(con
     };
 
     MatchImageAnalyzer role_analyzer(m_image);
-    role_analyzer.set_task_data(m_task_data);
 
     Role result = Role::Unknown;
     double max_score = 0;
     for (auto&& [role, role_name] : RolesName) {
-        role_analyzer.set_task_info(m_task_data->get("BattleOperRole" + role_name));
+        role_analyzer.set_task_info(Task.get("BattleOperRole" + role_name));
         role_analyzer.set_roi(roi);
         if (!role_analyzer.analyze()) {
             continue;
@@ -148,22 +142,21 @@ int asst::BattleImageAnalyzer::oper_cost_analyze(const Rect& roi)
     static HashImageAnalyzer hash_analyzer;
     if (!inited) {
         auto [h_l, h_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleOperCostChannelH"))->mask_range;
+            Task.get("BattleOperCostChannelH"))->mask_range;
         auto [s_l, s_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleOperCostChannelS"))->mask_range;
+            Task.get("BattleOperCostChannelS"))->mask_range;
         auto [v_l, v_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleOperCostChannelV"))->mask_range;
+            Task.get("BattleOperCostChannelV"))->mask_range;
         range_lower = cv::Scalar(h_l, s_l, v_l);
         range_upper = cv::Scalar(h_u, s_u, v_u);
         std::unordered_map<std::string, std::string> num_hashs;
         for (auto&& num : NumName) {
             auto hashs_vec = std::dynamic_pointer_cast<HashTaskInfo>(
-                m_task_data->get("BattleOperCost" + num))->hashs;
+                Task.get("BattleOperCost" + num))->hashs;
             for (size_t i = 0; i != hashs_vec.size(); ++i) {
                 num_hashs.emplace(num + "_" + std::to_string(i), hashs_vec.at(i));
             }
         }
-        hash_analyzer.set_task_data(m_task_data);
         hash_analyzer.set_hash_templates(std::move(num_hashs));
         hash_analyzer.set_need_bound(true);
         hash_analyzer.set_need_split(true);
@@ -202,7 +195,7 @@ bool asst::BattleImageAnalyzer::oper_available_analyze(const Rect& roi)
     Log.trace("oper available, mean", avg[2]);
 
     static int thres = static_cast<int>(std::dynamic_pointer_cast<MatchTaskInfo>(
-        m_task_data->get("BattleOperAvailable"))->special_threshold);
+        Task.get("BattleOperAvailable"))->special_threshold);
     if (avg[2] < thres) {
         return false;
     }
@@ -253,11 +246,10 @@ bool asst::BattleImageAnalyzer::home_analyze()
 
 bool asst::BattleImageAnalyzer::skill_analyze()
 {
-    const auto skill_task_ptr = m_task_data->get("BattleSkillReady");
+    const auto skill_task_ptr = Task.get("BattleSkillReady");
     const Rect& rect_move = skill_task_ptr->rect_move;
 
     MultiMatchImageAnalyzer mm_analyzer(m_image);
-    mm_analyzer.set_task_data(m_task_data);
     mm_analyzer.set_task_info(skill_task_ptr);
     if (!mm_analyzer.analyze()) {
         return false;
@@ -271,13 +263,12 @@ bool asst::BattleImageAnalyzer::skill_analyze()
 bool asst::BattleImageAnalyzer::hp_analyze()
 {
     // 识别 HP 的那个蓝白色图标
-    auto flag_task_ptr = m_task_data->get("BattleHpFlag");
+    auto flag_task_ptr = Task.get("BattleHpFlag");
     MatchImageAnalyzer flag_analyzer(m_image);
-    flag_analyzer.set_task_data(m_task_data);
     flag_analyzer.set_task_info(flag_task_ptr);
     if (!flag_analyzer.analyze()) {
         // 漏怪的时候，那个图标会变成红色的，所以多识别一次
-        flag_task_ptr = m_task_data->get("BattleHpFlag2");
+        flag_task_ptr = Task.get("BattleHpFlag2");
         flag_analyzer.set_task_info(flag_task_ptr);
         if (!flag_analyzer.analyze()) {
             return false;
@@ -294,22 +285,21 @@ bool asst::BattleImageAnalyzer::hp_analyze()
     static HashImageAnalyzer hash_analyzer;
     if (!inited) {
         auto [h_l, h_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleHpChannelH"))->mask_range;
+            Task.get("BattleHpChannelH"))->mask_range;
         auto [s_l, s_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleHpChannelS"))->mask_range;
+            Task.get("BattleHpChannelS"))->mask_range;
         auto [v_l, v_u] = std::dynamic_pointer_cast<HashTaskInfo>(
-            m_task_data->get("BattleHpChannelV"))->mask_range;
+            Task.get("BattleHpChannelV"))->mask_range;
         range_lower = cv::Scalar(h_l, s_l, v_l);
         range_upper = cv::Scalar(h_u, s_u, v_u);
         std::unordered_map<std::string, std::string> num_hashs;
         for (auto&& num : NumName) {
             const auto& hashs_vec = std::dynamic_pointer_cast<HashTaskInfo>(
-                m_task_data->get("BattleHp" + num))->hashs;
+                Task.get("BattleHp" + num))->hashs;
             for (size_t i = 0; i != hashs_vec.size(); ++i) {
                 num_hashs.emplace(num + "_" + std::to_string(i), hashs_vec.at(i));
             }
         }
-        hash_analyzer.set_task_data(m_task_data);
         hash_analyzer.set_hash_templates(std::move(num_hashs));
         hash_analyzer.set_need_bound(true);
         hash_analyzer.set_need_split(true);
diff --git a/src/MeoAssistant/BattleImageAnalyzer.h b/src/MeoAssistant/BattleImageAnalyzer.h
index 870b9631d9..c669792f2a 100644
--- a/src/MeoAssistant/BattleImageAnalyzer.h
+++ b/src/MeoAssistant/BattleImageAnalyzer.h
@@ -27,7 +27,7 @@ namespace asst
             Rect rect;
         };
     public:
-        BattleImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
+        using AbstractImageAnalyzer::AbstractImageAnalyzer;
         virtual ~BattleImageAnalyzer() = default;
 
         virtual bool analyze() override;
diff --git a/src/MeoAssistant/CreditShopImageAnalyzer.cpp b/src/MeoAssistant/CreditShopImageAnalyzer.cpp
index 41dfd74909..4286a0f5da 100644
--- a/src/MeoAssistant/CreditShopImageAnalyzer.cpp
+++ b/src/MeoAssistant/CreditShopImageAnalyzer.cpp
@@ -7,10 +7,6 @@
 
 #include "AsstUtils.hpp"
 
-asst::CreditShopImageAnalyzer::CreditShopImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
-    : AbstractImageAnalyzer(image, task_data)
-{}
-
 void asst::CreditShopImageAnalyzer::set_black_list(std::vector<std::string> black_list)
 {
     m_shopping_list = std::move(black_list);
@@ -35,10 +31,9 @@ bool asst::CreditShopImageAnalyzer::analyze()
 bool asst::CreditShopImageAnalyzer::commoditys_analyze()
 {
     // 识别信用点的图标
-    const auto commodity_task_ptr = m_task_data->get("CreditShop-Commoditys");
+    const auto commodity_task_ptr = Task.get("CreditShop-Commoditys");
     MultiMatchImageAnalyzer mm_annlyzer(m_image);
     mm_annlyzer.set_task_info(commodity_task_ptr);
-    mm_annlyzer.set_task_data(m_task_data);
 
     if (!mm_annlyzer.analyze()) {
         return false;
@@ -65,7 +60,7 @@ bool asst::CreditShopImageAnalyzer::commoditys_analyze()
 bool asst::CreditShopImageAnalyzer::whether_to_buy_analyze()
 {
     const auto not_to_buy_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(
-        m_task_data->get("CreditShop-NotToBuy"));
+        Task.get("CreditShop-NotToBuy"));
 
     for (const Rect& commodity : m_commoditys) {
         // 商品名的区域
@@ -74,7 +69,6 @@ bool asst::CreditShopImageAnalyzer::whether_to_buy_analyze()
         name_roi.y += commodity.y;
 
         OcrImageAnalyzer ocr_analyzer(m_image, name_roi);
-        ocr_analyzer.set_task_data(m_task_data);
         ocr_analyzer.set_required(m_shopping_list);
         if (ocr_analyzer.analyze()) {
             // 黑名单模式，有识别结果说明这个商品不买，直接跳过
@@ -99,8 +93,7 @@ bool asst::CreditShopImageAnalyzer::sold_out_analyze()
 {
     // 识别是否售罄
     MatchImageAnalyzer sold_out_analyzer(m_image);
-    sold_out_analyzer.set_task_info(m_task_data->get("CreditShop-SoldOut"));
-    sold_out_analyzer.set_task_data(m_task_data);
+    sold_out_analyzer.set_task_info(Task.get("CreditShop-SoldOut"));
 
     for (const Rect& commodity : m_need_to_buy) {
         sold_out_analyzer.set_roi(commodity);
diff --git a/src/MeoAssistant/CreditShopImageAnalyzer.h b/src/MeoAssistant/CreditShopImageAnalyzer.h
index 2b5ae2653b..93e6f78f44 100644
--- a/src/MeoAssistant/CreditShopImageAnalyzer.h
+++ b/src/MeoAssistant/CreditShopImageAnalyzer.h
@@ -6,7 +6,7 @@ namespace asst
     class CreditShopImageAnalyzer final : public AbstractImageAnalyzer
     {
     public:
-        CreditShopImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
+        using AbstractImageAnalyzer::AbstractImageAnalyzer;
         virtual ~CreditShopImageAnalyzer() = default;
 
         virtual bool analyze() override;
diff --git a/src/MeoAssistant/CreditShoppingTask.cpp b/src/MeoAssistant/CreditShoppingTask.cpp
index 10fccbd73c..da6cf6e8af 100644
--- a/src/MeoAssistant/CreditShoppingTask.cpp
+++ b/src/MeoAssistant/CreditShoppingTask.cpp
@@ -27,8 +27,7 @@ bool asst::CreditShoppingTask::_run()
 {
     const cv::Mat image = m_ctrler->get_image();
 
-    CreditShopImageAnalyzer shop_analyzer(image, m_task_data);
-    shop_analyzer.set_task_data(m_task_data);
+    CreditShopImageAnalyzer shop_analyzer(image);
     if (!shop_analyzer.analyze()) {
         return false;
     }
@@ -48,11 +47,11 @@ bool asst::CreditShoppingTask::_run()
         // “购买商品”按钮
         static Rect buy_it_rect;
         if (buy_it_rect.empty()) {
-            const auto buy_it_task_ptr = m_task_data->get("CreditShop-BuyIt");
+            const auto buy_it_task_ptr = Task.get("CreditShop-BuyIt");
 
             const cv::Mat buy_image = m_ctrler->get_image();
             MatchImageAnalyzer buy_it_analyzer(buy_image);
-            buy_it_analyzer.set_task_data(m_task_data);
+
             buy_it_analyzer.set_task_info(buy_it_task_ptr);
             if (!buy_it_analyzer.analyze()) {
                 // 没识别到“购买商品”按钮，不应该出现这种情况，TODO 报错
@@ -73,8 +72,8 @@ bool asst::CreditShoppingTask::_run()
         const cv::Mat prompt_image = m_ctrler->get_image();
 
         OcrImageAnalyzer prompt_analyzer(prompt_image);
-        prompt_analyzer.set_task_data(m_task_data);
-        prompt_analyzer.set_task_info(m_task_data->get("CreditShop-NoMoney"));
+
+        prompt_analyzer.set_task_info(Task.get("CreditShop-NoMoney"));
         if (prompt_analyzer.analyze()) {
             click_return_button();
             return true;
diff --git a/src/MeoAssistant/InfrastAbstractTask.cpp b/src/MeoAssistant/InfrastAbstractTask.cpp
index 3e982768cb..28bc0c8efb 100644
--- a/src/MeoAssistant/InfrastAbstractTask.cpp
+++ b/src/MeoAssistant/InfrastAbstractTask.cpp
@@ -78,7 +78,7 @@ bool asst::InfrastAbstractTask::enter_facility(int index)
 
     InfrastFacilityImageAnalyzer analyzer(image);
     analyzer.set_to_be_analyzed({ facility_name() });
-    analyzer.set_task_data(m_task_data);
+
     if (!analyzer.analyze()) {
         Log.trace("result is empty");
         return false;
@@ -94,7 +94,7 @@ bool asst::InfrastAbstractTask::enter_facility(int index)
 
     m_ctrler->click(rect);
 
-    const auto enter_task_ptr = m_task_data->get("InfrastEnterFacility");
+    const auto enter_task_ptr = Task.get("InfrastEnterFacility");
     sleep(enter_task_ptr->rear_delay);
 
     return true;
@@ -111,9 +111,9 @@ bool asst::InfrastAbstractTask::enter_oper_list_page()
 void asst::InfrastAbstractTask::async_swipe_of_operlist(bool reverse)
 {
     LogTraceFunction;
-    static Rect begin_rect = m_task_data->get("InfrastOperListSwipeBegin")->specific_rect;
-    static Rect end_rect = m_task_data->get("InfrastOperListSwipeEnd")->specific_rect;
-    static int duration = m_task_data->get("InfrastOperListSwipeBegin")->pre_delay;
+    static Rect begin_rect = Task.get("InfrastOperListSwipeBegin")->specific_rect;
+    static Rect end_rect = Task.get("InfrastOperListSwipeEnd")->specific_rect;
+    static int duration = Task.get("InfrastOperListSwipeBegin")->pre_delay;
 
     if (!reverse) {
         m_last_swipe_id = m_ctrler->swipe(begin_rect, end_rect, duration, false, 0, true);
@@ -126,7 +126,7 @@ void asst::InfrastAbstractTask::async_swipe_of_operlist(bool reverse)
 void asst::InfrastAbstractTask::await_swipe()
 {
     LogTraceFunction;
-    static int extra_delay = m_task_data->get("InfrastOperListSwipeBegin")->rear_delay;
+    static int extra_delay = Task.get("InfrastOperListSwipeBegin")->rear_delay;
 
     m_ctrler->wait(m_last_swipe_id);
     sleep(extra_delay);
@@ -165,11 +165,11 @@ void asst::InfrastAbstractTask::swipe_of_operlist(bool reverse)
 void asst::InfrastAbstractTask::swipe_to_the_left_of_operlist(int loop_times)
 {
     LogTraceFunction;
-    static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
-    static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
-    static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
-    static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
-    static int cfg_loop_times = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->max_times;
+    static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
+    static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
+    static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
+    static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
+    static int cfg_loop_times = Task.get("InfrastOperListSwipeToTheLeftBegin")->max_times;
 
     for (int i = 0; i != cfg_loop_times * loop_times; ++i) {
         if (need_exit()) {
@@ -183,10 +183,10 @@ void asst::InfrastAbstractTask::swipe_to_the_left_of_operlist(int loop_times)
 void asst::InfrastAbstractTask::swipe_to_the_left_of_main_ui()
 {
     LogTraceFunction;
-    static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
-    static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
-    static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
-    static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
+    static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
+    static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
+    static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
+    static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
 
     m_ctrler->swipe(end_rect, begin_rect, duration, true, extra_delay, false);
 }
@@ -194,10 +194,10 @@ void asst::InfrastAbstractTask::swipe_to_the_left_of_main_ui()
 void asst::InfrastAbstractTask::swipe_to_the_right_of_main_ui()
 {
     LogTraceFunction;
-    static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
-    static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
-    static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
-    static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
+    static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
+    static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
+    static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
+    static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
 
     m_ctrler->swipe(begin_rect, end_rect, duration, true, extra_delay, false);
 }
diff --git a/src/MeoAssistant/InfrastClueImageAnalyzer.cpp b/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
index c70399aea0..cc1a938976 100644
--- a/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
@@ -16,8 +16,8 @@ bool asst::InfrastClueImageAnalyzer::analyze()
 bool asst::InfrastClueImageAnalyzer::clue_detect()
 {
     MultiMatchImageAnalyzer clue_analyzer(m_image);
-    clue_analyzer.set_task_info(m_task_data->get("InfrastClue"));
-    clue_analyzer.set_task_data(m_task_data);
+    clue_analyzer.set_task_info(Task.get("InfrastClue"));
+
     clue_analyzer.set_roi(m_roi); // 该任务以外部设置的roi为准
     if (!clue_analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp b/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
index c39f278f53..717948099a 100644
--- a/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
@@ -10,9 +10,9 @@ bool asst::InfrastClueVacancyImageAnalyzer::analyze()
     const static std::string clue_vacancy = "InfrastClueVacancy";
 
     MatchImageAnalyzer analyzer(m_image);
-    analyzer.set_task_data(m_task_data);
+
     for (const std::string& suffix : m_to_be_analyzed) {
-        analyzer.set_task_info(m_task_data->get(clue_vacancy + suffix));
+        analyzer.set_task_info(Task.get(clue_vacancy + suffix));
         if (!analyzer.analyze()) {
             Log.trace("no", clue_vacancy, suffix);
             continue;
diff --git a/src/MeoAssistant/InfrastDormTask.cpp b/src/MeoAssistant/InfrastDormTask.cpp
index 2a41341889..75c1c0317e 100644
--- a/src/MeoAssistant/InfrastDormTask.cpp
+++ b/src/MeoAssistant/InfrastDormTask.cpp
@@ -44,7 +44,7 @@ bool asst::InfrastDormTask::opers_choose()
         }
         const auto image = m_ctrler->get_image();
         InfrastOperImageAnalyzer oper_analyzer(image);
-        oper_analyzer.set_task_data(m_task_data);
+
         const int without_skill = InfrastOperImageAnalyzer::All ^ InfrastOperImageAnalyzer::Skill;
         oper_analyzer.set_to_be_calced(without_skill);
         if (!oper_analyzer.analyze()) {
diff --git a/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp b/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
index 766cebb269..c255bc0d4a 100644
--- a/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
@@ -22,10 +22,10 @@ bool asst::InfrastFacilityImageAnalyzer::analyze()
     const static std::vector<std::string> task_name_suffix = { "", "Mini" };
 
     MultiMatchImageAnalyzer mm_analyzer(m_image);
-    mm_analyzer.set_task_data(m_task_data);
+
 
     auto task_analyze = [&](const std::string& task_name) -> bool {
-        mm_analyzer.set_task_info(m_task_data->get(task_name));
+        mm_analyzer.set_task_info(Task.get(task_name));
         return mm_analyzer.analyze();
     };
 
diff --git a/src/MeoAssistant/InfrastInfoTask.cpp b/src/MeoAssistant/InfrastInfoTask.cpp
index 80d6f48768..3543ab940f 100644
--- a/src/MeoAssistant/InfrastInfoTask.cpp
+++ b/src/MeoAssistant/InfrastInfoTask.cpp
@@ -12,7 +12,7 @@ bool asst::InfrastInfoTask::_run()
     const auto image = m_ctrler->get_image();
 
     InfrastFacilityImageAnalyzer analyzer(image);
-    analyzer.set_task_data(m_task_data);
+
     analyzer.set_to_be_analyzed({ "Mfg", "Trade", "Power", "Dorm" });
     if (!analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/InfrastOperImageAnalyzer.cpp b/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
index dc962ba405..6b43449fb5 100644
--- a/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
@@ -81,17 +81,17 @@ void asst::InfrastOperImageAnalyzer::oper_detect()
 {
     LogTraceFunction;
 
-    const Rect upper_roi = m_task_data->get("InfrastSkillsUpper")->roi;
-    const Rect lower_roi = m_task_data->get("InfrastSkillsLower")->roi;
+    const Rect upper_roi = Task.get("InfrastSkillsUpper")->roi;
+    const Rect lower_roi = Task.get("InfrastSkillsLower")->roi;
     const std::vector<Rect> all_roi = { upper_roi, lower_roi };
 
-    const Rect skill_rect_move = m_task_data->get("InfrastSkills")->rect_move;
-    const Rect hash_rect_move = m_task_data->get("InfrastOperNameHash")->rect_move;
-    const Rect prg_rect_move = m_task_data->get("InfrastOperMoodProgressBar")->roi;
+    const Rect skill_rect_move = Task.get("InfrastSkills")->rect_move;
+    const Rect hash_rect_move = Task.get("InfrastOperNameHash")->rect_move;
+    const Rect prg_rect_move = Task.get("InfrastOperMoodProgressBar")->roi;
     const std::vector<Rect> all_rect_move = { skill_rect_move, hash_rect_move, prg_rect_move };
 
     InfrastSmileyImageAnalyzer smiley_analyzer(m_image);
-    smiley_analyzer.set_task_data(m_task_data);
+
 
     for (auto&& roi : all_roi) {
         smiley_analyzer.set_roi(roi);
@@ -132,7 +132,7 @@ void asst::InfrastOperImageAnalyzer::mood_analyze()
     LogTraceFunction;
 
     const auto prg_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
-        m_task_data->get("InfrastOperMoodProgressBar"));
+        Task.get("InfrastOperMoodProgressBar"));
     uint8_t prg_lower_limit = static_cast<uint8_t>(prg_task_ptr->templ_threshold);
     int prg_diff_thres = static_cast<int>(prg_task_ptr->special_threshold);
     Rect rect_move = prg_task_ptr->rect_move;
@@ -208,10 +208,10 @@ void asst::InfrastOperImageAnalyzer::face_hash_analyze()
 {
     LogTraceFunction;
 
-    const Rect hash_rect_move = m_task_data->get("InfrastOperFaceHash")->rect_move;
+    const Rect hash_rect_move = Task.get("InfrastOperFaceHash")->rect_move;
 
     HashImageAnalyzer hash_analyzer(m_image);
-    hash_analyzer.set_task_data(m_task_data);
+
     for (auto&& oper : m_result) {
         Rect roi = oper.smiley.rect.move(hash_rect_move);
         hash_analyzer.set_roi(roi);
@@ -225,10 +225,10 @@ void asst::InfrastOperImageAnalyzer::name_hash_analyze()
     LogTraceFunction;
 
     const auto task_ptr = std::dynamic_pointer_cast<HashTaskInfo>(
-        m_task_data->get("InfrastOperNameHash"));
+        Task.get("InfrastOperNameHash"));
 
     HashImageAnalyzer hash_analyzer(m_image);
-    hash_analyzer.set_task_data(m_task_data);
+
     hash_analyzer.set_mask_range(task_ptr->mask_range);
     hash_analyzer.set_need_bound(true);
     for (auto&& oper : m_result) {
@@ -244,11 +244,11 @@ void asst::InfrastOperImageAnalyzer::skill_analyze()
     LogTraceFunction;
 
     const auto task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
-        m_task_data->get("InfrastSkills"));
+        Task.get("InfrastSkills"));
     const auto bright_thres = task_ptr->special_threshold;
 
     MatchImageAnalyzer skill_analyzer(m_image);
-    skill_analyzer.set_task_data(m_task_data);
+
     skill_analyzer.set_mask_range(task_ptr->mask_range);
     skill_analyzer.set_threshold(task_ptr->templ_threshold);
 
@@ -370,7 +370,7 @@ void asst::InfrastOperImageAnalyzer::selected_analyze()
     LogTraceFunction;
 
     const auto selected_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
-        m_task_data->get("InfrastOperSelected"));
+        Task.get("InfrastOperSelected"));
     Rect rect_move = selected_task_ptr->rect_move;
 
     for (auto&& oper : m_result) {
@@ -406,11 +406,11 @@ void asst::InfrastOperImageAnalyzer::doing_analyze()
 {
     LogTraceFunction;
 
-    const auto working_task_ptr = m_task_data->get("InfrastOperOnShift");
+    const auto working_task_ptr = Task.get("InfrastOperOnShift");
     Rect rect_move = working_task_ptr->rect_move;
 
     MatchImageAnalyzer working_analyzer(m_image);
-    working_analyzer.set_task_data(m_task_data);
+
     working_analyzer.set_task_info(working_task_ptr);
 
     for (auto&& oper : m_result) {
diff --git a/src/MeoAssistant/InfrastProductionTask.cpp b/src/MeoAssistant/InfrastProductionTask.cpp
index b78eeb42e7..efa276733d 100644
--- a/src/MeoAssistant/InfrastProductionTask.cpp
+++ b/src/MeoAssistant/InfrastProductionTask.cpp
@@ -40,14 +40,14 @@ bool asst::InfrastProductionTask::shift_facility_list()
     if (!facility_list_detect() || need_exit()) {
         return false;
     }
-    const auto tab_task_ptr = m_task_data->get("InfrastFacilityListTab" + facility_name());
+    const auto tab_task_ptr = Task.get("InfrastFacilityListTab" + facility_name());
     MatchImageAnalyzer add_analyzer;
-    add_analyzer.set_task_data(m_task_data);
-    const auto add_task_ptr = m_task_data->get("InfrastAddOperator" + facility_name() + m_work_mode_name);
+
+    const auto add_task_ptr = Task.get("InfrastAddOperator" + facility_name() + m_work_mode_name);
     add_analyzer.set_task_info(add_task_ptr);
     MultiMatchImageAnalyzer locked_analyzer;
-    locked_analyzer.set_task_data(m_task_data);
-    locked_analyzer.set_task_info(m_task_data->get("InfrastOperLocked" + facility_name()));
+
+    locked_analyzer.set_task_info(Task.get("InfrastOperLocked" + facility_name()));
 
     for (; m_cur_facility_index < m_facility_list_tabs.size(); ++m_cur_facility_index) {
         Rect tab = m_facility_list_tabs.at(m_cur_facility_index);
@@ -80,12 +80,12 @@ bool asst::InfrastProductionTask::shift_facility_list()
 
         /* 识别当前正在造什么 */
         MatchImageAnalyzer product_analyzer(image);
-        product_analyzer.set_task_data(m_task_data);
+
         auto& all_products = Resrc.infrast().get_facility_info(facility_name()).products;
         std::string cur_product = all_products.at(0);
         double max_score = 0;
         for (const std::string& product : all_products) {
-            product_analyzer.set_task_info(m_task_data->get("InfrastFlag" + product));
+            product_analyzer.set_task_info(Task.get("InfrastFlag" + product));
             if (product_analyzer.analyze()) {
                 double score = product_analyzer.get_result().score;
                 if (score > max_score) {
@@ -182,7 +182,7 @@ size_t asst::InfrastProductionTask::opers_detect()
     const auto image = m_ctrler->get_image();
 
     InfrastOperImageAnalyzer oper_analyzer(image);
-    oper_analyzer.set_task_data(m_task_data);
+
     oper_analyzer.set_facility(facility_name());
 
     if (!oper_analyzer.analyze()) {
@@ -192,7 +192,7 @@ size_t asst::InfrastProductionTask::opers_detect()
     max_num_of_opers_per_page = (std::max)(max_num_of_opers_per_page, cur_all_opers.size());
 
     const int face_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
-        m_task_data->get("InfrastOperFaceHash"))->dist_threshold;
+        Task.get("InfrastOperFaceHash"))->dist_threshold;
     int cur_available_num = static_cast<int>(cur_all_opers.size());
     for (const auto& cur_oper : cur_all_opers) {
         if (cur_oper.skills.empty()) {
@@ -296,7 +296,7 @@ bool asst::InfrastProductionTask::optimal_calc()
     }
 
     const int name_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
-        m_task_data->get("InfrastOperNameHash"))->dist_threshold;
+        Task.get("InfrastOperNameHash"))->dist_threshold;
 
     // 遍历所有组合，找到效率最高的
     auto& all_group = Resrc.infrast().get_skills_group(facility_name());
@@ -456,9 +456,9 @@ bool asst::InfrastProductionTask::opers_choose()
     int cur_max_num_of_opers = facility_info.max_num_of_opers - m_cur_num_of_lokced_opers;
 
     const int name_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
-        m_task_data->get("InfrastOperNameHash"))->dist_threshold;
+        Task.get("InfrastOperNameHash"))->dist_threshold;
     const int face_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
-        m_task_data->get("InfrastOperFaceHash"))->dist_threshold;
+        Task.get("InfrastOperFaceHash"))->dist_threshold;
     while (true) {
         if (need_exit()) {
             return false;
@@ -466,7 +466,7 @@ bool asst::InfrastProductionTask::opers_choose()
         const auto image = m_ctrler->get_image();
 
         InfrastOperImageAnalyzer oper_analyzer(image);
-        oper_analyzer.set_task_data(m_task_data);
+
         oper_analyzer.set_facility(facility_name());
 
         if (!oper_analyzer.analyze()) {
@@ -624,8 +624,8 @@ bool asst::InfrastProductionTask::facility_list_detect()
 
     const auto image = m_ctrler->get_image();
     MultiMatchImageAnalyzer mm_analyzer(image);
-    mm_analyzer.set_task_data(m_task_data);
-    mm_analyzer.set_task_info(m_task_data->get("InfrastFacilityListTab" + facility_name()));
+
+    mm_analyzer.set_task_info(Task.get("InfrastFacilityListTab" + facility_name()));
 
     if (!mm_analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/InfrastReceptionTask.cpp b/src/MeoAssistant/InfrastReceptionTask.cpp
index 6fe55443ec..78b4ffbbc1 100644
--- a/src/MeoAssistant/InfrastReceptionTask.cpp
+++ b/src/MeoAssistant/InfrastReceptionTask.cpp
@@ -65,7 +65,7 @@ bool asst::InfrastReceptionTask::use_clue()
 
     // 所有的空位分析一次，看看还缺哪些线索
     InfrastClueVacancyImageAnalyzer vacancy_analyzer(image);
-    vacancy_analyzer.set_task_data(m_task_data);
+
     vacancy_analyzer.set_to_be_analyzed(clue_suffix);
     if (!vacancy_analyzer.analyze()) {
     }
@@ -102,7 +102,7 @@ bool asst::InfrastReceptionTask::proc_clue_vacancy()
         }
         // 先识别线索的空位
         InfrastClueVacancyImageAnalyzer vacancy_analyzer(image);
-        vacancy_analyzer.set_task_data(m_task_data);
+
         vacancy_analyzer.set_to_be_analyzed({ clue });
         if (!vacancy_analyzer.analyze()) {
             continue;
@@ -110,14 +110,14 @@ bool asst::InfrastReceptionTask::proc_clue_vacancy()
         // 点开线索的空位
         Rect vacancy = vacancy_analyzer.get_vacancy().cbegin()->second;
         m_ctrler->click(vacancy);
-        int delay = m_task_data->get(clue_vacancy + clue)->rear_delay;
+        int delay = Task.get(clue_vacancy + clue)->rear_delay;
         sleep(delay);
 
         // 识别右边列表中的线索，然后用最底下的那个（一般都是剩余时间最短的）
         //swipe_to_the_bottom_of_clue_list_on_the_right();
         image = m_ctrler->get_image();
         InfrastClueImageAnalyzer clue_analyzer(image);
-        clue_analyzer.set_task_data(m_task_data);
+
         if (!clue_analyzer.analyze()) {
             continue;
         }
@@ -145,9 +145,9 @@ bool asst::InfrastReceptionTask::shift()
     LogTraceFunction;
     const auto image = m_ctrler->get_image();
     MatchImageAnalyzer add_analyzer(image);
-    add_analyzer.set_task_data(m_task_data);
 
-    const auto raw_task_ptr = m_task_data->get("InfrastAddOperator" + facility_name() + m_work_mode_name);
+
+    const auto raw_task_ptr = Task.get("InfrastAddOperator" + facility_name() + m_work_mode_name);
     switch (raw_task_ptr->algorithm) {
     case AlgorithmType::JustReturn:
         if (raw_task_ptr->action == ProcessTaskAction::ClickRect) {
diff --git a/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp b/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
index 75213618c4..655017fada 100644
--- a/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
@@ -15,11 +15,11 @@ bool asst::InfrastSmileyImageAnalyzer::analyze()
     m_result.clear();
 
     MultiMatchImageAnalyzer mm_analyzer(m_image);
-    mm_analyzer.set_task_data(m_task_data);
+
 
     decltype(m_result) temp_result;
     for (const auto& [type, task_name] : smiley_map) {
-        mm_analyzer.set_task_info(m_task_data->get(task_name));
+        mm_analyzer.set_task_info(Task.get(task_name));
         mm_analyzer.set_roi(m_roi);
         if (!mm_analyzer.analyze()) {
             continue;
diff --git a/src/MeoAssistant/MeoAssistant.vcxproj.filters b/src/MeoAssistant/MeoAssistant.vcxproj.filters
index d8378c5149..88bb1de48e 100644
--- a/src/MeoAssistant/MeoAssistant.vcxproj.filters
+++ b/src/MeoAssistant/MeoAssistant.vcxproj.filters
@@ -283,7 +283,7 @@
       <Filter>头文件\Task</Filter>
     </ClInclude>
     <ClInclude Include="MallTask.h">
-      <Filter>头文件</Filter>
+      <Filter>头文件\Task</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
@@ -462,7 +462,7 @@
       <Filter>源文件\Task</Filter>
     </ClCompile>
     <ClCompile Include="MallTask.cpp">
-      <Filter>源文件</Filter>
+      <Filter>源文件\Task</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
diff --git a/src/MeoAssistant/PackageTask.cpp b/src/MeoAssistant/PackageTask.cpp
index 80253cc148..8a5b6a60be 100644
--- a/src/MeoAssistant/PackageTask.cpp
+++ b/src/MeoAssistant/PackageTask.cpp
@@ -18,8 +18,7 @@ bool asst::PackageTask::run()
 
         task_ptr->set_exit_flag(m_exit_flag)
             .set_ctrler(m_ctrler)
-            .set_status(m_status)
-            .set_task_data(m_task_data);
+            .set_status(m_status);
 
         if (!task_ptr->run()) {
             return false;
@@ -65,12 +64,3 @@ asst::AbstractTask& asst::PackageTask::set_status(std::shared_ptr<RuntimeStatus>
     }
     return *this;
 }
-
-asst::AbstractTask& asst::PackageTask::set_task_data(std::shared_ptr<TaskData> task_data) noexcept
-{
-    AbstractTask::set_task_data(task_data);
-    for (auto&& sub : m_subtasks) {
-        sub->set_task_data(task_data);
-    }
-    return *this;
-}
diff --git a/src/MeoAssistant/PackageTask.h b/src/MeoAssistant/PackageTask.h
index e5f3b93e02..c9c21fe832 100644
--- a/src/MeoAssistant/PackageTask.h
+++ b/src/MeoAssistant/PackageTask.h
@@ -26,7 +26,6 @@ namespace asst
         virtual AbstractTask& set_retry_times(int times) noexcept;
         virtual AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
         virtual AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
-        virtual AbstractTask& set_task_data(std::shared_ptr<TaskData> task_data) noexcept;
 
     protected:
         virtual bool _run() override { return true; }
diff --git a/src/MeoAssistant/ProcessTask.cpp b/src/MeoAssistant/ProcessTask.cpp
index eef38baf82..656b83e169 100644
--- a/src/MeoAssistant/ProcessTask.cpp
+++ b/src/MeoAssistant/ProcessTask.cpp
@@ -88,16 +88,16 @@ bool ProcessTask::_run()
         std::shared_ptr<TaskInfo> cur_task_ptr = nullptr;
 
         // 如果第一个任务是JustReturn的，那就没必要再截图并计算了
-        if (auto front_task_ptr = m_task_data->get(m_cur_tasks_name.front());
+        if (auto front_task_ptr = Task.get(m_cur_tasks_name.front());
             front_task_ptr->algorithm == AlgorithmType::JustReturn) {
             cur_task_ptr = front_task_ptr;
         }
         else {
             const auto image = m_ctrler->get_image();
             ProcessTaskImageAnalyzer analyzer(image, m_cur_tasks_name);
-            analyzer.set_task_data(m_task_data);
+
             analyzer.set_status(m_status);
-            analyzer.set_task_data(m_task_data);
+
             if (!analyzer.analyze()) {
                 return false;
             }
diff --git a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
index a5e798a308..6dc5954526 100644
--- a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
+++ b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
@@ -108,7 +108,7 @@ bool asst::ProcessTaskImageAnalyzer::analyze()
     m_result_rect = Rect();
 
     for (const std::string& task_name : m_tasks_name) {
-        auto task_ptr = m_task_data->get(task_name);
+        auto task_ptr = Task.get(task_name);
 
         switch (task_ptr->algorithm) {
         case AlgorithmType::JustReturn:
diff --git a/src/MeoAssistant/RecruitImageAnalyzer.cpp b/src/MeoAssistant/RecruitImageAnalyzer.cpp
index c7be7a5f35..48db41d4c6 100644
--- a/src/MeoAssistant/RecruitImageAnalyzer.cpp
+++ b/src/MeoAssistant/RecruitImageAnalyzer.cpp
@@ -23,7 +23,7 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
     static OcrImageAnalyzer tags_analyzer;
     if (!analyzer_inited) {
         const auto tags_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(
-            m_task_data->get("RecruitTags"));
+            Task.get("RecruitTags"));
         tags_analyzer.set_roi(tags_task_ptr->roi);
         auto& all_tags_set = Resrc.recruit().get_all_tags();
         std::vector<std::string> all_tags_vec;
@@ -33,7 +33,7 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
         if (ssr_iter != all_tags_vec.end()) {
             std::swap(*ssr_iter, all_tags_vec.front());
         }
-        tags_analyzer.set_task_data(m_task_data);
+
         tags_analyzer.set_required(std::move(all_tags_vec));
         tags_analyzer.set_replace(tags_task_ptr->replace_map);
         analyzer_inited = true;
@@ -53,11 +53,11 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
 
 bool asst::RecruitImageAnalyzer::time_analyze()
 {
-    const auto time_task_ptr = m_task_data->get("RecruitTime");
+    const auto time_task_ptr = Task.get("RecruitTime");
 
     MatchImageAnalyzer time_analyzer(m_image);
     time_analyzer.set_task_info(time_task_ptr);
-    time_analyzer.set_task_data(m_task_data);
+
 
     if (time_analyzer.analyze()) {
         Rect rect = time_analyzer.get_result().rect;
@@ -77,8 +77,8 @@ bool asst::RecruitImageAnalyzer::time_analyze()
 bool asst::RecruitImageAnalyzer::confirm_analyze()
 {
     MatchImageAnalyzer confirm_analyzer(m_image);
-    confirm_analyzer.set_task_info(m_task_data->get("RecruitConfirm"));
-    confirm_analyzer.set_task_data(m_task_data);
+    confirm_analyzer.set_task_info(Task.get("RecruitConfirm"));
+
 
     if (confirm_analyzer.analyze()) {
         m_confirm_rect = confirm_analyzer.get_result().rect;
@@ -91,8 +91,8 @@ bool asst::RecruitImageAnalyzer::confirm_analyze()
 bool asst::RecruitImageAnalyzer::refresh_analyze()
 {
     MatchImageAnalyzer refresh_analyzer(m_image);
-    refresh_analyzer.set_task_data(m_task_data);
-    refresh_analyzer.set_task_info(m_task_data->get("RecruitRefresh"));
+
+    refresh_analyzer.set_task_info(Task.get("RecruitRefresh"));
 
     if (refresh_analyzer.analyze()) {
         m_refresh_rect = refresh_analyzer.get_result().rect;
diff --git a/src/MeoAssistant/RecruitTask.cpp b/src/MeoAssistant/RecruitTask.cpp
index 30a6bbfe72..fcaddfce9e 100644
--- a/src/MeoAssistant/RecruitTask.cpp
+++ b/src/MeoAssistant/RecruitTask.cpp
@@ -18,7 +18,7 @@ bool RecruitTask::_run()
 
     const cv::Mat image = m_ctrler->get_image();
     RecruitImageAnalyzer analyzer(image);
-    analyzer.set_task_data(m_task_data);
+
 
     if (!analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/Resource.cpp b/src/MeoAssistant/Resource.cpp
index 39e79259b1..dad3515574 100644
--- a/src/MeoAssistant/Resource.cpp
+++ b/src/MeoAssistant/Resource.cpp
@@ -28,8 +28,8 @@ bool asst::Resource::load(const std::string& dir)
         m_last_error = std::string(GeneralCfgFilename) + ": " + m_general_cfg_unique_ins.get_last_error();
         return false;
     }
-    if (!StaticTaskData::get_instance().load(dir + TaskDataFilename)) {
-        m_last_error = std::string(TaskDataFilename) + ": " + StaticTaskData::get_instance().get_last_error();
+    if (!TaskData::get_instance().load(dir + TaskDataFilename)) {
+        m_last_error = std::string(TaskDataFilename) + ": " + TaskData::get_instance().get_last_error();
         return false;
     }
 
@@ -50,7 +50,7 @@ bool asst::Resource::load(const std::string& dir)
 
     /* 加载模板图片资源 */
     // task所需要的模板资源
-    m_templ_resource_unique_ins.append_load_required(StaticTaskData::get_instance().get_templ_required());
+    m_templ_resource_unique_ins.append_load_required(TaskData::get_instance().get_templ_required());
     // 基建所需要的模板资源
     m_templ_resource_unique_ins.append_load_required(m_infrast_cfg_unique_ins.get_templ_required());
 
diff --git a/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp b/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
index b55d6faec0..35926dec2b 100644
--- a/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
+++ b/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
@@ -59,14 +59,14 @@ bool asst::RoguelikeBattleTaskPlugin::get_stage_info()
     bool calced = false;
 
     if (m_stage_name.empty()) {
-        const auto stage_name_task_ptr = m_task_data->get("BattleStageName");
+        const auto stage_name_task_ptr = Task.get("BattleStageName");
         sleep(stage_name_task_ptr->pre_delay);
 
         constexpr int StageNameRetryTimes = 50;
         for (int i = 0; i != StageNameRetryTimes; ++i) {
             cv::Mat image = m_ctrler->get_image();
             OcrImageAnalyzer name_analyzer(image);
-            name_analyzer.set_task_data(m_task_data);
+
             name_analyzer.set_task_info(stage_name_task_ptr);
             if (!name_analyzer.analyze()) {
                 continue;
@@ -134,8 +134,8 @@ bool asst::RoguelikeBattleTaskPlugin::auto_battle()
 
     using Oper = asst::BattleImageAnalyzer::Oper;
 
-    BattleImageAnalyzer battle_analyzer(m_ctrler->get_image(), m_task_data);
-    battle_analyzer.set_task_data(m_task_data);
+    BattleImageAnalyzer battle_analyzer(m_ctrler->get_image());
+
     if (!battle_analyzer.analyze()) {
         return false;
     }
@@ -173,8 +173,8 @@ bool asst::RoguelikeBattleTaskPlugin::auto_battle()
         Role::Tank,
         Role::Drone
     };
-    const auto use_oper_task_ptr = m_task_data->get("BattleUseOper");
-    const auto swipe_oper_task_ptr = m_task_data->get("BattleSwipeOper");
+    const auto use_oper_task_ptr = Task.get("BattleUseOper");
+    const auto swipe_oper_task_ptr = Task.get("BattleSwipeOper");
 
     // 点击当前最合适的干员
     Oper opt_oper;
@@ -295,7 +295,7 @@ void asst::RoguelikeBattleTaskPlugin::clear()
 //asst::Rect asst::RoguelikeBattleTaskPlugin::get_placed_by_cv()
 //{
 //    BattlePerspectiveImageAnalyzer placed_analyzer(m_ctrler->get_image());
-//    placed_analyzer.set_task_data(m_task_data);
+
 //    placed_analyzer.set_src_homes(m_home_cache);
 //    if (!placed_analyzer.analyze()) {
 //        return Rect();
diff --git a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
index 1fc59664f1..2680d1beeb 100644
--- a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
+++ b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
@@ -5,15 +5,11 @@
 #include "TaskData.h"
 #include "Logger.hpp"
 
-asst::RoguelikeFormationImageAnalyzer::RoguelikeFormationImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
-    : AbstractImageAnalyzer(image, task_data)
-{}
-
 bool asst::RoguelikeFormationImageAnalyzer::analyze()
 {
     MultiMatchImageAnalyzer opers_analyzer(m_image);
-    opers_analyzer.set_task_info(m_task_data->get("Roguelike1FormationOper"));
-    opers_analyzer.set_task_data(m_task_data);
+    opers_analyzer.set_task_info(Task.get("Roguelike1FormationOper"));
+
     if (!opers_analyzer.analyze()) {
         return false;
     }
@@ -51,7 +47,7 @@ bool asst::RoguelikeFormationImageAnalyzer::selected_analyze(const Rect& roi)
     cv::Mat hsv;
 
     const auto selected_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
-        m_task_data->get("Roguelike1FormationOperSelected"));
+        Task.get("Roguelike1FormationOperSelected"));
     cv::cvtColor(img_roi, hsv, cv::COLOR_BGR2HSV);
     std::vector<cv::Mat> channels;
     cv::split(hsv, channels);
diff --git a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.h b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.h
index fd551a96e4..011acc1760 100644
--- a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.h
+++ b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.h
@@ -13,7 +13,7 @@ namespace asst
             // TODO
         };
     public:
-        RoguelikeFormationImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
+        using AbstractImageAnalyzer::AbstractImageAnalyzer;
         virtual ~RoguelikeFormationImageAnalyzer() = default;
 
         virtual bool analyze() override;
diff --git a/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp b/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
index 8e08a2ab32..6554a49154 100644
--- a/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
+++ b/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
@@ -22,8 +22,8 @@ bool asst::RoguelikeFormationTaskPlugin::verify(AsstMsg msg, const json::value&
 
 bool asst::RoguelikeFormationTaskPlugin::_run()
 {
-    RoguelikeFormationImageAnalyzer formation_analyzer(m_ctrler->get_image(), m_task_data);
-    formation_analyzer.set_task_data(m_task_data);
+    RoguelikeFormationImageAnalyzer formation_analyzer(m_ctrler->get_image());
+
     if (!formation_analyzer.analyze()) {
         return false;
     }
diff --git a/src/MeoAssistant/StageDropsTaskPlugin.cpp b/src/MeoAssistant/StageDropsTaskPlugin.cpp
index df27147717..05eb7b0e2d 100644
--- a/src/MeoAssistant/StageDropsTaskPlugin.cpp
+++ b/src/MeoAssistant/StageDropsTaskPlugin.cpp
@@ -72,7 +72,7 @@ bool asst::StageDropsTaskPlugin::recognize_drops()
 {
     LogTraceFunction;
 
-    sleep(m_task_data->get("PRTS")->rear_delay);
+    sleep(Task.get("PRTS")->rear_delay);
     if (need_exit()) {
         return false;
     }
@@ -134,7 +134,7 @@ void asst::StageDropsTaskPlugin::set_startbutton_delay()
 
         if (pre_start_time > 0) {
             int64_t duration = time(nullptr) - pre_start_time;
-            int elapsed = m_task_data->get("EndOfAction")->pre_delay + m_task_data->get("PRTS")->rear_delay;
+            int elapsed = Task.get("EndOfAction")->pre_delay + Task.get("PRTS")->rear_delay;
             int64_t delay = duration * 1000 - elapsed;
             m_cast_ptr->set_rear_delay("StartButton2", static_cast<int>(delay));
         }
diff --git a/src/MeoAssistant/TaskData.cpp b/src/MeoAssistant/TaskData.cpp
index b6864ac492..ad6e8eb84c 100644
--- a/src/MeoAssistant/TaskData.cpp
+++ b/src/MeoAssistant/TaskData.cpp
@@ -9,7 +9,7 @@
 #include "TemplResource.h"
 #include "Logger.hpp"
 
-const std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::string& name) const noexcept
+const std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name) const noexcept
 {
     if (auto iter = m_all_tasks_info.find(name);
         iter != m_all_tasks_info.cend()) {
@@ -20,17 +20,17 @@ const std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::strin
     }
 }
 
-const std::unordered_set<std::string>& asst::StaticTaskData::get_templ_required() const noexcept
+const std::unordered_set<std::string>& asst::TaskData::get_templ_required() const noexcept
 {
     return m_templ_required;
 }
 
-std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::string& name)
+std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name)
 {
     return m_all_tasks_info[name];
 }
 
-bool asst::StaticTaskData::parse(const json::value& json)
+bool asst::TaskData::parse(const json::value& json)
 {
     LogTraceFunction;
 
@@ -214,47 +214,3 @@ bool asst::StaticTaskData::parse(const json::value& json)
 #endif
     return true;
 }
-
-const std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name) const noexcept
-{
-    if (auto iter = m_specal_tasks_info.find(name);
-        iter != m_specal_tasks_info.cend()) {
-        return iter->second;
-    }
-    else {
-        return StaticTaskData::get_instance().get(name);
-    }
-}
-
-std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name)
-{
-    if (auto iter = m_specal_tasks_info.find(name);
-        iter != m_specal_tasks_info.cend()) {
-        return iter->second;
-    }
-    else {
-        return StaticTaskData::get_instance().get(name);
-    }
-}
-
-bool asst::TaskData::set_ocr_text(const std::string& key, std::vector<std::string> text)
-{
-    if (auto iter = m_specal_tasks_info.find(key);
-        iter != m_specal_tasks_info.end()) {
-        std::dynamic_pointer_cast<OcrTaskInfo>(iter->second)->text = std::move(text);
-        return true;
-    }
-    else {
-        auto raw_task_ptr = StaticTaskData::get_instance().get(key);
-        if (!raw_task_ptr) {
-            Log.error("Task", key, "Not Exists");
-            return false;
-        }
-        // 拷贝一份
-        OcrTaskInfo info = *std::dynamic_pointer_cast<OcrTaskInfo>(raw_task_ptr);
-        info.text = std::move(text);
-        auto specail_ptr = std::make_shared<OcrTaskInfo>(std::move(info));
-        m_specal_tasks_info.emplace(key, specail_ptr);
-        return true;
-    }
-}
diff --git a/src/MeoAssistant/TaskData.h b/src/MeoAssistant/TaskData.h
index bfb1d74b5a..adbe5d0259 100644
--- a/src/MeoAssistant/TaskData.h
+++ b/src/MeoAssistant/TaskData.h
@@ -10,17 +10,17 @@ namespace asst
 {
     struct TaskInfo;
 
-    class StaticTaskData : public AbstractConfiger
+    class TaskData : public AbstractConfiger
     {
     public:
-        StaticTaskData(const StaticTaskData&) = delete;
-        StaticTaskData(StaticTaskData&&) = delete;
+        TaskData(const TaskData&) = delete;
+        TaskData(TaskData&&) = delete;
 
-        virtual ~StaticTaskData() = default;
+        virtual ~TaskData() = default;
 
-        static StaticTaskData& get_instance()
+        static TaskData& get_instance()
         {
-            static StaticTaskData unique_instance;
+            static TaskData unique_instance;
             return unique_instance;
         }
         const std::unordered_set<std::string>& get_templ_required() const noexcept;
@@ -29,7 +29,7 @@ namespace asst
         std::shared_ptr<TaskInfo> get(const std::string& name);
 
     protected:
-        StaticTaskData() = default;
+        TaskData() = default;
 
         virtual bool parse(const json::value& json);
 
@@ -37,18 +37,5 @@ namespace asst
         std::unordered_set<std::string> m_templ_required;
     };
 
-    class TaskData
-    {
-    public:
-        TaskData() = default;
-        ~TaskData() noexcept = default;
-
-        const std::shared_ptr<TaskInfo> get(const std::string& name) const noexcept;
-        std::shared_ptr<TaskInfo> get(const std::string& name);
-
-        bool set_ocr_text(const std::string& key, std::vector<std::string> text);
-
-    private:
-        std::unordered_map<std::string, std::shared_ptr<TaskInfo>> m_specal_tasks_info;
-    };
+    static auto& Task = TaskData::get_instance();
 }