diff --git a/HPPA/TaskTreeModel.cpp b/HPPA/TaskTreeModel.cpp
index 5443bc9..bdf3d57 100644
--- a/HPPA/TaskTreeModel.cpp
+++ b/HPPA/TaskTreeModel.cpp
@@ -3,44 +3,44 @@
 #include <QFont>
 #include <QIcon>
 
-// ==================== TreeNode 实现 ====================
+// ==================== TaskTreeNode 实现 ====================
 
-TreeNode::TreeNode(TreeNode* parent)
+TaskTreeNode::TaskTreeNode(TaskTreeNode* parent)
     : m_parent(parent)
 {
 }
 
-TreeNode::~TreeNode()
+TaskTreeNode::~TaskTreeNode()
 {
     qDeleteAll(m_children);
 }
 
-void TreeNode::appendChild(TreeNode* child)
+void TaskTreeNode::appendChild(TaskTreeNode* child)
 {
     m_children.append(child);
 }
 
-TreeNode* TreeNode::child(int row)
+TaskTreeNode* TaskTreeNode::child(int row)
 {
     if (row < 0 || row >= m_children.size())
         return nullptr;
     return m_children.at(row);
 }
 
-int TreeNode::childCount() const
+int TaskTreeNode::childCount() const
 {
     return m_children.size();
 }
 
-int TreeNode::row() const
+int TaskTreeNode::row() const
 {
     if (m_parent) {
-        return m_parent->m_children.indexOf(const_cast<TreeNode*>(this));
+        return m_parent->m_children.indexOf(const_cast<TaskTreeNode*>(this));
     }
     return 0;
 }
 
-TreeNode* TreeNode::parentNode()
+TaskTreeNode* TaskTreeNode::parentNode()
 {
     return m_parent;
 }
@@ -49,7 +49,7 @@ TreeNode* TreeNode::parentNode()
 
 TaskTreeModel::TaskTreeModel(QObject* parent)
     : QAbstractItemModel(parent)
