The task and thread families are plain ksys::

They link in the same block as the plain-ksys:: Message family.
getItemValue and applyScreenFade sit in engine UI TUs, hence ksys::ui.

(AI assisted using Claude Fable 5.1 and Claude Opus 5.5)

65 files changed, 218 insertions, 230 deletions

diff --git a/src/Game/Actor/Query/queryHasPorchArrow.cpp b/src/Game/Actor/Query/queryHasPorchArrow.cpp
index 7867b388..e0d53e32 100644
--- a/src/Game/Actor/Query/queryHasPorchArrow.cpp
+++ b/src/Game/Actor/Query/queryHasPorchArrow.cpp
@@ -1,6 +1,6 @@
 #include "Game/Actor/Query/queryHasPorchArrow.h"
 #include <evfl/Query.h>
-#include "Game/UI/uiUtils.h"
+#include "KingSystem/System/UIGlue.h"
 
 namespace uking::query {
 
@@ -9,9 +9,9 @@ HasPorchArrow::HasPorchArrow(const InitArg& arg) : ksys::act::ai::Query(arg) {}
 HasPorchArrow::~HasPorchArrow() = default;
 
 int HasPorchArrow::doQuery() {
-    s32 arrow_cnt = ui::getItemValue("NormalArrow") + ui::getItemValue("FireArrow") +
-                    ui::getItemValue("IceArrow") + ui::getItemValue("ElectricArrow") +
-                    ui::getItemValue("BombArrow_A") + ui::getItemValue("AncientArrow");
+    s32 arrow_cnt = ksys::ui::getItemValue("NormalArrow") + ksys::ui::getItemValue("FireArrow") +
+                    ksys::ui::getItemValue("IceArrow") + ksys::ui::getItemValue("ElectricArrow") +
+                    ksys::ui::getItemValue("BombArrow_A") + ksys::ui::getItemValue("AncientArrow");
     return arrow_cnt < *mCheckNum;
 }
 
diff --git a/src/Game/Actor/Query/queryHasPorchItem.cpp b/src/Game/Actor/Query/queryHasPorchItem.cpp
index f8ac4e74..e16d0ac3 100644
--- a/src/Game/Actor/Query/queryHasPorchItem.cpp
+++ b/src/Game/Actor/Query/queryHasPorchItem.cpp
@@ -1,6 +1,6 @@
 #include "Game/Actor/Query/queryHasPorchItem.h"
 #include <evfl/Query.h>
-#include "Game/UI/uiUtils.h"
+#include "KingSystem/System/UIGlue.h"
 
 namespace uking::query {
 
@@ -9,7 +9,7 @@ HasPorchItem::HasPorchItem(const InitArg& arg) : ksys::act::ai::Query(arg) {}
 HasPorchItem::~HasPorchItem() = default;
 
 int HasPorchItem::doQuery() {
-    return ui::getItemValue(mPorchItemName) >= *mCount;
+    return ksys::ui::getItemValue(mPorchItemName) >= *mCount;
 }
 
 void HasPorchItem::loadParams(const evfl::QueryArg& arg) {
diff --git a/src/Game/UI/uiFadeProgress.cpp b/src/Game/UI/uiFadeProgress.cpp
index 87ded166..f448b862 100644
--- a/src/Game/UI/uiFadeProgress.cpp
+++ b/src/Game/UI/uiFadeProgress.cpp
@@ -1,5 +1,6 @@
 #include "Game/UI/uiFadeProgress.h"
 #include "Game/UI/uiUtils.h"
+#include "KingSystem/System/UIGlue.h"
 
 namespace uking::ui {
 
@@ -37,7 +38,7 @@ void FadeProgress::updateFadeScreen() {
     if (new_progress < progress)
         progress = new_progress;
     mGaugeValue = progress;
-    applyScreenFade(progress);
+    ksys::ui::applyScreenFade(progress);
 }
 
 void FadeProgress::setProgress(float value) {
diff --git a/src/Game/UI/uiUtils.h b/src/Game/UI/uiUtils.h
index 288b7996..39b66348 100644
--- a/src/Game/UI/uiUtils.h
+++ b/src/Game/UI/uiUtils.h
@@ -47,11 +47,6 @@ void setShowRaceResult(s32 result_type);
 
 int countCookResultsCheck(const sead::SafeString& name, s32 effect_type);
 int countCookResultsAllOk(const sead::SafeString& name);
-int getItemValue(const sead::SafeString& name);
-
-// TODO: move these to another translation unit (TBD)
-// Do not implement until the location is figured out
-void applyScreenFade(float progress);
 
 act::CreateEquipmentSlot getCreateEquipmentSlot(ui::PouchItemType type);
 ui::EquipmentSlot getEquipmentSlot(act::CreateEquipmentSlot slot);
diff --git a/src/KingSystem/ActorSystem/actActorCreator.cpp b/src/KingSystem/ActorSystem/actActorCreator.cpp
index 5bb3303d..32556639 100644
--- a/src/KingSystem/ActorSystem/actActorCreator.cpp
+++ b/src/KingSystem/ActorSystem/actActorCreator.cpp
@@ -23,7 +23,7 @@ ActorCreator::ActorCreator() {
     mPlacementMgrHeap = nullptr;
 }
 
-void ActorCreator::onTaskRemoved(const util::TaskRemoveCallbackContext& context) {
+void ActorCreator::onTaskRemoved(const TaskRemoveCallbackContext& context) {
     if (!context.mTask)
         return;
 
diff --git a/src/KingSystem/ActorSystem/actActorCreator.h b/src/KingSystem/ActorSystem/actActorCreator.h
index 3368e765..7560230d 100644
--- a/src/KingSystem/ActorSystem/actActorCreator.h
+++ b/src/KingSystem/ActorSystem/actActorCreator.h
@@ -67,7 +67,7 @@ private:
                            InstParamPack* params, bool sleep_after_init, bool = false);
 
     BaseProc* doCreateProc(BaseProcCreateArg& arg);
-    void onTaskRemoved(const util::TaskRemoveCallbackContext& context);
+    void onTaskRemoved(const TaskRemoveCallbackContext& context);
 
     sead::Heap* mForBaseProcDualHeap;
     sead::Heap* mPlacementMgrHeap;
@@ -79,8 +79,7 @@ private:
     void* _60{};
     sead::Delegate1R<ActorCreator, BaseProcCreateArg&, BaseProc*> mCreateProcDelegate{
         this, &ActorCreator::doCreateProc};
-    util::TaskRemoveCallbackT<ActorCreator> mTaskRemovedDelegate{this,
-                                                                 &ActorCreator::onTaskRemoved};
+    TaskRemoveCallbackT<ActorCreator> mTaskRemovedDelegate{this, &ActorCreator::onTaskRemoved};
     sead::CriticalSection mActorListCS;
     ActorFactory* mActorFactory;
 };
diff --git a/src/KingSystem/ActorSystem/actActorParam.h b/src/KingSystem/ActorSystem/actActorParam.h
index a1796eca..6e869b57 100644
--- a/src/KingSystem/ActorSystem/actActorParam.h
+++ b/src/KingSystem/ActorSystem/actActorParam.h
@@ -175,8 +175,8 @@ private:
     std::array<s32, 2> mNumHandles;
     s32 mRefCount{};
     sead::CriticalSection mCS{nullptr};
-    util::Event mEvent{nullptr,
-                       sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, true};
+    Event mEvent{nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified,
+                 true};
 };
 KSYS_CHECK_SIZE_NX150(ActorParam, 0x200);
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp b/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
index b2d623fc..ab52e12a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTask.cpp
@@ -75,7 +75,7 @@ void BaseProcCreateTask::doPrepare(const BaseProcCreateTaskData* arg) {
     }();
 }
 
-void BaseProcCreateTask::prepareImpl_(util::TaskRequest* req) {
+void BaseProcCreateTask::prepareImpl_(TaskRequest* req) {
     doPrepare(sead::DynamicCast<BaseProcCreateTaskRequest>(req)->mData);
     setDelegateInternal_(&mTaskDelegate);
 }
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTask.h b/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
index 50c1c966..fcffd092 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTask.h
@@ -33,8 +33,8 @@ struct BaseProcCreateArg {
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateArg, 0x58);
 
-class BaseProcCreateTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskData, util::TaskData)
+class BaseProcCreateTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskData, TaskData)
 
 public:
     BaseProcCreateTaskData() = default;
@@ -53,8 +53,8 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateTaskData, 0x68);
 
-class BaseProcCreateTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskRequest, util::TaskRequest)
+class BaseProcCreateTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTaskRequest, TaskRequest)
 
 public:
     BaseProcCreateTaskRequest() = default;
@@ -62,8 +62,8 @@ public:
     BaseProcCreateTaskData* mData{};
 };
 