-    , m_rootNode(new TreeNode())
+    , m_rootNode(new TaskTreeNode())
     , m_countdownTimer(new QTimer(this))
 {
     m_rootNode->nodeType = TreeNodeType::Root;
@@ -68,13 +68,13 @@ QModelIndex TaskTreeModel::index(int row, int column, const QModelIndex& parent)
     if (!hasIndex(row, column, parent))
         return QModelIndex();
 
-    TreeNode* parentNode;
+    TaskTreeNode* parentNode;
     if (!parent.isValid())
         parentNode = m_rootNode;
     else
-        parentNode = static_cast<TreeNode*>(parent.internalPointer());
+        parentNode = static_cast<TaskTreeNode*>(parent.internalPointer());
 
-    TreeNode* childNode = parentNode->child(row);
+    TaskTreeNode* childNode = parentNode->child(row);
     if (childNode)
         return createIndex(row, column, childNode);
 
@@ -86,8 +86,8 @@ QModelIndex TaskTreeModel::parent(const QModelIndex& index) const
     if (!index.isValid())
         return QModelIndex();
 
-    TreeNode* childNode = static_cast<TreeNode*>(index.internalPointer());
-    TreeNode* parentNode = childNode->parentNode();
+    TaskTreeNode* childNode = static_cast<TaskTreeNode*>(index.internalPointer());
+    TaskTreeNode* parentNode = childNode->parentNode();
 
     if (parentNode == m_rootNode)
         return QModelIndex();
@@ -97,11 +97,11 @@ QModelIndex TaskTreeModel::parent(const QModelIndex& index) const
 
 int TaskTreeModel::rowCount(const QModelIndex& parent) const
 {
-    TreeNode* parentNode;
+    TaskTreeNode* parentNode;
     if (!parent.isValid())
         parentNode = m_rootNode;
     else
-        parentNode = static_cast<TreeNode*>(parent.internalPointer());
+        parentNode = static_cast<TaskTreeNode*>(parent.internalPointer());
 
     return parentNode->childCount();
 }
@@ -117,7 +117,7 @@ QVariant TaskTreeModel::data(const QModelIndex& index, int role) const
     if (!index.isValid())
         return QVariant();
 
-    TreeNode* node = static_cast<TreeNode*>(index.internalPointer());
+    TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
 
     if (role == Qt::DisplayRole) {
         if (node->nodeType == TreeNodeType::Task && node->taskData) {
@@ -328,7 +328,7 @@ void TaskTreeModel::setupModelData()
         TimedTask& task = m_tasks[i];
 
         // 创建任务节点
-        TreeNode* taskNode = new TreeNode(m_rootNode);
+        TaskTreeNode* taskNode = new TaskTreeNode(m_rootNode);
         taskNode->nodeType = TreeNodeType::Task;
         taskNode->taskId = task.id;
         taskNode->taskData = &task;
@@ -338,7 +338,7 @@ void TaskTreeModel::setupModelData()
         for (int j = 0; j < task.subTasks.size(); ++j) {
             SubTask& subTask = task.subTasks[j];
 
-            TreeNode* subTaskNode = new TreeNode(taskNode);
+            TaskTreeNode* subTaskNode = new TaskTreeNode(taskNode);
             subTaskNode->nodeType = TreeNodeType::SubTask;
             subTaskNode->taskId = task.id;
             subTaskNode->subTaskIndex = j;
@@ -365,13 +365,13 @@ void TaskTreeModel::updateTask(const TimedTask& task)
     m_tasks[dataIndex] = task;
 
     // 重新设置指针（因为数据被复制了）
-    TreeNode* taskNode = findTaskNode(task.id);
+    TaskTreeNode* taskNode = findTaskNode(task.id);
     if (taskNode) {
         taskNode->taskData = &m_tasks[dataIndex];
 
         // 更新子任务指针
         for (int i = 0; i < taskNode->childCount() && i < m_tasks[dataIndex].subTasks.size(); ++i) {
-            TreeNode* subNode = taskNode->child(i);
+            TaskTreeNode* subNode = taskNode->child(i);
             if (subNode) {
                 subNode->subTaskData = &m_tasks[dataIndex].subTasks[i];
             }
@@ -406,7 +406,7 @@ void TaskTreeModel::updateSubTask(int taskId, int subTaskIndex, const SubTask& s
     m_tasks[dataIndex].subTasks[subTaskIndex] = subTask;
 
     // 重新设置指针
-    TreeNode* subNode = findSubTaskNode(taskId, subTaskIndex);
+    TaskTreeNode* subNode = findSubTaskNode(taskId, subTaskIndex);
     if (subNode) {
         subNode->subTaskData = &m_tasks[dataIndex].subTasks[subTaskIndex];
     }
@@ -510,7 +510,7 @@ SubTask* TaskTreeModel::getSubTask(int taskId, int subTaskIndex)
 QModelIndex TaskTreeModel::getTaskIndex(int taskId) const
 {
     for (int i = 0; i < m_rootNode->childCount(); ++i) {
-        TreeNode* node = m_rootNode->child(i);
+        TaskTreeNode* node = m_rootNode->child(i);
         if (node && node->taskId == taskId) {
             return createIndex(i, 0, node);
         }
@@ -520,9 +520,9 @@ QModelIndex TaskTreeModel::getTaskIndex(int taskId) const
 
 QModelIndex TaskTreeModel::getSubTaskIndex(int taskId, int subTaskIndex) const
 {
-    TreeNode* taskNode = findTaskNode(taskId);
+    TaskTreeNode* taskNode = findTaskNode(taskId);
     if (taskNode && subTaskIndex < taskNode->childCount()) {
-        TreeNode* subNode = taskNode->child(subTaskIndex);
+        TaskTreeNode* subNode = taskNode->child(subTaskIndex);
         if (subNode) {
             return createIndex(subTaskIndex, 0, subNode);
         }
@@ -530,10 +530,10 @@ QModelIndex TaskTreeModel::getSubTaskIndex(int taskId, int subTaskIndex) const
     return QModelIndex();
 }
 
-TreeNode* TaskTreeModel::findTaskNode(int taskId) const
+TaskTreeNode* TaskTreeModel::findTaskNode(int taskId) const
 {
     for (int i = 0; i < m_rootNode->childCount(); ++i) {
-        TreeNode* node = m_rootNode->child(i);
+        TaskTreeNode* node = m_rootNode->child(i);
         if (node && node->taskId == taskId) {
             return node;
         }
@@ -541,9 +541,9 @@ TreeNode* TaskTreeModel::findTaskNode(int taskId) const
     return nullptr;
 }
 
-TreeNode* TaskTreeModel::findSubTaskNode(int taskId, int subTaskIndex) const
+TaskTreeNode* TaskTreeModel::findSubTaskNode(int taskId, int subTaskIndex) const
 {
-    TreeNode* taskNode = findTaskNode(taskId);
+    TaskTreeNode* taskNode = findTaskNode(taskId);
     if (taskNode && subTaskIndex < taskNode->childCount()) {
         return taskNode->child(subTaskIndex);
     }
diff --git a/HPPA/TaskTreeModel.h b/HPPA/TaskTreeModel.h
index d9e762a..b9576eb 100644
--- a/HPPA/TaskTreeModel.h
+++ b/HPPA/TaskTreeModel.h
@@ -14,17 +14,17 @@ enum class TreeNodeType {
 };
 
 // 树节点数据
-class TreeNode
+class TaskTreeNode
 {
 public:
-    explicit TreeNode(TreeNode* parent = nullptr);
-    ~TreeNode();
+    explicit TaskTreeNode(TaskTreeNode* parent = nullptr);
+    ~TaskTreeNode();
 
-    void appendChild(TreeNode* child);
-    TreeNode* child(int row);
+    void appendChild(TaskTreeNode* child);
+    TaskTreeNode* child(int row);
     int childCount() const;
     int row() const;
-    TreeNode* parentNode();
+    TaskTreeNode* parentNode();
 
     TreeNodeType nodeType = TreeNodeType::Root;
     int taskId = -1;           // 任务ID
@@ -35,8 +35,8 @@ public:
     SubTask* subTaskData = nullptr;
 
 private:
-    QVector<TreeNode*> m_children;
-    TreeNode* m_parent;
+    QVector<TaskTreeNode*> m_children;
+    TaskTreeNode* m_parent;
 };
 
 // 树形模型
@@ -101,8 +101,8 @@ private slots:
 private:
     void setupModelData();
     void clearTree();
-    TreeNode* findTaskNode(int taskId) const;
-    TreeNode* findSubTaskNode(int taskId, int subTaskIndex) const;
+    TaskTreeNode* findTaskNode(int taskId) const;
+    TaskTreeNode* findSubTaskNode(int taskId, int subTaskIndex) const;
     int findTaskDataIndex(int taskId) const;
 
     QString statusToString(TaskStatus status) const;
@@ -111,7 +111,7 @@ private:
     QColor statusColor(TaskStatus status) const;
     QString formatCountdown(qint64 seconds) const;
 
-    TreeNode* m_rootNode;
+    TaskTreeNode* m_rootNode;
     QVector<TimedTask> m_tasks;
     QTimer* m_countdownTimer;
 };
diff --git a/HPPA/TimedDataCollection.cpp b/HPPA/TimedDataCollection.cpp
index cb8f9e0..ae4c154 100644
--- a/HPPA/TimedDataCollection.cpp
+++ b/HPPA/TimedDataCollection.cpp
@@ -219,7 +219,7 @@ void TimedDataCollection::onTreeItemClicked(const QModelIndex& index)
 {
     if (!index.isValid()) return;
 
-    TreeNode* node = static_cast<TreeNode*>(index.internalPointer());
+    TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
     if (!node) return;
 
     QString info;
@@ -242,7 +242,7 @@ void TimedDataCollection::onTreeItemDoubleClicked(const QModelIndex& index)
 {
     if (!index.isValid()) return;
 
-    TreeNode* node = static_cast<TreeNode*>(index.internalPointer());
+    TaskTreeNode* node = static_cast<TaskTreeNode*>(index.internalPointer());
     if (!node) return;
 
     if (node->nodeType == TreeNodeType::Task && node->taskData) {