-class BaseProcCreateTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(BaseProcCreateTask, util::ManagedTask)
+class BaseProcCreateTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(BaseProcCreateTask, ManagedTask)
 
 public:
     enum class LaneId : u8 {
@@ -77,7 +77,7 @@ public:
     void onBaseProcCreationFailed(BaseProc* proc, bool set_flag_5);
 
 protected:
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
 
 private:
     friend class BaseProcCreateTaskSelector;
@@ -92,8 +92,8 @@ private:
     sead::IDelegate1R<BaseProcCreateArg&, BaseProc*>* mCreateDelegate{};
     BaseProcUnit* mUnit{};
     map::Object* mMapObject{};
-    util::TaskDelegateT<BaseProcCreateTask> mTaskDelegate{
-        this, &BaseProcCreateTask::onTaskDelegateInvoked};
+    TaskDelegateT<BaseProcCreateTask> mTaskDelegate{this,
+                                                    &BaseProcCreateTask::onTaskDelegateInvoked};
     BaseProcLink mLink;
     f32 mDistanceToLoadSphere = -1.0;
     InstParamPack::Buffer mParams;
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
index 3609d5a2..397d831a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.cpp
@@ -7,9 +7,9 @@ namespace ksys::act {
 
 SEAD_SINGLETON_DISPOSER_IMPL(BaseProcCreateTaskSelector)
 
-util::Task* BaseProcCreateTaskSelector::selectTask(const util::TaskSelectionContext& context) {
-    util::Task* min_task = nullptr;
-    util::Task* lane1_task = nullptr;
+Task* BaseProcCreateTaskSelector::selectTask(const TaskSelectionContext& context) {
+    Task* min_task = nullptr;
+    Task* lane1_task = nullptr;
     auto min = std::numeric_limits<float>::max();
 
     for (auto& it : context) {
diff --git a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
index 40e5da31..9c03e271 100644
--- a/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
+++ b/src/KingSystem/ActorSystem/actBaseProcCreateTaskSelector.h
@@ -15,9 +15,9 @@ public:
     auto& getDelegate() { return mDelegate; }
 
 private:
-    util::Task* selectTask(const util::TaskSelectionContext& context);
+    Task* selectTask(const TaskSelectionContext& context);
 
-    util::TaskSelectionDelegateT<BaseProcCreateTaskSelector> mDelegate{
+    TaskSelectionDelegateT<BaseProcCreateTaskSelector> mDelegate{
         this, &BaseProcCreateTaskSelector::selectTask};
 };
 KSYS_CHECK_SIZE_NX150(BaseProcCreateTaskSelector, 0x40);
diff --git a/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp b/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
index a83e48d0..5541b11a 100644
--- a/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcDeleter.cpp
@@ -31,12 +31,12 @@ BaseProcDeleter::~BaseProcDeleter() {
 void BaseProcDeleter::init(const InitArg& arg) {
     auto* heap = arg.heap;
     mTaskQueue = arg.task_queue;
-    mTaskMgr = new (heap) util::TaskMgr(heap);
-    mTaskMgr->init<util::ManagedTask>(arg.task_queue_size, heap);
+    mTaskMgr = new (heap) TaskMgr(heap);
+    mTaskMgr->init<ManagedTask>(arg.task_queue_size, heap);
 }
 
 bool BaseProcDeleter::requestPreDelete(BaseProc* proc) {
-    util::TaskRequest request{false};
+    TaskRequest request{false};
     request.mSynchronous = false;
     request.mQueue = mTaskQueue;
     request.mDelegate = &mPreDeleteDelegate;
@@ -44,13 +44,13 @@ bool BaseProcDeleter::requestPreDelete(BaseProc* proc) {
     request.mLaneId = u8(TaskLane::PreDelete);
     request.mName = "PreDelete";
 
-    util::TaskMgrRequest req;
+    TaskMgrRequest req;
     req.request = &request;
     return mTaskMgr->trySubmitRequest(req);
 }
 
 void BaseProcDeleter::requestUnloadActorParam(ActorParam* param) {
-    util::TaskRequest request{false};
+    TaskRequest request{false};
     request.mSynchronous = false;
     request.mQueue = mTaskQueue;
     request.mDelegate = &mUnloadActorParamDelegate;
@@ -58,7 +58,7 @@ void BaseProcDeleter::requestUnloadActorParam(ActorParam* param) {
     request.mLaneId = u8(TaskLane::UnloadActorParam);
     request.mName = "UnloadActorParam";
 
-    util::TaskMgrRequest req;
+    TaskMgrRequest req;
     req.request = &request;
     mTaskMgr->submitRequest(req);
 }
diff --git a/src/KingSystem/ActorSystem/actBaseProcDeleter.h b/src/KingSystem/ActorSystem/actBaseProcDeleter.h
index a46f5131..a3575293 100644
--- a/src/KingSystem/ActorSystem/actBaseProcDeleter.h
+++ b/src/KingSystem/ActorSystem/actBaseProcDeleter.h
@@ -5,10 +5,10 @@
 #include "KingSystem/Utils/Thread/Task.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 class TaskMgr;
 class TaskQueue;
-}  // namespace ksys::util
+}  // namespace ksys
 
 namespace ksys::act {
 
@@ -19,7 +19,7 @@ class BaseProcDeleter {
 public:
     struct InitArg {
         sead::Heap* heap;
-        util::TaskQueue* task_queue;
+        TaskQueue* task_queue;
         int task_queue_size;
     };
 
@@ -40,12 +40,11 @@ private:
     bool doPreDelete(void* proc);
     bool doUnloadParam(void* actor_param);
 
-    util::TaskMgr* mTaskMgr{};
-    util::TaskQueue* mTaskQueue{};
+    TaskMgr* mTaskMgr{};
+    TaskQueue* mTaskQueue{};
     sead::Buffer<void*> mBuffer;
-    util::TaskDelegateT<BaseProcDeleter> mPreDeleteDelegate{this, &BaseProcDeleter::doPreDelete};
-    util::TaskDelegateT<BaseProcDeleter> mUnloadActorParamDelegate{this,
-                                                                   &BaseProcDeleter::doUnloadParam};
+    TaskDelegateT<BaseProcDeleter> mPreDeleteDelegate{this, &BaseProcDeleter::doPreDelete};
+    TaskDelegateT<BaseProcDeleter> mUnloadActorParamDelegate{this, &BaseProcDeleter::doUnloadParam};
 };
 KSYS_CHECK_SIZE_NX150(BaseProcDeleter, 0x68);
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcHandle.cpp b/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
index bdde1c62..cc780cc3 100644
--- a/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcHandle.cpp
@@ -26,7 +26,7 @@ bool BaseProcHandle::hasProcCreationFailed() const {
     if (status == BaseProcUnit::Status::NoProc || status == BaseProcUnit::Status::Cancelled)
         return true;
 
-    if (mUnit->getCreateTask().getStatus() == util::Task::Status::RemovedFromQueue ||
+    if (mUnit->getCreateTask().getStatus() == Task::Status::RemovedFromQueue ||
         status == BaseProcUnit::Status::Cancelled) {
         return true;
     }
@@ -38,7 +38,7 @@ bool BaseProcHandle::isProcCreationCancelled() const {
     if (!mUnit)
         return false;
 
-    if (mUnit->getCreateTask().getStatus() == util::Task::Status::RemovedFromQueue)
+    if (mUnit->getCreateTask().getStatus() == Task::Status::RemovedFromQueue)
         return true;
 
     if (mUnit->getStatus() == BaseProcUnit::Status::Cancelled)
diff --git a/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp b/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
index 2785fd5b..e927df9e 100644
--- a/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcInitializer.cpp
@@ -42,8 +42,8 @@ void BaseProcInitializer::init(sead::Heap* parent_heap, const BaseProcInitialize
     mThreads.allocBufferAssert(NumThreads, mHeap);
 
     const auto init_queue = [&] {
-        mTaskQueue = new (mHeap) util::TaskQueue(mHeap);
-        util::TaskQueue::InitArg arg;
+        mTaskQueue = new (mHeap) TaskQueue(mHeap);
+        TaskQueue::InitArg arg;
         arg.enable_locks = true;
         arg.heap = mHeap;
         arg.num_lanes = 5;
@@ -53,16 +53,16 @@ void BaseProcInitializer::init(sead::Heap* parent_heap, const BaseProcInitialize
     };
     init_queue();
 
-    mTaskMgr = new (mHeap) util::TaskMgr(mHeap);
+    mTaskMgr = new (mHeap) TaskMgr(mHeap);
     mTaskMgr->initAndCheckType<BaseProcCreateTask>(args.queue_size, mHeap);
 
     for (int i = 0; i < NumThreads; ++i) {
         mThreads[i].thread_name.format("%s", args.thread_name.cstr());
-        mThreads[i].thread = new (mHeap) util::GameTaskThread(
+        mThreads[i].thread = new (mHeap) GameTaskThread(
             mThreads[i].thread_name, mHeap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(20),
             sead::MessageQueue::BlockType::Blocking, 0x7FFFFFFF, 0x100000, 64);
         {
-            util::TaskThread::InitArg arg;
+            TaskThread::InitArg arg;
             arg.num_lanes = 5;
             arg.heap = mHeap;
             arg.queue = mTaskQueue;
@@ -109,7 +109,7 @@ bool BaseProcInitializer::requestCreateBaseProc(const BaseProcCreateRequest& req
     if (req.task_data)
         task_req.mName = req.task_data->mProcName;
 
-    util::TaskMgrRequest mgr_req;
+    TaskMgrRequest mgr_req;
     if (req.task_data->mProcHandle) {
         if (!req.task_data->mProcHandle->allocUnit()) {
             req.task_data->mProcHandle->setFailed(true);
@@ -214,11 +214,11 @@ void BaseProcInitializer::pauseMainThread() {
 void BaseProcInitializer::resumeMainThread() {
     mThreads[0].valid = true;
     if (!mThreads[0].thread) {
-        mThreads[0].thread = new (mHeap) util::GameTaskThread(
+        mThreads[0].thread = new (mHeap) GameTaskThread(
             mThreads[0].thread_name, mHeap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(20),
             sead::MessageQueue::BlockType::Blocking, 0x7FFFFFFF, 0x100000, 64);
         {
-            util::TaskThread::InitArg arg;
+            TaskThread::InitArg arg;
             arg.num_lanes = 5;
             arg.heap = mHeap;
             arg.queue = mTaskQueue;
@@ -272,8 +272,8 @@ int BaseProcInitializer::getQueueSize(int x) const {
     return count;
 }
 
-void BaseProcInitializer::removeTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate) {
-    util::TaskQueueLock lock;
+void BaseProcInitializer::removeTasksIf(sead::IDelegate1R<Task*, bool>& predicate) {
+    TaskQueueLock lock;
     auto it = mTaskQueue->activeTasksRobustBegin(&lock);
     const auto end = mTaskQueue->activeTasksRobustEnd();
     for (; it != end; ++it) {
diff --git a/src/KingSystem/ActorSystem/actBaseProcInitializer.h b/src/KingSystem/ActorSystem/actBaseProcInitializer.h
index 649e0002..4c4b5900 100644
--- a/src/KingSystem/ActorSystem/actBaseProcInitializer.h
+++ b/src/KingSystem/ActorSystem/actBaseProcInitializer.h
@@ -10,11 +10,11 @@ namespace sead {
 class Heap;
 }
 
-namespace ksys::util {
+namespace ksys {
 class TaskMgr;
 class TaskQueue;
 class TaskThread;
-}  // namespace ksys::util
+}  // namespace ksys
 
 namespace ksys::act {
 
@@ -24,14 +24,14 @@ struct BaseProcCreateRequest;
 struct BaseProcInitializerArgs {
     u32 queue_size;
     sead::SafeString thread_name = "BaseProcCreate";
-    util::TaskSelectionDelegate* task_selector = nullptr;
+    TaskSelectionDelegate* task_selector = nullptr;
 };
 
 class BaseProcInitializer {
 public:
     struct ThreadInfo {
         bool valid = false;
-        util::TaskThread* thread = nullptr;
+        TaskThread* thread = nullptr;
         sead::FixedSafeString<32> thread_name;
     };
     KSYS_CHECK_SIZE_NX150(ThreadInfo, 0x48);
@@ -68,15 +68,15 @@ public:
     void cancelTasks();
     int getQueueSize(int x = -1) const;
 
-    void removeTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate);
+    void removeTasksIf(sead::IDelegate1R<Task*, bool>& predicate);
     void setActorGenerationEnabled(bool enabled);
 
-    util::TaskQueue* getTaskQueue() const { return mTaskQueue; }
+    TaskQueue* getTaskQueue() const { return mTaskQueue; }
 
 private:
     sead::Buffer<ThreadInfo> mThreads;
-    util::TaskMgr* mTaskMgr = nullptr;
-    util::TaskQueue* mTaskQueue = nullptr;
+    TaskMgr* mTaskMgr = nullptr;
+    TaskQueue* mTaskQueue = nullptr;
     sead::Heap* mHeap = nullptr;
     bool mActorGenerationEnabled = true;
 };
diff --git a/src/KingSystem/ActorSystem/actBaseProcMgr.cpp b/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
index 9c8c59be..7d9b3120 100644
--- a/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
+++ b/src/KingSystem/ActorSystem/actBaseProcMgr.cpp
@@ -614,7 +614,7 @@ int BaseProcMgr::getInitializerQueueSizeEx(int x) const {
     return mProcInitializer->getQueueSize(x);
 }
 
-void BaseProcMgr::removeInitializerTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate) {
+void BaseProcMgr::removeInitializerTasksIf(sead::IDelegate1R<Task*, bool>& predicate) {
     mProcInitializer->removeTasksIf(predicate);
 }
 
diff --git a/src/KingSystem/ActorSystem/actBaseProcMgr.h b/src/KingSystem/ActorSystem/actBaseProcMgr.h
index 26c5d97c..67def589 100644
--- a/src/KingSystem/ActorSystem/actBaseProcMgr.h
+++ b/src/KingSystem/ActorSystem/actBaseProcMgr.h
@@ -37,7 +37,7 @@ class BaseProcJobQue;
 struct BaseProcCreateRequest {
     u32 task_lane_id;
     BaseProcCreateTaskData* task_data;
-    util::TaskRemoveCallback* task_remove_callback;
+    TaskRemoveCallback* task_remove_callback;
 };
 
 class BaseProcMgr {
@@ -201,7 +201,7 @@ public:
     bool isAnyInitializerThreadActive() const;
     int getInitializerQueueSize() const;
     int getInitializerQueueSizeEx(int x = -1) const;
-    void removeInitializerTasksIf(sead::IDelegate1R<util::Task*, bool>& predicate);
+    void removeInitializerTasksIf(sead::IDelegate1R<Task*, bool>& predicate);
     void setActorGenerationEnabled(bool enabled);
 
     // endregion
diff --git a/src/KingSystem/Framework/CMakeLists.txt b/src/KingSystem/Framework/CMakeLists.txt
index cbae2e87..e3bea8e3 100644
--- a/src/KingSystem/Framework/CMakeLists.txt
+++ b/src/KingSystem/Framework/CMakeLists.txt
@@ -1,7 +1,7 @@
 target_sources(uking PRIVATE
+  frmFramework.cpp
+  frmFramework.h
   frmRootTaskParam.h
   frmWorkerSupportThreadMgr.cpp
   frmWorkerSupportThreadMgr.h
-  Framework.cpp
-  Framework.h
 )
diff --git a/src/KingSystem/Framework/Framework.cpp b/src/KingSystem/Framework/Framework.cpp
deleted file mode 100644
index f11ef44e..00000000
--- a/src/KingSystem/Framework/Framework.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "KingSystem/Framework/Framework.h"
\ No newline at end of file
diff --git a/src/KingSystem/Framework/frmFramework.cpp b/src/KingSystem/Framework/frmFramework.cpp
new file mode 100644
index 00000000..2dbca29c
--- /dev/null
+++ b/src/KingSystem/Framework/frmFramework.cpp
@@ -0,0 +1 @@
+#include "KingSystem/Framework/frmFramework.h"
\ No newline at end of file
diff --git a/src/KingSystem/Framework/Framework.h b/src/KingSystem/Framework/frmFramework.h
index aa390f57..aa390f57 100644
--- a/src/KingSystem/Framework/Framework.h
+++ b/src/KingSystem/Framework/frmFramework.h
diff --git a/src/KingSystem/Framework/frmWorkerSupportThreadMgr.cpp b/src/KingSystem/Framework/frmWorkerSupportThreadMgr.cpp
index 4880df32..fafd9f42 100644
--- a/src/KingSystem/Framework/frmWorkerSupportThreadMgr.cpp
+++ b/src/KingSystem/Framework/frmWorkerSupportThreadMgr.cpp
@@ -15,13 +15,13 @@ SEAD_SINGLETON_DISPOSER_IMPL(WorkerSupportThreadMgr)
 void WorkerSupportThreadMgr::init(sead::Heap* heap) {
     auto* worker = mWorkers;
     for (size_t i = 0; i < NumWorkers; ++i) {
-        auto* mgr = new (heap) util::TaskMgr(heap);
-        mgr->init<util::ManagedTask>(NumTasks, heap);
+        auto* mgr = new (heap) TaskMgr(heap);
+        mgr->init<ManagedTask>(NumTasks, heap);
         worker->task_mgr = mgr;
 
-        worker->task_handle = new (heap) util::ManagedTaskHandle;
+        worker->task_handle = new (heap) ManagedTaskHandle;
         for (int j = 0; j < NumTasks; ++j)
-            worker->tasks[j] = new (heap) util::ManagedTask(heap);
+            worker->tasks[j] = new (heap) ManagedTask(heap);
 
         const auto affinity = [&] {
             if (i == 0)
@@ -30,11 +30,11 @@ void WorkerSupportThreadMgr::init(sead::Heap* heap) {
         }();
 
         worker->thread_name.format("WorkerSupport[%d]", int(i));
-        worker->task_thread = new (heap) util::GameTaskThread(
+        worker->task_thread = new (heap) GameTaskThread(
             worker->thread_name, heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(17),
             sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0x20000, 32);
 
-        util::TaskThread::InitArg arg;
+        TaskThread::InitArg arg;
         arg.batch_size = 0;
         arg.heap = nullptr;
         arg.queue = nullptr;
@@ -85,23 +85,23 @@ static int getTaskIdx(u32 id) {
     return idx[id];
 }
 
-util::ManagedTask* WorkerSupportThreadMgr::getTask(int id) {
+ManagedTask* WorkerSupportThreadMgr::getTask(int id) {
     return mWorkers[getWorkerIdx(id)].tasks[getTaskIdx(id)];
 }
 
-void WorkerSupportThreadMgr::submitRequest(int id, util::TaskDelegate* delegate) {
+void WorkerSupportThreadMgr::submitRequest(int id, TaskDelegate* delegate) {
     auto& worker = mWorkers[getWorkerIdx(id)];
     if (mThreadsPaused)
         return;
 
-    util::TaskRequest req{false};
+    TaskRequest req{false};
     req.mName = worker.thread_name;
     req.mDelegate = delegate;
     req.mHasHandle = true;
     req.mSynchronous = false;
     req.mThread = worker.task_thread;
 
-    util::TaskMgrRequest task_mgr_req;
+    TaskMgrRequest task_mgr_req;
     task_mgr_req.request = &req;
     task_mgr_req.handle = worker.task_handle;
     task_mgr_req.task = worker.tasks[getTaskIdx(id)];
diff --git a/src/KingSystem/Framework/frmWorkerSupportThreadMgr.h b/src/KingSystem/Framework/frmWorkerSupportThreadMgr.h
index 2ec99fa2..25a3ada2 100644
--- a/src/KingSystem/Framework/frmWorkerSupportThreadMgr.h
+++ b/src/KingSystem/Framework/frmWorkerSupportThreadMgr.h
@@ -11,12 +11,12 @@ class DelegateThread;
 class Thread;
 }  // namespace sead
 
-namespace ksys::util {
+namespace ksys {
 class GameTaskThread;
 class ManagedTask;
 class ManagedTaskHandle;
 class TaskMgr;
-}  // namespace ksys::util
+}  // namespace ksys
 
 namespace ksys::frm {
 
@@ -28,7 +28,7 @@ class WorkerSupportThreadMgr {
 public:
     void init(sead::Heap* heap);
 
-    void submitRequest(int id, util::TaskDelegate* delegate);
+    void submitRequest(int id, TaskDelegate* delegate);
     void waitForTask(int id);
     void pauseThreads();
     void resumeThreads();
@@ -39,18 +39,18 @@ private:
     static constexpr int NumTasks = 5;
 
     struct Worker {
-        util::GameTaskThread* task_thread = nullptr;
+        GameTaskThread* task_thread = nullptr;
         sead::DelegateThread* thread;
-        util::ManagedTask* tasks[NumTasks];
-        util::TaskMgr* task_mgr = nullptr;
-        util::ManagedTaskHandle* task_handle;
+        ManagedTask* tasks[NumTasks];
+        TaskMgr* task_mgr = nullptr;
+        ManagedTaskHandle* task_handle;
         sead::FixedSafeString<32> thread_name;
     };
 
     void initSleeperThreads();
     void sleeperThreadFun(sead::Thread* thread, sead::MessageQueue::Element);
 
-    util::ManagedTask* getTask(int id);
+    ManagedTask* getTask(int id);
 
     Worker mWorkers[NumWorkers];
     bool mThreadsPaused = false;
diff --git a/src/KingSystem/Physics/System/physRayCastRequestMgr.h b/src/KingSystem/Physics/System/physRayCastRequestMgr.h
index 4dde6bd6..7f8de114 100644
--- a/src/KingSystem/Physics/System/physRayCastRequestMgr.h
+++ b/src/KingSystem/Physics/System/physRayCastRequestMgr.h
@@ -33,7 +33,7 @@ private:
     sead::CriticalSection mCS;
     sead::TList<RayCastForRequest*> mQueuedList;
     sead::TList<RayCastForRequest*> mFreeList;
-    util::TaskDelegateT<RayCastRequestMgr> mWorkerFunction;
+    TaskDelegateT<RayCastRequestMgr> mWorkerFunction;
     /// The number of requests to process per batch.
     int mBatchSize = 1;
     int mLargestRecordedQueueSize = 0;
diff --git a/src/KingSystem/Resource/resArchiveWork.cpp b/src/KingSystem/Resource/resArchiveWork.cpp
index 0838b7ec..e537faaf 100644
--- a/src/KingSystem/Resource/resArchiveWork.cpp
+++ b/src/KingSystem/Resource/resArchiveWork.cpp
@@ -16,7 +16,7 @@ ArchiveWork::~ArchiveWork() {
 }
 
 bool ArchiveWork::init(const ArchiveWork::InitArg& arg) {
-    mEvent = new (arg.heap) util::Event(
+    mEvent = new (arg.heap) Event(
         nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, false);
     mEvent->resetSignal();
 
diff --git a/src/KingSystem/Resource/resArchiveWork.h b/src/KingSystem/Resource/resArchiveWork.h
index 2ec0f3e2..5229f551 100644
--- a/src/KingSystem/Resource/resArchiveWork.h
+++ b/src/KingSystem/Resource/resArchiveWork.h
@@ -12,9 +12,7 @@ namespace ksys {
 
 class OverlayArena;
 
-namespace util {
 class Event;
-}
 
 namespace res {
 
@@ -41,7 +39,7 @@ public:
     void setEvent();
 
 private:
-    util::Event* mEvent = nullptr;
+    Event* mEvent = nullptr;
     OverlayArena* mArena = nullptr;
 };
 KSYS_CHECK_SIZE_NX150(ArchiveWork, 0x10);
diff --git a/src/KingSystem/Resource/resControlTask.cpp b/src/KingSystem/Resource/resControlTask.cpp
index 3cee95c5..66c3470e 100644
--- a/src/KingSystem/Resource/resControlTask.cpp
+++ b/src/KingSystem/Resource/resControlTask.cpp
@@ -3,11 +3,11 @@
 
 namespace ksys::res {
 
-ControlTask::ControlTask(sead::Heap* heap) : util::ManagedTask(heap) {}
+ControlTask::ControlTask(sead::Heap* heap) : ManagedTask(heap) {}
 
 void ControlTask::onRun_() {}
 
-void ControlTask::prepareImpl_(util::TaskRequest* req_) {
+void ControlTask::prepareImpl_(TaskRequest* req_) {
     auto* req = static_cast<ControlTaskRequest*>(req_);
 
     mData.mHasResLoadReq = req->mHasResLoadReq;
diff --git a/src/KingSystem/Resource/resControlTask.h b/src/KingSystem/Resource/resControlTask.h
index 13a68ecc..2ceebc78 100644
--- a/src/KingSystem/Resource/resControlTask.h
+++ b/src/KingSystem/Resource/resControlTask.h
@@ -12,8 +12,8 @@ namespace ksys::res {
 class Handle;
 class ResourceUnit;
 
-class ControlTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(ControlTaskData, util::TaskData)
+class ControlTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(ControlTaskData, TaskData)
 public:
     virtual ~ControlTaskData() = default;
 
@@ -25,22 +25,22 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(ControlTaskData, 0x138);
 
-class ControlTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(ControlTask, util::ManagedTask)
+class ControlTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(ControlTask, ManagedTask)
 public:
     explicit ControlTask(sead::Heap* heap);
 
 private:
     void onRun_() override;
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
     void preRemoveImpl_() override;
 
     ControlTaskData mData;
 };
 KSYS_CHECK_SIZE_NX150(ControlTask, 0x1f8);
 
-class ControlTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(ControlTaskRequest, util::TaskRequest)
+class ControlTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(ControlTaskRequest, TaskRequest)
 public:
     explicit ControlTaskRequest(bool has_handle = false) : TaskRequest(has_handle) {}
 
diff --git a/src/KingSystem/Resource/resHandle.cpp b/src/KingSystem/Resource/resHandle.cpp
index c620ee25..c2d5d83e 100644
--- a/src/KingSystem/Resource/resHandle.cpp
+++ b/src/KingSystem/Resource/resHandle.cpp
@@ -209,7 +209,7 @@ bool Handle::parseResource(Context* context) {
     if (mFlags.isOn(Flag::UnloadRequested))
         return false;
 
-    if (mTaskHandle.getStatus() == util::ManagedTaskHandle::Status::TaskRemoved ||
+    if (mTaskHandle.getStatus() == ManagedTaskHandle::Status::TaskRemoved ||
         (mUnit && mUnit->isTask1NotQueued())) {
         stubbedLogFunction();
         mStatus = Status::Cancelled;
diff --git a/src/KingSystem/Resource/resHandle.h b/src/KingSystem/Resource/resHandle.h
index aacad690..538a53f4 100644
--- a/src/KingSystem/Resource/resHandle.h
+++ b/src/KingSystem/Resource/resHandle.h
@@ -111,7 +111,7 @@ private:
     sead::TypedBitFlag<Flag> mFlags = Flag::Dummy;
     Status mStatus = Status::NoFile;
     ResourceUnit* mUnit = nullptr;
-    util::ManagedTaskHandle mTaskHandle;
+    ManagedTaskHandle mTaskHandle;
     sead::ListNode mListNode;
 };
 KSYS_CHECK_SIZE_NX150(Handle, 0x50);
diff --git a/src/KingSystem/Resource/resMemoryTask.cpp b/src/KingSystem/Resource/resMemoryTask.cpp
index 3f580852..17a78d94 100644
--- a/src/KingSystem/Resource/resMemoryTask.cpp
+++ b/src/KingSystem/Resource/resMemoryTask.cpp
@@ -3,11 +3,11 @@
 
 namespace ksys::res {
 
-MemoryTask::MemoryTask(sead::Heap* heap) : util::ManagedTask(heap) {}
+MemoryTask::MemoryTask(sead::Heap* heap) : ManagedTask(heap) {}
 
 void MemoryTask::onRun_() {}
 
-void MemoryTask::prepareImpl_(util::TaskRequest* req_) {
+void MemoryTask::prepareImpl_(TaskRequest* req_) {
     auto* req = static_cast<MemoryTaskRequest*>(req_);
     mData._8 = req->mData_8;
     mData._c = req->mData_c;
diff --git a/src/KingSystem/Resource/resMemoryTask.h b/src/KingSystem/Resource/resMemoryTask.h
index 2de1a5f8..f7d3b416 100644
--- a/src/KingSystem/Resource/resMemoryTask.h
+++ b/src/KingSystem/Resource/resMemoryTask.h
@@ -7,8 +7,8 @@
 
 namespace ksys::res {
 
-class MemoryTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(MemoryTaskData, util::TaskData)
+class MemoryTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(MemoryTaskData, TaskData)
 public:
     virtual ~MemoryTaskData() = default;
 
@@ -18,25 +18,25 @@ public:
 };
 KSYS_CHECK_SIZE_NX150(MemoryTaskData, 0xa8);
 
-class MemoryTask : public util::ManagedTask {
-    SEAD_RTTI_OVERRIDE(MemoryTask, util::ManagedTask)
+class MemoryTask : public ManagedTask {
+    SEAD_RTTI_OVERRIDE(MemoryTask, ManagedTask)
 public:
     explicit MemoryTask(sead::Heap* heap);
     ~MemoryTask() override { ; }
 
 private:
     void onRun_() override;
-    void prepareImpl_(util::TaskRequest* req) override;
+    void prepareImpl_(TaskRequest* req) override;
     void preRemoveImpl_() override;
 
-    void setUserData() { util::ManagedTask::setUserData(&mData); }
+    void setUserData() { ManagedTask::setUserData(&mData); }
 
     MemoryTaskData mData;
 };
 KSYS_CHECK_SIZE_NX150(MemoryTask, 0x168);
 
-class MemoryTaskRequest : public util::TaskRequest {
-    SEAD_RTTI_OVERRIDE(MemoryTaskRequest, util::TaskRequest)
+class MemoryTaskRequest : public TaskRequest {
+    SEAD_RTTI_OVERRIDE(MemoryTaskRequest, TaskRequest)
 public:
     MemoryTaskRequest() = default;
 
diff --git a/src/KingSystem/Resource/resResourceMgrTask.cpp b/src/KingSystem/Resource/resResourceMgrTask.cpp
index 74e845a1..f241361f 100644
--- a/src/KingSystem/Resource/resResourceMgrTask.cpp
+++ b/src/KingSystem/Resource/resResourceMgrTask.cpp
@@ -23,8 +23,8 @@
 namespace ksys::res {
 
 namespace {
-class ClearCachesTaskData : public util::TaskData {
-    SEAD_RTTI_OVERRIDE(ClearCachesTaskData, util::TaskData)
+class ClearCachesTaskData : public TaskData {
+    SEAD_RTTI_OVERRIDE(ClearCachesTaskData, TaskData)
 public:
     virtual ~ClearCachesTaskData() = default;
 
@@ -106,17 +106,17 @@ void ResourceMgrTask::insertOverlayArena(OverlayArena* arena) {
     }
 }
 
-util::TaskThread* ResourceMgrTask::makeResourceLoadingThread(sead::Heap* heap,
-                                                             bool use_game_task_thread) {
+TaskThread* ResourceMgrTask::makeResourceLoadingThread(sead::Heap* heap,
+                                                       bool use_game_task_thread) {
     if (use_game_task_thread) {
-        return new (heap) util::GameTaskThread(
+        return new (heap) GameTaskThread(
             "Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
             sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xfa000, 32);
     }
 
-    return new (heap) util::TaskThread(
-        "Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
-        sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xa000, 32);
+    return new (heap)
+        TaskThread("Resource Loading", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(19),
+                   sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0xa000, 32);
 }
 
 void ResourceMgrTask::clearAllCaches(OverlayArena* arena) {
@@ -135,13 +135,13 @@ void ResourceMgrTask::clearAllCaches(OverlayArena* arena) {
     req.mData_c = -1;
     req.mData_mStr = arena->getHeap()->getName();
 
-    util::TaskMgrRequest task_mgr_request;
+    TaskMgrRequest task_mgr_request;
     task_mgr_request.request = &req;
     mResourceMemoryTaskMgr->submitRequest(task_mgr_request);
 }
 
 bool ResourceMgrTask::isDefragDone() const {
-    return mTask2->getStatus() == util::Task::Status::PostFinishCallback;
+    return mTask2->getStatus() == Task::Status::PostFinishCallback;
 }
 
 f32 ResourceMgrTask::getDefragProgress() const {
@@ -263,7 +263,7 @@ void ResourceMgrTask::deregisterUnit(ResourceUnit* unit) {
     }
 }
 
-void ResourceMgrTask::requestClearCache(ResourceUnit** p_unit, util::Task* task) {
+void ResourceMgrTask::requestClearCache(ResourceUnit** p_unit, Task* task) {
     if (!p_unit || !*p_unit || !(*p_unit)->isStatusFlag8000Set()) {
         stubbedLogFunction();
         return;
@@ -405,7 +405,7 @@ bool ResourceMgrTask::calc_(void*) {
         req.mData_8 = false;
         req.mData_c = -1;
 
-        util::TaskMgrRequest request;
+        TaskMgrRequest request;
         request.request = &req;
         mResourceMemoryTaskMgr->submitRequest(request);
         mTexHandleMgr->clearAllCache();
@@ -522,7 +522,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
     auto* unit = mUnitPool.tryAlloc();
 
     if (!unit) {
-        util::TaskQueueLock lock;
+        TaskQueueLock lock;
 
         auto* queue = mResourceControlThread->getTaskQueue();
         auto it = queue->activeTasksRobustBegin(&lock);
@@ -541,7 +541,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
         ClearCachesTaskData data;
         data._8 = true;
         data._c = 100;
-        util::TaskRequest req;
+        TaskRequest req;
         req.mLaneId = u8(LaneId::_8);
         req.mHasHandle = true;
         req.mSynchronous = true;
@@ -555,7 +555,7 @@ ResourceUnit* ResourceMgrTask::clearCachesAndGetUnit(const GetUnitArg& arg) {
     }
 
     if (!unit) {
-        util::TaskQueueLock lock;
+        TaskQueueLock lock;
 
         auto* queue = mResourceControlThread->getTaskQueue();
         auto it = queue->activeTasksRobustBegin(&lock);
@@ -658,7 +658,7 @@ void ResourceMgrTask::clearUnits_() {
 
 void ResourceMgrTask::systemCalc_() {
     if (mTask1->canSubmitRequest()) {
-        util::TaskRequest request;
+        TaskRequest request;
         request.mSynchronous = false;
         request.mHasHandle = false;
         request.mLaneId = u8(LaneId::_6);
@@ -732,7 +732,7 @@ void ResourceMgrTask::clearAllCachesSynchronously(OverlayArena* arena) {
     req.mData_c = -1;
     req.mData_mStr = arena->getHeap()->getName();
 
-    util::TaskMgrRequest task_mgr_request;
+    TaskMgrRequest task_mgr_request;
     task_mgr_request.request = &req;
     mResourceMemoryTaskMgr->submitRequest(task_mgr_request);
 }
diff --git a/src/KingSystem/Resource/resResourceMgrTask.h b/src/KingSystem/Resource/resResourceMgrTask.h
index eddcf08b..6cec9e1b 100644
--- a/src/KingSystem/Resource/resResourceMgrTask.h
+++ b/src/KingSystem/Resource/resResourceMgrTask.h
@@ -35,11 +35,9 @@ class SZSDecompressor;
 namespace ksys {
 class OverlayArena;
 
-namespace util {
 class TaskMgr;
 class TaskPostRunResult;
 class TaskThread;
-}  // namespace util
 }  // namespace ksys
 
 namespace ksys::res {
@@ -99,8 +97,7 @@ public:
     };
 
     using ResourceUnitDelegate = sead::Delegate1RFunc<void*, bool>;
-    using TaskCallback =
-        sead::Delegate2Func<util::TaskPostRunResult*, const util::TaskPostRunContext&>;
+    using TaskCallback = sead::Delegate2Func<TaskPostRunResult*, const TaskPostRunContext&>;
     using MemoryTaskDelegate = sead::Delegate1R<ResourceMgrTask, void*, bool>;
 
     struct ResourceUnitDelegatePair {
@@ -114,7 +111,7 @@ public:
 
     void insertOverlayArena(OverlayArena* arena);
 
-    util::TaskThread* makeResourceLoadingThread(sead::Heap* heap, bool use_game_task_thread);
+    TaskThread* makeResourceLoadingThread(sead::Heap* heap, bool use_game_task_thread);
 
     void clearAllCaches(OverlayArena* arena);
     OverlayArena* getTexHandleMgrArena() const;
@@ -157,7 +154,7 @@ public:
     void registerUnit(ResourceUnit* unit);
     void deregisterUnit(ResourceUnit* unit);
 
-    void requestClearCache(ResourceUnit** p_unit, util::Task* task = nullptr);
+    void requestClearCache(ResourceUnit** p_unit, Task* task = nullptr);
     void requestClearCacheForSync(ResourceUnit** p_unit, bool clear_immediately,
                                   bool delete_immediately);
 
@@ -206,7 +203,7 @@ public:
     ResourceUnit* clearCachesAndGetUnit(const GetUnitArg& arg);
 
     struct SetActorCreateInitializerThreadsArg {
-        sead::PtrArray<util::TaskThread>* threads;
+        sead::PtrArray<TaskThread>* threads;
     };
     void setActorCreateInitializerThreads(const SetActorCreateInitializerThreadsArg& arg);
     void clearActorCreateInitializerThreads();
@@ -261,10 +258,10 @@ public:
 
     void removeOverlayArena(OverlayArena* arena);
 
-    util::TaskThread* getResourceLoadingThread() const { return mResourceLoadingThread; }
-    util::TaskThread* getResourceControlThread() const { return mResourceControlThread; }
-    util::TaskThread* getResourceMemoryThread() const { return mResourceMemoryThread; }
-    util::TaskThread* getMovableMemoryThread() const { return mMovableMemoryThread; }
+    TaskThread* getResourceLoadingThread() const { return mResourceLoadingThread; }
+    TaskThread* getResourceControlThread() const { return mResourceControlThread; }
+    TaskThread* getResourceMemoryThread() const { return mResourceMemoryThread; }
+    TaskThread* getMovableMemoryThread() const { return mMovableMemoryThread; }
 
     ResourceUnitDelegatePair& getUnitInitLoadFn() { return mUnitInitLoadFn; }
     auto& getUnitAdjustHeapFn() { return mUnitAdjustHeapFn; }
@@ -315,17 +312,17 @@ private:
     sead::TypedBitFlag<CacheControlFlag> mCacheControlFlags;
     u32 _17c = 0;
     sead::Heap* mResSystemHeap = nullptr;
-    util::TaskThread* mResourceLoadingThread = nullptr;
-    util::TaskThread* mResourceControlThread = nullptr;
-    util::TaskThread* mResourceMemoryThread = nullptr;
-    util::TaskThread* mMovableMemoryThread = nullptr;
-    sead::PtrArray<util::TaskThread>* mActorCreateInitializerThreads = nullptr;
-    util::TaskMgr* mResourceControlTaskMgr = nullptr;
-    util::TaskMgr* mResourceMemoryTaskMgr;
+    TaskThread* mResourceLoadingThread = nullptr;
+    TaskThread* mResourceControlThread = nullptr;
+    TaskThread* mResourceMemoryThread = nullptr;
+    TaskThread* mMovableMemoryThread = nullptr;
+    sead::PtrArray<TaskThread>* mActorCreateInitializerThreads = nullptr;
+    TaskMgr* mResourceControlTaskMgr = nullptr;
+    TaskMgr* mResourceMemoryTaskMgr;
     ControlTask* mControlTask = nullptr;
-    util::Task* mTask1 = nullptr;
-    util::Task* mTask2 = nullptr;
-    util::Task* mTask3 = nullptr;
+    Task* mTask1 = nullptr;
+    Task* mTask2 = nullptr;
+    Task* mTask3 = nullptr;
 
     EntryFactoryBase* mEntryFactoryBase = nullptr;
     EntryFactoryBase* mDefaultEntryFactory = nullptr;
@@ -349,9 +346,8 @@ private:
     MemoryTaskDelegate mDefragAllMemoryMgrFn;
 
     MemoryTaskDelegate mLoadFn;
-    sead::Delegate2<ResourceMgrTask, util::TaskPostRunResult*, const util::TaskPostRunContext&>
-        mLoadCb;
-    sead::Delegate1<ResourceMgrTask, const util::TaskRemoveCallbackContext&> mLoadTaskRemoveCb;
+    sead::Delegate2<ResourceMgrTask, TaskPostRunResult*, const TaskPostRunContext&> mLoadCb;
+    sead::Delegate1<ResourceMgrTask, const TaskRemoveCallbackContext&> mLoadTaskRemoveCb;
 
     MemoryTaskDelegate mCalcFn;
     MemoryTaskDelegate mCalcArenaHeapSizeFn;
@@ -413,7 +409,7 @@ private:
     u8 _9c0d98 = 1;
     size_t _9c0da0 = 500;
 
-    util::Task mTask;                     // TODO: rename
+    Task mTask;                           // TODO: rename
     sead::CriticalSection mCritSection4;  // TODO: rename
     sead::TickTime mTickTime;
     MemoryTaskDelegate mSystemCalcFn;
diff --git a/src/KingSystem/Resource/resUnit.cpp b/src/KingSystem/Resource/resUnit.cpp
index 186cffb2..2aa93005 100644
--- a/src/KingSystem/Resource/resUnit.cpp
+++ b/src/KingSystem/Resource/resUnit.cpp
@@ -98,12 +98,12 @@ bool ResourceUnit::init(const ResourceUnit::InitArg& arg) {
     }
 
     {
-        util::TaskDelegateSetter setter;
+        TaskDelegateSetter setter;
         mTask1.setDelegate(setter);
     }
 
     {
-        util::TaskDelegateSetter setter;
+        TaskDelegateSetter setter;
         mTask2.setDelegate(setter);
     }
 
@@ -154,7 +154,7 @@ void ResourceUnit::updateStatus() {
 }
 
 bool ResourceUnit::isTask1NotQueued() const {
-    return mTask1.getStatus() == util::Task::Status::RemovedFromQueue;
+    return mTask1.getStatus() == Task::Status::RemovedFromQueue;
 }
 
 bool ResourceUnit::isStatus0() const {
@@ -243,7 +243,7 @@ bool ResourceUnit::removeTask3FromQueue() {
 void ResourceUnit::requestInitLoad(const RequestInitLoadArg& arg) {
     mStatus = Status::_7;
 
-    util::TaskRequest req;
+    TaskRequest req;
     req.mHasHandle = arg.has_handle;
     req.mSynchronous = false;
     req.mLaneId = arg.lane_id;
diff --git a/src/KingSystem/Resource/resUnit.h b/src/KingSystem/Resource/resUnit.h
index 981b7678..87a8f565 100644
--- a/src/KingSystem/Resource/resUnit.h
+++ b/src/KingSystem/Resource/resUnit.h
@@ -196,14 +196,14 @@ private:
 
     void initLoad(void* x = nullptr);
     void prepareLoad();
-    void requestPrepareLoad(util::TaskPostRunResult* result, const util::TaskPostRunContext& ctx);
+    void requestPrepareLoad(TaskPostRunResult* result, const TaskPostRunContext& ctx);
 
     void unloadForSync();
     void clearCacheForSync(bool x);
 
     void unload();
     void clearCache(void* x);
-    void requestClearCache(util::TaskPostRunResult* result, const util::TaskPostRunContext& ctx);
+    void requestClearCache(TaskPostRunResult* result, const TaskPostRunContext& ctx);
 
     sead::TypedBitFlag<CacheFlag> mCacheFlags;
     sead::TypedBitFlag<Flag> mFlags;
@@ -226,13 +226,13 @@ private:
     sead::ListNode mArenaUnitListNode;
     sead::ListNode mArenaUnitListNode2;
     sead::ListNode mResMgrUnitListNode;
-    util::Task mTask1;
-    util::Task mTask2;
-    util::Task mTask3;
+    Task mTask1;
+    Task mTask2;
+    Task mTask3;
     ResourceUnitMapNode mMapNode{this};
     sead::Atomic<s32> mCounter;
-    util::Event mEvent{nullptr,
-                       sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified, true};
+    Event mEvent{nullptr, sead::IDisposer::HeapNullOption::DoNotAppendDisposerIfNoHeapSpecified,
+                 true};
     sead::ResourceMgr::LoadArg mLoadArg;
     sead::FixedSafeString<128> mPath;
     sead::Heap* mHeap = nullptr;
diff --git a/src/KingSystem/System/OverlayArenaSystem.cpp b/src/KingSystem/System/OverlayArenaSystem.cpp
index bafb705a..82a59aaf 100644
--- a/src/KingSystem/System/OverlayArenaSystem.cpp
+++ b/src/KingSystem/System/OverlayArenaSystem.cpp
@@ -66,12 +66,12 @@ void OverlayArenaSystem::destroyHeaps() {
 bool OverlayArenaSystem::init(const InitArg& arg, sead::Heap* heap) {
     mSystemPauseMgr = arg.system_pause_mgr;
 
-    mPrepareThread = new (heap) util::TaskThread(
+    mPrepareThread = new (heap) TaskThread(
         "OverlayArena Prepare", heap, sead::ThreadUtil::ConvertPrioritySeadToPlatform(17),
         sead::MessageQueue::BlockType::Blocking, 0x7fffffff, 0x14000, 32);
 
     {
-        util::TaskThread::InitArg arg_;
+        TaskThread::InitArg arg_;
         arg_.batch_size = 0;
         arg_.queue = nullptr;
         arg_.num_lanes = 1;
@@ -84,8 +84,8 @@ bool OverlayArenaSystem::init(const InitArg& arg, sead::Heap* heap) {
     mDelegate = {this, &OverlayArenaSystem::delegatedFunction};
 
     {
-        mTask = new (heap) util::Task(heap);
-        util::TaskDelegateSetter setter;
+        mTask = new (heap) Task(heap);
+        TaskDelegateSetter setter;
         mTask->setDelegate(setter);
     }
 
diff --git a/src/KingSystem/System/OverlayArenaSystem.h b/src/KingSystem/System/OverlayArenaSystem.h
index a0a3cd71..3350c390 100644
--- a/src/KingSystem/System/OverlayArenaSystem.h
+++ b/src/KingSystem/System/OverlayArenaSystem.h
@@ -17,11 +17,8 @@ class SZSDecompressor;
 
 namespace ksys {
 
-namespace util {
 class Task;
 class TaskThread;
-}  // namespace util
-
 class OverlayArena;
 
 class ISystemPauseMgr {
@@ -116,14 +113,14 @@ private:
     ISystemPauseMgr* mSystemPauseMgr = nullptr;
     OverlayArenaSystemS1 mS1;
     u32 _b8 = 0;
-    util::TaskThread* mPrepareThread = nullptr;
-    util::Task* mTask = nullptr;
+    TaskThread* mPrepareThread = nullptr;
+    Task* mTask = nullptr;
     sead::DelegateR<OverlayArenaSystem, bool> mDelegate;
     OverlayArenaSystemS2 mS2;
     sead::Atomic<u32> _130 = 0;
     sead::Atomic<u32> _134 = 0;
     res::Handle mResHandle;
-    util::Event mEvent;
+    Event mEvent;
 };
 KSYS_CHECK_SIZE_NX150(OverlayArenaSystem, 0x1c8);
 
diff --git a/src/KingSystem/System/ProductReporter.cpp b/src/KingSystem/System/ProductReporter.cpp
index 827f01fa..4812734a 100644
--- a/src/KingSystem/System/ProductReporter.cpp
+++ b/src/KingSystem/System/ProductReporter.cpp
@@ -7,7 +7,7 @@
 #include <nn/oe.h>
 
 #include "KingSystem/Camera/CameraMgr.h"
-#include "KingSystem/Framework/Framework.h"
+#include "KingSystem/Framework/frmFramework.h"
 #include "KingSystem/Map/mapPlacementMgr.h"
 #include "KingSystem/Sound/sndMgr.h"
 #include "KingSystem/System/PlayReportMgr.h"
diff --git a/src/KingSystem/System/UIGlue.h b/src/KingSystem/System/UIGlue.h
index d07da634..4dffe1b3 100644
--- a/src/KingSystem/System/UIGlue.h
+++ b/src/KingSystem/System/UIGlue.h
@@ -5,7 +5,9 @@
 namespace ksys::ui {
 
 int getPorchNum(const sead::SafeString& name);
+int getItemValue(const sead::SafeString& name);
 void initRupeeCounter();
 bool isRupeeCounterActive();
+void applyScreenFade(float progress);
 
 }  // namespace ksys::ui
diff --git a/src/KingSystem/Utils/Thread/Event.cpp b/src/KingSystem/Utils/Thread/Event.cpp
index 1c16be54..b7e3fef7 100644
--- a/src/KingSystem/Utils/Thread/Event.cpp
+++ b/src/KingSystem/Utils/Thread/Event.cpp
@@ -1,6 +1,6 @@
 #include "KingSystem/Utils/Thread/Event.h"
 
-namespace ksys::util {
+namespace ksys {
 
 Event::Event() = default;
 
@@ -51,4 +51,4 @@ bool Event::isSignalSet() const {
     return mSignalSet == 1;
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/Event.h b/src/KingSystem/Utils/Thread/Event.h
index 6db2822a..22956d47 100644
--- a/src/KingSystem/Utils/Thread/Event.h
+++ b/src/KingSystem/Utils/Thread/Event.h
@@ -4,7 +4,7 @@
 #include <thread/seadEvent.h>
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class Event {
 public:
@@ -32,4 +32,4 @@ private:
 KSYS_CHECK_SIZE_NX150(sead::Event, 0x30);
 KSYS_CHECK_SIZE_NX150(Event, 0x40);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/GameTaskThread.cpp b/src/KingSystem/Utils/Thread/GameTaskThread.cpp
index eacd9e64..c6f6eab1 100644
--- a/src/KingSystem/Utils/Thread/GameTaskThread.cpp
+++ b/src/KingSystem/Utils/Thread/GameTaskThread.cpp
@@ -1,6 +1,6 @@
 #include "KingSystem/Utils/Thread/GameTaskThread.h"
 
-namespace ksys::util {
+namespace ksys {
 
 GameTaskThread::GameTaskThread(const sead::SafeString& name, sead::Heap* heap, s32 priority,
                                sead::MessageQueue::BlockType block_type, long quit_msg,
@@ -12,4 +12,4 @@ void GameTaskThread::quit(bool) {
     Thread::quit(false);
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/GameTaskThread.h b/src/KingSystem/Utils/Thread/GameTaskThread.h
index a16e9f68..6f1d6f8d 100644
--- a/src/KingSystem/Utils/Thread/GameTaskThread.h
+++ b/src/KingSystem/Utils/Thread/GameTaskThread.h
@@ -3,7 +3,7 @@
 #include "KingSystem/Utils/Thread/TaskThread.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class GameTaskThread : public TaskThread {
     SEAD_RTTI_OVERRIDE(GameTaskThread, TaskThread)
@@ -24,4 +24,4 @@ protected:
 };
 KSYS_CHECK_SIZE_NX150(GameTaskThread, 0x1a8);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/LowPrioThreadMgr.cpp b/src/KingSystem/Utils/Thread/LowPrioThreadMgr.cpp
index 35f69e48..e69ad4a7 100644
--- a/src/KingSystem/Utils/Thread/LowPrioThreadMgr.cpp
+++ b/src/KingSystem/Utils/Thread/LowPrioThreadMgr.cpp
@@ -5,7 +5,7 @@
 #include "KingSystem/Utils/SafeDelete.h"
 #include "KingSystem/Utils/Thread/TaskQueue.h"
 
-namespace ksys::util {
+namespace ksys {
 
 SEAD_SINGLETON_DISPOSER_IMPL(LowPrioThreadMgr)
 
@@ -116,4 +116,4 @@ void LowPrioThreadMgr::resumeAllTasks() {
 
 void LowPrioThreadMgr::sub_710127AC40() {}
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/LowPrioThreadMgr.h b/src/KingSystem/Utils/Thread/LowPrioThreadMgr.h
index 08ddfe85..e5a24383 100644
--- a/src/KingSystem/Utils/Thread/LowPrioThreadMgr.h
+++ b/src/KingSystem/Utils/Thread/LowPrioThreadMgr.h
@@ -7,7 +7,7 @@
 #include "KingSystem/Utils/Thread/TaskMgr.h"
 #include "KingSystem/Utils/Thread/TaskThread.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class LowPrioThreadMgr {
     SEAD_SINGLETON_DISPOSER(LowPrioThreadMgr)
@@ -55,4 +55,4 @@ private:
     sead::Buffer<CoreThreadTask> mCoreThreadTasks{};
 };
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/ManagedTask.cpp b/src/KingSystem/Utils/Thread/ManagedTask.cpp
index 8a0f3dfd..2c2c1c58 100644
--- a/src/KingSystem/Utils/Thread/ManagedTask.cpp
+++ b/src/KingSystem/Utils/Thread/ManagedTask.cpp
@@ -3,7 +3,7 @@
 #include "KingSystem/Utils/Thread/TaskMgr.h"
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 
-namespace ksys::util {
+namespace ksys {
 
 ManagedTask::ManagedTask(sead::Heap* heap) : Task(heap) {}
 
@@ -103,4 +103,4 @@ void ManagedTask::detachHandle() {
     }
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/ManagedTask.h b/src/KingSystem/Utils/Thread/ManagedTask.h
index 8116de41..32e00b01 100644
--- a/src/KingSystem/Utils/Thread/ManagedTask.h
+++ b/src/KingSystem/Utils/Thread/ManagedTask.h
@@ -3,7 +3,7 @@
 #include "KingSystem/Utils/Thread/Task.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class ManagedTaskHandle;
 class TaskMgr;
@@ -43,4 +43,4 @@ protected:
 };
 KSYS_CHECK_SIZE_NX150(ManagedTask, 0xc0);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/ManagedTaskHandle.cpp b/src/KingSystem/Utils/Thread/ManagedTaskHandle.cpp
index 874bf46f..60f9e5cb 100644
--- a/src/KingSystem/Utils/Thread/ManagedTaskHandle.cpp
+++ b/src/KingSystem/Utils/Thread/ManagedTaskHandle.cpp
@@ -3,7 +3,7 @@
 #include "KingSystem/Utils/Thread/TaskQueueBase.h"
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 
-namespace ksys::util {
+namespace ksys {
 
 ManagedTaskHandle::ManagedTaskHandle() = default;
 
@@ -104,4 +104,4 @@ inline void ManagedTaskHandle::decrementRef_() {
     }
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/ManagedTaskHandle.h b/src/KingSystem/Utils/Thread/ManagedTaskHandle.h
index 61c41c51..04beea9c 100644
--- a/src/KingSystem/Utils/Thread/ManagedTaskHandle.h
+++ b/src/KingSystem/Utils/Thread/ManagedTaskHandle.h
@@ -4,7 +4,7 @@
 #include <time/seadTickSpan.h>
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class ManagedTask;
 class TaskQueueBase;
@@ -57,4 +57,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(ManagedTaskHandle, 0x28);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/MessageDispatcher.h b/src/KingSystem/Utils/Thread/MessageDispatcher.h
index 2a6706d5..7cbc7175 100644
--- a/src/KingSystem/Utils/Thread/MessageDispatcher.h
+++ b/src/KingSystem/Utils/Thread/MessageDispatcher.h
@@ -154,7 +154,7 @@ private:
     sead::Buffer<u8> mBoolBuffer;
     sead::ObjList<u8*> mBools;
     sead::CriticalSection mCritSection;
-    util::Event mUpdateEndEvent;
+    Event mUpdateEndEvent;
     sead::Atomic<int> mNumEntries = 0;
 };
 
diff --git a/src/KingSystem/Utils/Thread/Task.cpp b/src/KingSystem/Utils/Thread/Task.cpp
index e2ba464f..fd740fbb 100644
--- a/src/KingSystem/Utils/Thread/Task.cpp
+++ b/src/KingSystem/Utils/Thread/Task.cpp
@@ -4,7 +4,7 @@
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 #include "KingSystem/Utils/Thread/TaskThread.h"
 
-namespace ksys::util {
+namespace ksys {
 
 TaskDelegateSetter::TaskDelegateSetter() = default;
 
@@ -282,4 +282,4 @@ void Task::setLaneId(u8 id) {
     mLaneId = id;
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/Task.h b/src/KingSystem/Utils/Thread/Task.h
index 5c9d95c3..da7aab87 100644
--- a/src/KingSystem/Utils/Thread/Task.h
+++ b/src/KingSystem/Utils/Thread/Task.h
@@ -9,7 +9,7 @@
 #include "KingSystem/Utils/Thread/Event.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class Task;
 class TaskQueueBase;
@@ -203,4 +203,4 @@ KSYS_CHECK_SIZE_NX150(Task, 0xa8);
 
 inline void Task::prepare_(TaskRequest*) {}
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskData.h b/src/KingSystem/Utils/Thread/TaskData.h
index 68db7ce0..251d1413 100644
--- a/src/KingSystem/Utils/Thread/TaskData.h
+++ b/src/KingSystem/Utils/Thread/TaskData.h
@@ -2,10 +2,10 @@
 
 #include <prim/seadRuntimeTypeInfo.h>
 
-namespace ksys::util {
+namespace ksys {
 
 class TaskData {
     SEAD_RTTI_BASE(TaskData)
 };
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskMgr.cpp b/src/KingSystem/Utils/Thread/TaskMgr.cpp
index 6f6c58c3..4f4f8e02 100644
--- a/src/KingSystem/Utils/Thread/TaskMgr.cpp
+++ b/src/KingSystem/Utils/Thread/TaskMgr.cpp
@@ -4,7 +4,7 @@
 #include "KingSystem/Utils/Thread/ManagedTask.h"
 #include "KingSystem/Utils/Thread/TaskThread.h"
 
-namespace ksys::util {
+namespace ksys {
 
 TaskMgr::TaskMgr(sead::Heap* heap)
     : mTasksCS(heap), mCS2(heap), mNewFreeTaskEvent(heap, true), mEvent2(heap, true) {
@@ -209,4 +209,4 @@ ManagedTask* TaskMgr::fetchIdleTask_(bool retry_until_success) {
     }
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskMgr.h b/src/KingSystem/Utils/Thread/TaskMgr.h
index 4c8fa131..d0bc03eb 100644
--- a/src/KingSystem/Utils/Thread/TaskMgr.h
+++ b/src/KingSystem/Utils/Thread/TaskMgr.h
@@ -15,7 +15,7 @@
 #include "KingSystem/Utils/Thread/ManagedTask.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class ManagedTaskHandle;
 class TaskRequest;
@@ -93,7 +93,7 @@ protected:
 
     template <typename TaskType>
     void makeTaskType_(ManagedTask** task) {
-        *task = new TaskType(getCurrentHeap());
+        *task = new TaskType(util::getCurrentHeap());
     }
 
     template <typename TaskType>
@@ -114,4 +114,4 @@ protected:
 };
 KSYS_CHECK_SIZE_NX150(TaskMgr, 0x158);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueue.cpp b/src/KingSystem/Utils/Thread/TaskQueue.cpp
index cf76c768..bb0d886b 100644
--- a/src/KingSystem/Utils/Thread/TaskQueue.cpp
+++ b/src/KingSystem/Utils/Thread/TaskQueue.cpp
@@ -1,7 +1,7 @@
 #include "KingSystem/Utils/Thread/TaskQueue.h"
 
-namespace ksys::util {
+namespace ksys {
 
 TaskQueue::TaskQueue(sead::Heap* heap) : TaskQueueBase(heap), mCS(heap) {}
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueue.h b/src/KingSystem/Utils/Thread/TaskQueue.h
index 6792a783..0706834c 100644
--- a/src/KingSystem/Utils/Thread/TaskQueue.h
+++ b/src/KingSystem/Utils/Thread/TaskQueue.h
@@ -3,7 +3,7 @@
 #include <thread/seadCriticalSection.h>
 #include "KingSystem/Utils/Thread/TaskQueueBase.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class TaskQueue : public TaskQueueBase {
     SEAD_RTTI_OVERRIDE(TaskQueue, TaskQueueBase)
@@ -18,4 +18,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(TaskQueue, 0xd0);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueueBase.cpp b/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
index 5310726c..10c55680 100644
--- a/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
+++ b/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
@@ -7,7 +7,7 @@
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 #include "KingSystem/Utils/Thread/TaskThread.h"
 
-namespace ksys::util {
+namespace ksys {
 
 static const auto cSleepSpan = sead::TickSpan::makeFromMicroSeconds(10);
 
@@ -333,7 +333,8 @@ void TaskQueueBase::notifyThreadsForNewTasks() {
     }
 
     if (retry_count >= 2)
-        PrintDebug(sead::FormatFixedSafeString<128>("↓↓↓\nリトライ回数 %d 回\n↑↑↑\n", retry_count));
+        util::PrintDebug(
+            sead::FormatFixedSafeString<128>("↓↓↓\nリトライ回数 %d 回\n↑↑↑\n", retry_count));
 }
 
 bool TaskQueueBase::push(const PushArg& arg) {
@@ -482,4 +483,4 @@ void TaskQueueBase::fetchTask(Task** out_task) {
     unlock();
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueueBase.h b/src/KingSystem/Utils/Thread/TaskQueueBase.h
index e90d4a24..14d94316 100644
--- a/src/KingSystem/Utils/Thread/TaskQueueBase.h
+++ b/src/KingSystem/Utils/Thread/TaskQueueBase.h
@@ -11,7 +11,7 @@
 #include "KingSystem/Utils/Thread/Event.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class Task;
 class TaskQueueLock;
@@ -156,4 +156,4 @@ protected:
 };
 KSYS_CHECK_SIZE_NX150(TaskQueueBase, 0x90);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueueLock.cpp b/src/KingSystem/Utils/Thread/TaskQueueLock.cpp
index be7b1c5e..758a2a95 100644
--- a/src/KingSystem/Utils/Thread/TaskQueueLock.cpp
+++ b/src/KingSystem/Utils/Thread/TaskQueueLock.cpp
@@ -1,7 +1,7 @@
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 #include "KingSystem/Utils/Thread/TaskQueueBase.h"
 
-namespace ksys::util {
+namespace ksys {
 
 TaskQueueLock::TaskQueueLock() = default;
 
@@ -23,4 +23,4 @@ void TaskQueueLock::unlock() {
     }
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskQueueLock.h b/src/KingSystem/Utils/Thread/TaskQueueLock.h
index 2bc44035..da95b798 100644
--- a/src/KingSystem/Utils/Thread/TaskQueueLock.h
+++ b/src/KingSystem/Utils/Thread/TaskQueueLock.h
@@ -4,7 +4,7 @@
 #include "KingSystem/Utils/Thread/TaskThread.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class TaskQueueBase;
 
@@ -25,4 +25,4 @@ private:
 };
 KSYS_CHECK_SIZE_NX150(TaskQueueLock, 0x10);
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskThread.cpp b/src/KingSystem/Utils/Thread/TaskThread.cpp
index 27dcd4e9..447143df 100644
--- a/src/KingSystem/Utils/Thread/TaskThread.cpp
+++ b/src/KingSystem/Utils/Thread/TaskThread.cpp
@@ -4,7 +4,7 @@
 #include "KingSystem/Utils/Thread/TaskQueue.h"
 #include "KingSystem/Utils/Thread/TaskQueueLock.h"
 
-namespace ksys::util {
+namespace ksys {
 
 TaskThread::TaskThread(const sead::SafeString& name, sead::Heap* heap, s32 priority,
                        sead::MessageQueue::BlockType block_type,
@@ -259,4 +259,4 @@ void TaskThread::cancelCurrentTask() {
         mTask->cancel();
 }
 
-}  // namespace ksys::util
+}  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/TaskThread.h b/src/KingSystem/Utils/Thread/TaskThread.h
index 8d2cb559..d8b4b9b7 100644
--- a/src/KingSystem/Utils/Thread/TaskThread.h
+++ b/src/KingSystem/Utils/Thread/TaskThread.h
@@ -7,7 +7,7 @@
 #include "KingSystem/Utils/Thread/Event.h"
 #include "KingSystem/Utils/Types.h"
 
-namespace ksys::util {
+namespace ksys {
 
 class Task;
 class TaskQueueBase;
@@ -106,4 +106,4 @@ protected:
 };
 KSYS_CHECK_SIZE_NX150(TaskThread, 0x1a0);
 
-}  // namespace ksys::util
+}  // namespace ksys