diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index f0be09e62b..20c0f628a9 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -27,6 +27,7 @@ repos:
         additional_dependencies: [ '@commitlint/config-conventional' ]
   #【可选】提升 Python 代码风格，符合更高版本的 Python 语法
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.19.0
+    rev: v3.15.0
     hooks:
     - id: pyupgrade
+    args: [--py38-plus]
diff --git a/app_desc.yaml b/app_desc.yaml
index c095646b84..2bbf6de07f 100644
--- a/app_desc.yaml
+++ b/app_desc.yaml
@@ -1,5 +1,5 @@
 spec_version: 2
-app_version: "1.11.9"
+app_version: "1.11.10"
 app:
   region: default
   bk_app_code: &APP_CODE bk_flow_engine
diff --git a/bkflow/apigw/serializers/task.py b/bkflow/apigw/serializers/task.py
index 7d7b499dbb..1c4d551eef 100644
--- a/bkflow/apigw/serializers/task.py
+++ b/bkflow/apigw/serializers/task.py
@@ -81,6 +81,7 @@ class CreateTaskSerializer(CredentialsValidationMixin, serializers.Serializer):
     custom_span_attributes = serializers.DictField(
         help_text=_("自定义 Span 属性，会添加到所有节点上报的 Span 中"), required=False, default={}
     )
+    label_ids = serializers.ListField(help_text=_("标签ID列表"), child=serializers.IntegerField(), required=False)
 
 
 class CreateTaskByAppSerializer(serializers.Serializer):
diff --git a/bkflow/apigw/serializers/template.py b/bkflow/apigw/serializers/template.py
index 854b7ef0e2..a9d5215f53 100644
--- a/bkflow/apigw/serializers/template.py
+++ b/bkflow/apigw/serializers/template.py
@@ -47,6 +47,7 @@ class CreateTemplateSerializer(serializers.Serializer):
     )
     extra_info = serializers.JSONField(help_text=_("额外扩展信息"), required=False)
     pipeline_tree = serializers.JSONField(help_text=_("任务树"), required=False)
+    label_ids = serializers.ListField(help_text=_("标签"), child=serializers.IntegerField(), required=False)
 
     def validate(self, attrs):
         # 将 bind_app_code 映射到 bk_app_code 字段（models 中的字段名）
diff --git a/bkflow/contrib/api/collections/task.py b/bkflow/contrib/api/collections/task.py
index 4966bad0ea..1e1908ba93 100644
--- a/bkflow/contrib/api/collections/task.py
+++ b/bkflow/contrib/api/collections/task.py
@@ -59,6 +59,25 @@ def _get_task_url(self, api_name):
     def task_list(self, data):
         return self._request(method="get", url=self._get_task_url("task/"), data=data)
 
+    def update_labels(self, task_id, data):
+        return self._request(method="post", url=self._get_task_url("task/{}/update_labels/".format(task_id)), data=data)
+
+    def get_task_label_ref_count(self, space_id, label_ids):
+        return self._request(
+            method="get",
+            url=self._get_task_url(
+                "task/get_task_label_ref_count/?space_id={}&label_ids={}".format(space_id, label_ids)
+            ),
+            data=None,
+        )
+
+    def delete_task_label_relation(self, data):
+        return self._request(
+            method="post",
+            url=self._get_task_url("task/delete_task_label_relation/"),
+            data=data,
+        )
+
     def create_task(self, data):
         return self._request(method="post", url=self._get_task_url("task/"), data=data)
 
diff --git a/bkflow/interface/task/view.py b/bkflow/interface/task/view.py
index 9902eeda06..2d31eb96d6 100644
--- a/bkflow/interface/task/view.py
+++ b/bkflow/interface/task/view.py
@@ -40,6 +40,7 @@
     TaskTokenPermission,
 )
 from bkflow.interface.task.utils import StageConstantHandler, StageJobStateHandler
+from bkflow.label.models import Label
 from bkflow.permission.models import TASK_PERMISSION_TYPE, Token
 from bkflow.space.configs import SuperusersConfig
 from bkflow.space.models import SpaceConfig
@@ -56,7 +57,35 @@ class TaskInterfaceAdminViewSet(GenericViewSet):
     @action(methods=["GET"], detail=False, url_path="get_task_list/(?P<space_id>\\d+)")
     def get_task_list(self, request, space_id):
         client = TaskComponentClient(space_id=space_id)
-        result = client.task_list(data={**request.query_params, "space_id": space_id})
+        # 把标签名称转换为id进行搜索
+        query_params = request.query_params.copy()
+        labels = request.query_params.get("label", "")
+        label_ids = Label.get_label_ids_by_names(labels)
+        if label_ids:
+            query_params["label"] = ",".join([str(label_id) for label_id in label_ids])
+        result = client.task_list(data={**query_params, "space_id": space_id})
+
+        label_ids = []
+        for item in result["data"]["results"]:
+            label_ids.extend(item["labels"])
+
+        labels_map = Label.objects.get_labels_map(set(label_ids))
+
+        for item in result["data"]["results"]:
+            item["labels"] = [labels_map.get(label_id) for label_id in item["labels"]]
+
+        return Response(result)
+
+    @action(methods=["POST"], detail=False, url_path="update_labels/(?P<space_id>\\d+)/(?P<pk>\\d+)")
+    def update_labels(self, request, space_id, pk=None):
+        """
+        更新特定任务（pk指定）的标签列表。
+        请求体期望格式：{"label_ids": [1, 2, 5]}
+        """
+        client = TaskComponentClient(space_id=space_id)
+        result = client.update_labels(pk, data={**request.data, "space_id": space_id})
+        labels_map = Label.objects.get_labels_map(set(result["data"]))
+        result["data"] = [labels_map.get(label_id) for label_id in result["data"]]
         return Response(result)
 
     @swagger_auto_schema(methods=["post"], operation_description="任务状态查询", request_body=GetTasksStatesBodySerializer)
diff --git a/bkflow/label/__init__.py b/bkflow/label/__init__.py
new file mode 100644
index 0000000000..732d2b8d52
--- /dev/null
+++ b/bkflow/label/__init__.py
@@ -0,0 +1,18 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
diff --git a/bkflow/label/admin.py b/bkflow/label/admin.py
new file mode 100644
index 0000000000..e1d6811fc0
--- /dev/null
+++ b/bkflow/label/admin.py
@@ -0,0 +1,70 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from django.contrib import admin
+
+from .models import Label, TemplateLabelRelation
+
+
+@admin.register(Label)
+class LabelAdmin(admin.ModelAdmin):
+    """Admin configuration for Label model."""
+
+    list_display = (
+        "id",
+        "name",
+        "space_id",
+        "parent_label",
+        "is_default",
+        "color",
+        "full_path",
+        "created_at",
+        "updated_at",
+    )
+    list_filter = ("space_id", "is_default")
+    search_fields = ("name", "creator", "updated_by", "description")
+    readonly_fields = ("created_at", "updated_at", "full_path")
+    ordering = ("space_id", "parent_id", "name")
+    list_per_page = 50
+
+    def parent_label(self, obj):
+        """Show parent label name in list_display."""
+        parent = obj.get_parent_label()
+        return parent.name if parent else "-"
+
+    parent_label.short_description = "Parent label"
+
+
+@admin.register(TemplateLabelRelation)
+class TemplateLabelRelationAdmin(admin.ModelAdmin):
+    """Admin for template-label relations."""
+
+    list_display = ("id", "template_id", "label_id", "label_name")
+    list_filter = ("template_id",)
+    search_fields = ("template_id", "label_id")
+    list_per_page = 50
+
+    def label_name(self, obj):
+        """Resolve label name from label_id."""
+        try:
+            label = Label.objects.get(id=obj.label_id)
+            return label.name
+        except Label.DoesNotExist:
+            return "-"
+
+    label_name.short_description = "Label"
diff --git a/bkflow/label/apps.py b/bkflow/label/apps.py
new file mode 100644
index 0000000000..120bb04da7
--- /dev/null
+++ b/bkflow/label/apps.py
@@ -0,0 +1,24 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from django.apps import AppConfig
+
+
+class LabelConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "bkflow.label"
diff --git a/bkflow/label/migrations/0001_initial.py b/bkflow/label/migrations/0001_initial.py
new file mode 100644
index 0000000000..48f2537321
--- /dev/null
+++ b/bkflow/label/migrations/0001_initial.py
@@ -0,0 +1,84 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="TemplateLabelRelation",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("template_id", models.IntegerField(db_index=True, verbose_name="模版ID")),
+                ("label_id", models.IntegerField(db_index=True, verbose_name="标签ID")),
+            ],
+            options={
+                "verbose_name": "模版标签关系 TemplateLabelRelation",
+                "verbose_name_plural": "模版标签关系 TemplateLabelRelation",
+                "unique_together": {("template_id", "label_id")},
+            },
+        ),
+        migrations.CreateModel(
+            name="Label",
+            fields=[
+                ("id", models.BigAutoField(primary_key=True, serialize=False, verbose_name="标签ID")),
+                ("name", models.CharField(db_index=True, help_text="标签名称", max_length=255, verbose_name="标签名称")),
+                ("creator", models.CharField(help_text="标签创建人", max_length=255, verbose_name="创建者")),
+                ("updated_by", models.CharField(help_text="标签更新人", max_length=255, verbose_name="更新者")),
+                (
+                    "space_id",
+                    models.IntegerField(default=-1, help_text="标签对应的空间id（默认标签时space_id=-1）", verbose_name="空间ID"),
+                ),
+                ("is_default", models.BooleanField(default=False, help_text="是否是默认标签", verbose_name="默认标签")),
+                (
+                    "color",
+                    models.CharField(default="#dcffe2", help_text="标签颜色值（如#ffffff）", max_length=7, verbose_name="标签颜色"),
+                ),
+                (
+                    "description",
+                    models.CharField(blank=True, help_text="标签描述", max_length=255, null=True, verbose_name="标签描述"),
+                ),
+                (
+                    "label_scope",
+                    models.JSONField(
+                        default="template", help_text="标签范围（支持多选，如['task', 'common']）", verbose_name="标签范围"
+                    ),
+                ),
+                (
+                    "parent_id",
+                    models.IntegerField(
+                        blank=True, default=None, help_text="父标签ID（根标签填null或留空）", null=True, verbose_name="父标签ID"
+                    ),
+                ),
+                ("created_at", models.DateTimeField(auto_now_add=True, verbose_name="创建时间")),
+                ("updated_at", models.DateTimeField(auto_now=True, verbose_name="更新时间")),
+            ],
+            options={
+                "verbose_name": "用户标签 Label",
+                "verbose_name_plural": "用户标签 Label",
+                "ordering": ["space_id", "parent_id", "name"],
+                "unique_together": {("space_id", "parent_id", "name")},
+            },
+        ),
+    ]
diff --git a/bkflow/label/migrations/__init__.py b/bkflow/label/migrations/__init__.py
new file mode 100644
index 0000000000..732d2b8d52
--- /dev/null
+++ b/bkflow/label/migrations/__init__.py
@@ -0,0 +1,18 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
diff --git a/bkflow/label/models.py b/bkflow/label/models.py
new file mode 100644
index 0000000000..75bd321032
--- /dev/null
+++ b/bkflow/label/models.py
@@ -0,0 +1,296 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+import re
+from collections import defaultdict
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models import Q
+from django.utils.translation import ugettext_lazy as _
+
+
+class LabelManager(models.Manager):
+    """自定义管理器，添加层级相关查询方法"""
+
+    def check_label_ids(self, label_ids):
+        if len(label_ids) != self.filter(id__in=label_ids).count():
+            return False
+        return True
+
+    def get_root_labels(self, space_id=-1, label_scope=None):
+        """获取指定空间、指定范围的根标签（父ID为null或-1）"""
+        filters = {"parent_id__isnull": True, "space_id": space_id}
+        # 兼容可能的-1存储（如果根标签存-1，需调整过滤条件为 parent_id=-1）
+        # filters = Q(parent_id__isnull=True) | Q(parent_id=-1)
+        if label_scope:
+            filters["label_scope__contains"] = label_scope
+        return self.filter(**filters).order_by("name")
+
+    def get_sub_labels(self, parent_id, recursive=False):
+        """
+        获取指定父标签ID的子标签（手动过滤parent_id）
+        :param parent_id: 父标签ID
+        :param recursive: 是否递归查询所有子孙标签
+        :return: QuerySet（非递归）或列表（递归）
+        """
+        if not recursive:
+            # 非递归：直接过滤parent_id等于目标ID
+            return self.filter(parent_id=parent_id).order_by("name")
+
+        # 递归查询：手动遍历子标签，累计所有子孙
+        sub_labels = list(self.filter(parent_id=parent_id).order_by("name"))
+        for label in sub_labels:
+            # 递归查询当前标签的子标签，并入结果
+            sub_labels.extend(self.get_sub_labels(label.id, recursive=True))
+        return sub_labels
+
+    def get_parent_label(self, label_id):
+        """通过标签ID获取其父标签（手动查询parent_id对应的记录）"""
+        try:
+            # 当前标签的parent_id字段存储父标签ID
+            current_label = self.get(id=label_id)
+            if not current_label.parent_id:  # 根标签无父标签
+                return None
+            # 通过parent_id查询父标签记录
+            return self.get(id=current_label.parent_id)
+        except self.model.DoesNotExist:
+            return None
+
+    def get_labels_map(self, label_ids):
+        """通过标签ID获取其完整信息"""
+        labels = Label.objects.filter(id__in=label_ids)
+        labels_map = {}
+        for label in labels:
+            label_dict = {"id": label.id, "name": label.name, "color": label.color, "full_path": label.full_path}
+            labels_map[label.id] = label_dict
+        return labels_map
+
+
+class Label(models.Model):
+    LABEL_SCOPE_CHOICES = (
+        ("task", _("任务")),
+        ("template", _("模板")),
+        ("common", _("通用")),
+    )
+
+    id = models.BigAutoField(_("标签ID"), primary_key=True)
+    name = models.CharField(_("标签名称"), max_length=255, db_index=True, help_text="标签名称")
+    creator = models.CharField(_("创建者"), max_length=255, help_text="标签创建人")
+    updated_by = models.CharField(_("更新者"), max_length=255, help_text="标签更新人")
+    space_id = models.IntegerField(_("空间ID"), default=-1, help_text="标签对应的空间id（默认标签时space_id=-1）")
+    is_default = models.BooleanField(_("默认标签"), default=False, help_text="是否是默认标签")
+    color = models.CharField(_("标签颜色"), max_length=7, default="#dcffe2", help_text="标签颜色值（如#ffffff）")
+    description = models.CharField(_("标签描述"), max_length=255, blank=True, null=True, help_text="标签描述")
+    label_scope = models.JSONField(
+        verbose_name=_("标签范围"), default=["template", "task"], help_text="标签范围（支持多选，如['task', 'common']）"
+    )
+
+    # 核心修改：用IntegerField存储父标签ID，替代外键
+    parent_id = models.IntegerField(_("父标签ID"), null=True, blank=True, default=None, help_text="父标签ID（根标签填null或留空）")
+
+    created_at = models.DateTimeField(_("创建时间"), auto_now_add=True)
+    updated_at = models.DateTimeField(_("更新时间"), auto_now=True)
+
+    objects = LabelManager()
+
+    class Meta:
+        verbose_name = _("用户标签 Label")
+        verbose_name_plural = _("用户标签 Label")
+        # 唯一约束：同一空间、同一父ID下，标签名称不能重复
+        unique_together = ("space_id", "parent_id", "name")
+        ordering = ["space_id", "parent_id", "name"]
+
+    def __str__(self):
+        # 手动查询父标签名称（替代外键的self.parent.name）
+        parent_label = self.get_parent_label()
+        parent_name = parent_label.name if parent_label else "无"
+        return f"标签：{self.name}（父标签：{parent_name}，空间：{self.space_id}）"
+
+    def get_parent_label(self):
+        """获取父标签实例（手动通过parent_id查询）"""
+        if not self.parent_id:
+            return None
+        try:
+            return Label.objects.get(id=self.parent_id)
+        except Label.DoesNotExist:
+            # 父标签已删除（数据不一致），返回None
+            return None
+
+    def clean(self):
+        """数据验证：保持原有约束，适配手动关联"""
+        # 1. 子标签的space_id必须与父标签一致（如果有父标签）
+        if self.parent_id:
+            parent_label = self.get_parent_label()
+            if not parent_label:
+                raise ValidationError(_("父标签不存在（父ID：{}）".format(self.parent_id)))
+            if self.space_id != parent_label.space_id:
+                raise ValidationError(_("子标签的空间ID必须与父标签一致"))
+        # 2. 禁止循环引用（如A→B→C→A）
+        if self.parent_id:
+            current_parent_id = self.parent_id
+            # 遍历所有祖先标签，检查是否包含自身ID
+            while current_parent_id:
+                if current_parent_id == self.id:
+                    raise ValidationError(_("禁止循环引用：标签不能作为自身的祖先"))
+                # 手动获取上一级父标签ID
+                try:
+                    ancestor = Label.objects.get(id=current_parent_id)
+                    current_parent_id = ancestor.parent_id
+                except Label.DoesNotExist:
+                    break  # 父标签不存在，终止检查
+
+    def save(self, *args, **kwargs):
+        """保存前执行验证"""
+        self.clean()
+        super().save(*args, **kwargs)
+
+    @staticmethod
+    def get_label_ids_by_names(names):
+        """通过标签名称列表获取对应的标签ID列表"""
+        labels = [s.strip() for s in re.split(r"[,\s]+", names) if s.strip()]
+
+        label_ids = []
+        if labels:
+            q_objects = Q()
+            for keyword in labels:
+                q_objects |= Q(name__icontains=keyword)
+            label_ids = list(Label.objects.filter(q_objects).values_list("id", flat=True))
+
+        return label_ids
+
+    @property
+    def full_path(self):
+        """获取标签完整路径（手动递归查询父标签）"""
+        path = [self.name]
+        current_parent = self.get_parent_label()
+        while current_parent:
+            path.insert(0, current_parent.name)
+            # 继续查询上一级父标签
+            current_parent = current_parent.get_parent_label()
+        return "/".join(path)
+
+    def is_root(self):
+        """判断是否为根标签（parent_id为null或无对应父标签）"""
+        return not self.parent_id or not self.get_parent_label()
+
+    def get_all_children(self, recursive=True):
+        """获取所有子标签（手动过滤parent_id）"""
+        return Label.objects.get_sub_labels(parent_id=self.id, recursive=recursive)
+
+
+class BaseLabelRelationManager(models.Manager):
+    """
+    通用的标签关系管理器
+    核心思想：将变化的字段名 (task_id/template_id) 抽象为 self.fk_field
+    """
+
+    def __init__(self, fk_field):
+        super().__init__()
+        self.fk_field = fk_field
+
+    def set_labels(self, obj_id, label_ids):
+        """
+        设置对象的标签（增量更新）
+        """
+        # 1. 构造查询参数，例如: {"template_id": 1} 或 {"task_id": 1}
+        filter_kwargs = {self.fk_field: obj_id}
+
+        # 2. 获取已有标签
+        existing_labels = self.filter(**filter_kwargs).values_list("label_id", flat=True)
+
+        # 3. 计算差异
+        existing_set = set(existing_labels)
+        new_set = set(label_ids)
+
+        add_ids = list(new_set - existing_set)
+        remove_ids = list(existing_set - new_set)
+
+        # 4. 执行删除
+        if remove_ids:
+            # 构造删除查询: template_id=1, label_id__in=[...]
+            delete_kwargs = {self.fk_field: obj_id, "label_id__in": remove_ids}
+            self.filter(**delete_kwargs).delete()
+
+        # 5. 执行批量添加
+        if add_ids:
+            # 动态创建模型实例: TaskLabelRelation(task_id=1, label_id=xx)
+            new_relations = [self.model(**{self.fk_field: obj_id, "label_id": label_id}) for label_id in add_ids]
+            self.bulk_create(new_relations)
+
+    def fetch_labels(self, obj_id):
+        """
+        获取单个对象的标签列表
+        """
+        filter_kwargs = {self.fk_field: obj_id}
+        label_ids = self.filter(**filter_kwargs).distinct().values_list("label_id", flat=True)
+        labels = Label.objects.filter(id__in=label_ids)
+        labels_list_of_dicts = []
+
+        for label in labels:
+            label_dict = {
+                "id": label.id,
+                "name": label.name,
+                "color": label.color,
+            }
+            label_dict["full_path"] = label.full_path
+            labels_list_of_dicts.append(label_dict)
+
+        return labels_list_of_dicts
+
+    def fetch_objects_labels(self, obj_ids, label_fields=("name", "color")):
+        """
+        批量获取多个对象的标签字典
+        返回格式: {obj_id: [label_dict, ...]}
+        """
+        # 1. 构造 __in 查询，例如 template_id__in=[1,2,3]
+        filter_kwargs = {f"{self.fk_field}__in": obj_ids}
+        # 2. 获取所有关系
+        relations = self.filter(**filter_kwargs).values(self.fk_field, "label_id")
+        if not relations:
+            return {}
+        # 3. 提取标签详情
+        label_ids = {rel["label_id"] for rel in relations}
+        labels_map = {
+            label.id: {
+                "id": label.id,
+                **{field: getattr(label, field) for field in label_fields},
+                "full_path": label.full_path,
+            }
+            for label in Label.objects.filter(id__in=label_ids)
+        }
+        # 4. 组装结果
+        result = defaultdict(list)
+        for rel in relations:
+            oid = rel[self.fk_field]
+            lid = rel["label_id"]
+            if lid in labels_map:
+                result[oid].append(labels_map[lid])
+        return dict(result)
+
+
+class TemplateLabelRelation(models.Model):
+    template_id = models.IntegerField(_("模版ID"), db_index=True)
+    label_id = models.IntegerField(_("标签ID"), db_index=True)
+
+    objects = BaseLabelRelationManager(fk_field="template_id")
+
+    class Meta:
+        verbose_name = _("模版标签关系 TemplateLabelRelation")
+        verbose_name_plural = _("模版标签关系 TemplateLabelRelation")
+        unique_together = ("template_id", "label_id")
diff --git a/bkflow/label/permissions.py b/bkflow/label/permissions.py
new file mode 100644
index 0000000000..1aadf0e1e0
--- /dev/null
+++ b/bkflow/label/permissions.py
@@ -0,0 +1,33 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from bkflow.permission.permissions import BaseTokenPermission
+
+
+class LabelPermission(BaseTokenPermission):
+    def get_resource_type(self):
+        return "LABEL"
+
+    def has_object_permission(self, request, view, obj):
+        has_edit_permission = self.has_edit_permission(request.user.username, obj.space_id, obj.id, request.token)
+
+        if view.action in view.EDIT_ABOVE_ACTIONS:
+            return has_edit_permission
+
+        has_view_permission = self.has_view_permission(request.user.username, obj.space_id, obj.id, request.token)
+        return has_view_permission or has_edit_permission
diff --git a/bkflow/label/serializers.py b/bkflow/label/serializers.py
new file mode 100644
index 0000000000..ec41ede8f3
--- /dev/null
+++ b/bkflow/label/serializers.py
@@ -0,0 +1,164 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+import re
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from .models import Label
+
+
+class LabelSerializer(serializers.ModelSerializer):
+    """标签序列化器"""
+
+    label_scope = serializers.ListField(
+        child=serializers.ChoiceField(
+            choices=Label.LABEL_SCOPE_CHOICES,
+            allow_blank=False,
+        ),
+        min_length=1,
+        required=True,
+    )
+    has_children = serializers.BooleanField(read_only=True, help_text="是否有子标签")
+    full_path = serializers.ReadOnlyField()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # 检查是否是创建场景 (instance 为 None)
+        if self.instance is None:
+            # 1. 必填字段设置
+            required_fields = ["name", "space_id", "color", "label_scope"]
+            for field_name in required_fields:
+                if field_name in self.fields:
+                    self.fields[field_name].required = True
+
+            # 2. 可选字段设置
+            optional_fields = ["description", "parent_id"]
+            for field_name in optional_fields:
+                if field_name in self.fields:
+                    field = self.fields[field_name]
+                    field.required = False
+                    field.allow_null = True
+
+                    # 只有字符串类型的字段才设置 allow_blank
+                    if isinstance(field, (serializers.CharField)):
+                        field.allow_blank = True
+
+    class Meta:
+        model = Label
+        fields = [
+            "id",
+            "name",
+            "creator",
+            "updated_by",
+            "space_id",
+            "color",
+            "description",
+            "created_at",
+            "updated_at",
+            "label_scope",
+            "is_default",
+            "has_children",
+            "full_path",
+            "parent_id",
+        ]
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "is_default",
+            "creator",
+            "updated_by",
+            "has_children",
+            "full_path",
+        ]
+
+    def validate_color(self, value):
+        if not re.match(r"^#([0-9A-Fa-f]{6})$", value):
+            raise serializers.ValidationError(_("颜色格式错误"))
+        return value
+
+    def validate_name(self, value):
+        """验证标签名称非空且去重（结合 space_id）"""
+        value = value.strip()
+        if not value:
+            raise serializers.ValidationError(_("标签名称不能为空"))
+        # 新增时：检查同一 space_id 下名称是否重复
+        if self.instance is None:
+            space_id = self.initial_data.get("space_id", -1)
+            if Label.objects.filter(
+                space_id=space_id, name=value, parent_id=self.initial_data.get("parent_id", None)
+            ).exists():
+                raise serializers.ValidationError(_(f"该空间下已存在名称为「{value}」的标签"))
+        # 修改时：排除自身，检查同一 space_id 下名称是否重复
+        else:
+            space_id = self.initial_data.get("space_id", self.instance.space_id)
+            if (
+                Label.objects.filter(space_id=space_id, name=value, parent_id=self.initial_data.get("parent_id", None))
+                .exclude(id=self.instance.id)
+                .exists()
+            ):
+                raise serializers.ValidationError(_(f"该空间下已存在名称为「{value}」的标签"))
+        return value
+
+    def validate_label_scope(self, value):
+        """验证标签范围非空且去重"""
+        parent_id = self.initial_data.get("parent_id", None)
+        if parent_id:
+            # 有父标签时，标签范围必须与父标签一致
+            try:
+                parent_label = Label.objects.get(id=parent_id)
+            except Label.DoesNotExist:
+                raise serializers.ValidationError(_("父标签不存在"))
+            if not set(value).issubset(set(parent_label.label_scope)):
+                raise serializers.ValidationError(_("子标签的范围必须是父标签的子集"))
+        return value
+
+
+class LabelRefSerializer(serializers.Serializer):
+    """标签引用序列化器"""
+
+    space_id = serializers.IntegerField(required=True, help_text="空间ID")
+    label_ids = serializers.CharField(required=True, help_text="标签ID")
+
+    def validate_label_ids(self, value):
+        """
+        字段级验证：验证 label_ids 格式（仅允许数字和逗号，或列表/元组类型的数字）
+        """
+        # 处理列表/元组类型的入参（如果前端传的是列表）
+        if isinstance(value, (list, tuple)):
+            # 先验证列表中的每个元素都是数字
+            for item in value:
+                if not isinstance(item, (int, str)) or (isinstance(item, str) and not item.isdigit()):
+                    raise serializers.ValidationError("label_ids 列表中仅允许包含数字")
+            label_ids_str = ",".join(map(str, value))
+        else:
+            # 处理字符串类型的入参
+            label_ids_str = str(value).strip()  # 去除首尾空格
+
+        # 正则验证：仅包含数字和逗号，且不以逗号开头/结尾，也不是空字符串
+        if not label_ids_str:
+            raise serializers.ValidationError("label_ids 不能为空")
+        if not re.match(r"^[\d,]+$", label_ids_str) or label_ids_str.startswith(",") or label_ids_str.endswith(","):
+            raise serializers.ValidationError("label_ids 格式非法，仅允许数字和逗号（如 1,2,3）")
+
+        # 可选：去重 + 排序，保证格式统一
+        label_ids_list = list(set(label_ids_str.split(",")))
+        label_ids_list.sort()
+        return ",".join(label_ids_list)
diff --git a/bkflow/label/tests.py b/bkflow/label/tests.py
new file mode 100644
index 0000000000..6d73b95e17
--- /dev/null
+++ b/bkflow/label/tests.py
@@ -0,0 +1,19 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+# Create your tests here.
diff --git a/bkflow/label/urls.py b/bkflow/label/urls.py
new file mode 100644
index 0000000000..0b4b9a22ec
--- /dev/null
+++ b/bkflow/label/urls.py
@@ -0,0 +1,29 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from django.conf.urls import include, url
+from rest_framework.routers import DefaultRouter
+
+from .views import LabelViewSet
+
+router = DefaultRouter()
+router.register(r"", LabelViewSet)
+
+urlpatterns = [
+    url("^", include(router.urls)),
+]
diff --git a/bkflow/label/views.py b/bkflow/label/views.py
new file mode 100644
index 0000000000..5bb00234dd
--- /dev/null
+++ b/bkflow/label/views.py
@@ -0,0 +1,216 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+import django_filters
+from django.db.models import Count, Exists, OuterRef, Q
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework import filters, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from bkflow.contrib.api.collections.task import TaskComponentClient
+from bkflow.label.models import TemplateLabelRelation
+from bkflow.label.permissions import LabelPermission
+from bkflow.space.permissions import SpaceSuperuserPermission
+from bkflow.utils.mixins import BKFLOWNoMaxLimitPagination
+from bkflow.utils.permissions import AdminPermission
+from bkflow.utils.views import AdminModelViewSet
+
+from .models import Label
+from .serializers import LabelRefSerializer, LabelSerializer
+
+
+class LabelFilter(django_filters.FilterSet):
+    """标签过滤集：指定必须过滤字段"""
+
+    space_id = django_filters.NumberFilter(required=True, method="filter_space_id")
+    label_scope = django_filters.CharFilter(method="filter_label_scope")
+    parent_id = django_filters.NumberFilter(method="filter_parent_id")
+    name = django_filters.CharFilter(method="filter_name")
+    is_default = django_filters.BooleanFilter(method="filter_is_default")
+
+    class Meta:
+        model = Label
+        fields = ["space_id", "label_scope", "parent_id", "name", "is_default"]
+
+    def filter_space_id(self, queryset, name, value):
+        return queryset.filter(space_id__in=[-1, value])
+
+    def filter_label_scope(self, queryset, name, value):
+        return queryset.filter(Q(label_scope__contains=[value]) | Q(label_scope__contains=["common"]))
+
+    def filter_parent_id(self, queryset, name, value):
+        return queryset.filter(parent_id=value)
+
+    def filter_name(self, queryset, name, value):
+        return queryset.filter(name__icontains=value)
+
+    def filter_is_default(self, queryset, name, value):
+        return queryset.filter(is_default=value)
+
+    def filter_queryset(self, queryset):
+        """
+        重写父类方法，处理默认值逻辑 + 搜索兼容
+        """
+        queryset = super().filter_queryset(queryset)
+
+        params = self.data
+
+        has_parent_id = "parent_id" in params
+
+        if not has_parent_id:
+            # 过滤出根标签
+            root_label_ids = []
+            for label in queryset:
+                if label.parent_id is None:
+                    root_label_ids.append(label.id)
+                else:
+                    root_label_ids.append(label.parent_id)
+            return self.Meta.model.objects.filter(id__in=root_label_ids)
+
+        return queryset
+
+
+class LabelViewSet(AdminModelViewSet):
+    """
+    标签管理 ViewSet
+    """
+
+    swagger_tags = ["label"]
+    queryset = Label.objects.all().order_by("-updated_at")
+    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
+    search_fields = ["name", "description"]
+    ordering_fields = ["created_at", "updated_at", "name"]
+    serializer_class = LabelSerializer
+    pagination_class = BKFLOWNoMaxLimitPagination
+    EDIT_ABOVE_ACTIONS = ["create", "update", "partial_update", "destroy"]
+    permission_classes = [AdminPermission | SpaceSuperuserPermission | LabelPermission]
+
+    def get_filterset_class(self):
+        if self.action in ["list", "retrieve"]:
+            return LabelFilter
+        return None
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+        child_subquery = Label.objects.filter(parent_id=OuterRef("pk"))
+
+        filterset_class = self.get_filterset_class()
+        if filterset_class:
+            filterset = filterset_class(self.request.query_params, queryset=queryset, request=self.request)
+            if not filterset.is_valid():
+                return queryset.none()
+            queryset = filterset.qs
+
+        queryset = queryset.annotate(has_children=Exists(child_subquery))
+        return queryset
+
+    def create(self, request, *args, **kwargs):
+        """
+        覆盖 create 方法：
+        1. 如果 name 是 '一级/二级' 格式，则查找或自动创建 '一级' 标签。
+        2. 将 '二级' 标签关联到其父级 ID 下。
+        """
+        data = request.data.copy()
+        name_parts = data.get("name", "").split("/")
+
+        if len(name_parts) == 2:
+            parent_name = name_parts[0].strip()  # 一级标签名称
+            child_name = name_parts[1].strip()  # 二级标签名称
+
+            parent_label_pk = None
+
+            try:
+                # 尝试查找已存在的父标签 (一级标签，parent_id为空)
+                parent_label = Label.objects.get(
+                    name=parent_name, space_id=data.get("space_id"), parent_id__isnull=True
+                )
+                parent_label_pk = parent_label.pk
+            except Label.DoesNotExist:
+                # 如果一级标签不存在，则自动创建
+                data["name"] = parent_name
+                parent_serializer = self.get_serializer(data=data)
+                # 校验并保存一级标签
+                parent_serializer.is_valid(raise_exception=True)
+                parent_instance = parent_serializer.save()
+                parent_label_pk = parent_instance.pk
+
+            # 填充 parent_id 并修正 name 字段 (用于创建二级标签)
+            data["parent_id"] = parent_label_pk
+            data["name"] = child_name
+
+        # 创建一级/二级标签
+        serializer = self.get_serializer(data=data)
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+        headers = self.get_success_headers(serializer.data)
+        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
+
+    def destroy(self, request, *args, **kwargs):
+        """删除标签，级联删除子标签"""
+        instance = self.get_object()
+
+        need_delete_label_ids = [instance.pk]
+        # 如果是一级标签，删除所有子标签
+        if instance.parent_id is None:
+            sub_label_ids = Label.objects.filter(parent_id=instance.pk).values_list("id", flat=True)
+            need_delete_label_ids.extend(sub_label_ids)
+
+        # 删除任务标签关系通过任务组件接口完成，此处不做处理
+        client = TaskComponentClient(space_id=instance.space_id)
+        result = client.delete_task_label_relation({"label_ids": need_delete_label_ids})
+        if not result["result"]:
+            return Response(result, status=status.HTTP_400_BAD_REQUEST)
+
+        # 删除模板标签关系
+        TemplateLabelRelation.objects.filter(label_id__in=need_delete_label_ids).delete()
+
+        Label.objects.filter(id__in=need_delete_label_ids).delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @action(detail=False, methods=["get"], serializer_class=LabelRefSerializer)
+    def get_label_ref_count(self, request, *args, **kwargs):
+        """获取标签引用数量"""
+        ser = LabelRefSerializer(data=request.query_params)
+        ser.is_valid(raise_exception=True)
+        validated_params = ser.validated_data
+
+        # 调用任务组件接口获取任务引用数量
+        client = TaskComponentClient(space_id=validated_params["space_id"])
+        result = client.get_task_label_ref_count(validated_params["space_id"], validated_params["label_ids"])
+        if not result["result"]:
+            return Response(result)
+        label_task_ref_count_map = result["data"]
+
+        # 获取模板引用数量
+        label_ids = validated_params["label_ids"].split(",")
+        aggregation_qs = (
+            TemplateLabelRelation.objects.filter(label_id__in=label_ids).values("label_id").annotate(count=Count("id"))
+        )
+        label_template_count_map = {item["label_id"]: item["count"] for item in aggregation_qs}
+
+        # 合并结果
+        ref_result = {}
+        for label_id in label_ids:
+            ref_result[label_id] = {
+                "template_count": label_template_count_map.get(int(label_id), 0),
+                "task_count": label_task_ref_count_map.get(label_id, 0),
+            }
+
+        return Response(ref_result)
diff --git a/bkflow/permission/models.py b/bkflow/permission/models.py
index 32ef89ad42..95bce876ee 100644
--- a/bkflow/permission/models.py
+++ b/bkflow/permission/models.py
@@ -42,6 +42,8 @@ class ResourceType(Enum):
     TEMPLATE = "TEMPLATE"
     # 作用域
     SCOPE = "SCOPE"
+    # 标签
+    LABEL = "LABEL"
 
 
 class PermissionType(Enum):
@@ -85,6 +87,7 @@ class Token(models.Model):
         (ResourceType.TASK.value, _("任务")),
         (ResourceType.TEMPLATE.value, _("流程")),
         (ResourceType.SCOPE.value, _("作用域")),
+        (ResourceType.LABEL.value, _("标签")),
     )
 
     PERMISSION_TYPE = (
diff --git a/bkflow/task/migrations/0015_auto_20251204_1656.py b/bkflow/task/migrations/0015_auto_20251204_1656.py
new file mode 100644
index 0000000000..5a339fc328
--- /dev/null
+++ b/bkflow/task/migrations/0015_auto_20251204_1656.py
@@ -0,0 +1,46 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("task", "0014_taskflowrelation"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="tasktreeinfo",
+            options={"ordering": ["-id"], "verbose_name": "任务流程树信息", "verbose_name_plural": "任务流程树信息"},
+        ),
+        migrations.CreateModel(
+            name="TaskLabelRelation",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("task_id", models.IntegerField(db_index=True, verbose_name="任务ID")),
+                ("label_id", models.IntegerField(db_index=True, verbose_name="标签ID")),
+            ],
+            options={
+                "verbose_name": "任务标签关系 TaskLabelRelation",
+                "verbose_name_plural": "任务标签关系 TaskLabelRelation",
+                "unique_together": {("task_id", "label_id")},
+            },
+        ),
+    ]
diff --git a/bkflow/task/models.py b/bkflow/task/models.py
index 61f4c41d17..92dd5f779e 100644
--- a/bkflow/task/models.py
+++ b/bkflow/task/models.py
@@ -16,6 +16,7 @@
 
 to the current version of the project delivered to anyone in the future.
 """
+from collections import defaultdict
 import json
 import logging
 
@@ -600,3 +601,73 @@ class TaskFlowRelation(models.Model):
 
     class Meta:
         verbose_name = verbose_name_plural = _("任务关系")
+
+
+class BaseLabelRelationManager(models.Manager):
+    """
+    标签关系管理器
+    """
+
+    def set_labels(self, obj_id, label_ids):
+        """
+        设置对象的标签（增量更新）
+        """
+        # 1. 构造查询参数，例如: {"template_id": 1} 或 {"task_id": 1}
+        filter_kwargs = {"task_id": obj_id}
+
+        # 2. 获取已有标签
+        existing_labels = self.filter(**filter_kwargs).values_list("label_id", flat=True)
+
+        # 3. 计算差异
+        existing_set = set(existing_labels)
+        new_set = set(label_ids)
+
+        add_ids = list(new_set - existing_set)
+        remove_ids = list(existing_set - new_set)
+
+        # 4. 执行删除
+        if remove_ids:
+            # 构造删除查询: template_id=1, label_id__in=[...]
+            delete_kwargs = {
+                "task_id": obj_id,
+                "label_id__in": remove_ids
+            }
+            self.filter(**delete_kwargs).delete()
+
+        # 5. 执行批量添加
+        if add_ids:
+            # 动态创建模型实例: TaskLabelRelation(task_id=1, label_id=xx)
+            new_relations = [
+                self.model(**{"task_id": obj_id, "label_id": label_id})
+                for label_id in add_ids
+            ]
+            self.bulk_create(new_relations)
+
+    def fetch_tasks_labels(self, task_ids):
+        """
+        批量获取多个对象的标签字典
+        返回格式: {obj_id: [label_dict, ...]}
+        """
+        filter_kwargs = {"task_id__in": task_ids}
+        relations = self.filter(**filter_kwargs).values("task_id", "label_id")
+
+        if not relations:
+            return {}
+
+        result = defaultdict(list)
+        for rel in relations:
+            result[rel["task_id"]].append(rel["label_id"])
+
+        return dict(result)
+
+
+class TaskLabelRelation(models.Model):
+    task_id = models.BigIntegerField(verbose_name=_("任务ID"), db_index=True)
+    label_id = models.IntegerField(verbose_name=_("标签ID"), db_index=True)
+
+    objects = BaseLabelRelationManager()
+
+    class Meta:
+        verbose_name = _("任务标签关系 TaskLabelRelation")
+        verbose_name_plural = _("任务标签关系 TaskLabelRelation")
+        unique_together = ("task_id", "label_id")
diff --git a/bkflow/task/serializers.py b/bkflow/task/serializers.py
index ea72778e5d..7301da2463 100644
--- a/bkflow/task/serializers.py
+++ b/bkflow/task/serializers.py
@@ -68,6 +68,7 @@ class CreateTaskInstanceSerializer(serializers.ModelSerializer):
     pipeline_tree = serializers.JSONField(required=True)
     constants = serializers.JSONField(required=False, default={})
     mock_data = serializers.JSONField(required=False, default={})
+    label_ids = serializers.ListField(required=False, child=serializers.IntegerField())
 
     def validate(self, value):
         if value.get("extra_info", {}).get("notify_config") is not None:
@@ -112,6 +113,7 @@ class Meta:
             "scope_value",
             "constants",
             "extra_info",
+            "label_ids",
         ]
 
 
@@ -288,3 +290,12 @@ def validate_cron(self, cron_data):
 
 class BatchDeletePeriodicTaskSerializer(serializers.Serializer):
     trigger_ids = serializers.ListField(child=serializers.IntegerField(), help_text="触发器ID列表", required=True)
+
+
+class LabelRefSerializer(serializers.Serializer):
+    label_ids = serializers.CharField(help_text="标签ID", required=True)
+    space_id = serializers.IntegerField(help_text="空间ID", required=True)
+
+
+class DeleteTaskLabelRelationSerializer(serializers.Serializer):
+    label_ids = serializers.ListField(child=serializers.IntegerField(), help_text="标签ID", required=True)
diff --git a/bkflow/task/views.py b/bkflow/task/views.py
index 42232af140..6c0cac8251 100644
--- a/bkflow/task/views.py
+++ b/bkflow/task/views.py
@@ -20,8 +20,9 @@
 
 from blueapps.account.decorators import login_exempt
 from django.conf import settings
+from django.db.models import Count, Subquery
 from django.utils.decorators import method_decorator
-from django_filters import FilterSet
+from django_filters import CharFilter, FilterSet
 from django_filters.rest_framework import DjangoFilterBackend
 from drf_yasg.utils import swagger_auto_schema
 from rest_framework import mixins, status
@@ -48,6 +49,7 @@
     EngineSpaceConfigValueType,
     PeriodicTask,
     TaskInstance,
+    TaskLabelRelation,
     TaskMockData,
     TaskOperationRecord,
 )
@@ -57,9 +59,11 @@
     BatchDeletePeriodicTaskSerializer,
     CreatePeriodicTaskSerializer,
     CreateTaskInstanceSerializer,
+    DeleteTaskLabelRelationSerializer,
     EngineSpaceConfigSerializer,
     GetEngineSpaceConfigSerializer,
     GetTaskOperationRecordSerializer,
+    LabelRefSerializer,
     NodeSnapshotQuerySerializer,
     NodeSnapshotResponseSerializer,
     PeriodicTaskSerializer,
@@ -76,6 +80,8 @@
 
 
 class TaskInstanceFilterSet(FilterSet):
+    label = CharFilter(method="filter_by_labels")
+
     class Meta:
         model = TaskInstance
         fields = {
@@ -96,6 +102,23 @@ class Meta:
             "is_finished": ["exact"],
         }
 
+    def filter_by_labels(self, queryset, name, value):
+        """
+        根据逗号分隔的 label_id 字符串过滤任务。
+        URL Query Param 示例: ?label=1,2,3
+        """
+        try:
+            label_ids = [int(lid) for lid in value.split(",")]
+        except ValueError:
+            return queryset.none()
+
+        if not label_ids:
+            return queryset
+
+        task_ids_subquery = TaskLabelRelation.objects.filter(label_id__in=label_ids).values("task_id")
+
+        return queryset.filter(id__in=Subquery(task_ids_subquery))
+
 
 def validate_task_info(func):
     @wraps(func)
@@ -148,11 +171,60 @@ def get_serializer_class(self):
             return RetrieveTaskInstanceSerializer
         return super().get_serializer_class()
 
+    def list(self, request, *args, **kwargs):
+        queryset = self.filter_queryset(self.get_queryset())
+
+        page = self.paginate_queryset(queryset)
+
+        serializer = self.get_serializer(page, many=True)
+        task_ids = [task["id"] for task in serializer.data]
+        tasks_labels = TaskLabelRelation.objects.fetch_tasks_labels(task_ids)
+        for task in serializer.data:
+            task["labels"] = tasks_labels.get(task["id"], [])
+
+        return self.get_paginated_response(serializer.data)
+
+    @action(detail=True, methods=["post"], url_path="update_labels")
+    def update_labels(self, request, *args, **kwargs):
+        task_instance = self.get_object()
+        label_ids = request.data.get("label_ids", [])
+        TaskLabelRelation.objects.set_labels(task_instance.id, label_ids)
+        return Response(label_ids)
+
+    @action(detail=False, methods=["get"], serializer_class=LabelRefSerializer)
+    def get_task_label_ref_count(self, request, *args, **kwargs):
+        """获取标签引用数量"""
+        ser = LabelRefSerializer(data=request.query_params)
+        ser.is_valid(raise_exception=True)
+        validated_params = ser.validated_data
+        label_ids = validated_params["label_ids"].split(",")
+        queryset = (
+            TaskLabelRelation.objects.filter(label_id__in=label_ids).values("label_id").annotate(count=Count("id"))
+        )
+        label_template_count_map = {item["label_id"]: item["count"] for item in queryset}
+        result = {}
+        for label_id in label_ids:
+            result[label_id] = label_template_count_map.get(int(label_id), 0)
+
+        return Response(result)
+
+    @action(detail=False, methods=["post"], serializer_class=DeleteTaskLabelRelationSerializer)
+    def delete_task_label_relation(self, request, *args, **kwargs):
+        """删除任务标签关联"""
+        ser = DeleteTaskLabelRelationSerializer(data=request.data)
+        ser.is_valid(raise_exception=True)
+        validated_params = ser.validated_data
+        label_ids = validated_params["label_ids"]
+        TaskLabelRelation.objects.filter(label_id__in=label_ids).delete()
+        return Response({"label_ids": label_ids})
+
     @record_operation(RecordType.task.name, TaskOperationType.create.name, TaskOperationSource.api.name)
     def create(self, request, *args, **kwargs):
         serializer = self.get_serializer(data=request.data)
         serializer.is_valid(raise_exception=True)
+        label_ids = serializer.validated_data.pop("label_ids", [])
         instance = TaskInstance.objects.create_instance(**serializer.validated_data)
+        TaskLabelRelation.objects.set_labels(instance.id, label_ids)
         new_serializer = TaskInstanceSerializer(instance)
         headers = self.get_success_headers(new_serializer.data)
         response_data = new_serializer.data
@@ -176,6 +248,7 @@ def batch_delete(self, request, *args, **kwargs):
         else:
             task_ids = serializer.validated_data["task_ids"]
             TaskInstance.objects.filter(space_id=space_id, id__in=task_ids, is_deleted=False).update(is_deleted=True)
+            TaskLabelRelation.objects.filter(task_id__in=task_ids).delete()
         return Response({"result": True, "data": None, "message": "success"})
 
     @swagger_auto_schema(methods=["post"], operation_description="任务操作", request_body=EmptyBodySerializer)
diff --git a/bkflow/template/serializers/template.py b/bkflow/template/serializers/template.py
index 45f240db63..7ba0622cb0 100644
--- a/bkflow/template/serializers/template.py
+++ b/bkflow/template/serializers/template.py
@@ -35,6 +35,7 @@
     WebhookEventType,
     WebhookScopeType,
 )
+from bkflow.label.models import Label, TemplateLabelRelation
 from bkflow.permission.models import TEMPLATE_PERMISSION_TYPE, Token
 from bkflow.pipeline_web.preview_base import PipelineTemplateWebPreviewer
 from bkflow.space.configs import FlowVersioning, TemplateTriggerConfig
@@ -95,6 +96,7 @@ class TemplateSerializer(serializers.ModelSerializer):
     desc = serializers.CharField(help_text=_("流程说明"), required=False, allow_blank=True, allow_null=True)
     triggers = TriggerSerializer(many=True, required=True, allow_null=True)
     subprocess_info = serializers.JSONField(help_text=_("子流程信息"), read_only=True)
+    labels = serializers.CharField(help_text=_("模板标签"), required=False, allow_blank=True, allow_null=True)
 
     def validate_space_id(self, space_id):
         if not Space.objects.filter(id=space_id).exists():
@@ -163,10 +165,26 @@ def create(self, validated_data):
         )
         return template
 
+    def _sync_template_lables(self, template_id, label_ids):
+        """
+        创建或更新模板时同步模板标签数据
+        """
+        label_ids = list(set(label_ids))
+        if not Label.objects.check_label_ids(label_ids):
+            message = _("流程保存失败: 流程设置的标签不存在, 请检查配置后重试")
+            logger.error(message)
+            raise serializers.ValidationError(message)
+        try:
+            TemplateLabelRelation.objects.set_labels(template_id, label_ids)
+        except Exception as e:
+            logger.error("TemplateLabelRelation set_labels error: {}".format(e))
+            raise serializers.ValidationError(_("流程保存失败: 标签设置失败, 请检查配置后重试"))
+
     @transaction.atomic()
     def update(self, instance, validated_data):
         # TODO: 需要校验哪些字段是不可以更新的
         pipeline_tree = validated_data.pop("pipeline_tree", None)
+        template_labels = validated_data.pop("labels", [])
         # 检查新建任务的流程中是否有未二次授权的蓝鲸插件
         try:
             exist_code_list = [
@@ -192,6 +210,7 @@ def update(self, instance, validated_data):
             snapshot.template_id = instance.id
             snapshot.save(update_fields=["template_id"])
         instance = super().update(instance, validated_data)
+        self._sync_template_lables(instance.id, template_labels)
         # 批量修改流程绑定的触发器:
         try:
             Trigger.objects.compare_constants(
@@ -362,3 +381,7 @@ class Meta:
             "operator",
             "md5sum",
         ]
+
+
+class TemplateUpdateLabelSerializer(serializers.Serializer):
+    label_ids = serializers.ListField(help_text=_("标签ID列表"), required=True, child=serializers.IntegerField())
diff --git a/bkflow/template/views/template.py b/bkflow/template/views/template.py
index b81667da35..fec7df38fc 100644
--- a/bkflow/template/views/template.py
+++ b/bkflow/template/views/template.py
@@ -22,9 +22,10 @@
 import django_filters
 from blueapps.account.decorators import login_exempt
 from django.db import transaction
+from django.db.models import Subquery
 from django.utils.decorators import method_decorator
 from django.utils.translation import ugettext_lazy as _
-from django_filters.rest_framework import DjangoFilterBackend, FilterSet
+from django_filters.rest_framework import CharFilter, DjangoFilterBackend, FilterSet
 from drf_yasg.utils import swagger_auto_schema
 from rest_framework import mixins
 from rest_framework.decorators import action
@@ -49,6 +50,7 @@
 from bkflow.contrib.operation_record.decorators import record_operation
 from bkflow.decision_table.models import DecisionTable
 from bkflow.exceptions import APIResponseError, ValidationError
+from bkflow.label.models import Label, TemplateLabelRelation
 from bkflow.pipeline_web.drawing_new.constants import CANVAS_WIDTH, POSITION
 from bkflow.pipeline_web.drawing_new.drawing import draw_pipeline as draw_pipeline_tree
 from bkflow.pipeline_web.preview import preview_template_tree
@@ -96,6 +98,7 @@
     TemplateReleaseSerializer,
     TemplateSerializer,
     TemplateSnapshotSerializer,
+    TemplateUpdateLabelSerializer,
 )
 from bkflow.template.utils import analysis_pipeline_constants_ref
 from bkflow.utils.mixins import BKFLOWCommonMixin, BKFLOWNoMaxLimitPagination
@@ -108,6 +111,8 @@
 
 
 class TemplateFilterSet(FilterSet):
+    label = CharFilter(method="filter_by_labels")
+
     class Meta:
         model = Template
         fields = {
@@ -123,6 +128,20 @@ class Meta:
             "update_at": ["gte", "lte"],
         }
 
+    def filter_by_labels(self, queryset, name, value):
+        """
+        根据逗号/加号/换行分隔的 label 字符串过滤任务。
+        URL Query Param 示例: ?label=tag1,tag2+tag3\ntag4
+        """
+        # 支持逗号、加号或换行分隔，并去除空项与两端空白
+        label_ids = Label.get_label_ids_by_names(value)
+        if not label_ids:
+            return queryset
+
+        ttemplate_ids_subquery = TemplateLabelRelation.objects.filter(label_id__in=label_ids).values("template_id")
+
+        return queryset.filter(id__in=Subquery(ttemplate_ids_subquery))
+
 
 class TemplateSnapshotFilterSet(FilterSet):
     desc = django_filters.CharFilter(field_name="desc", lookup_expr="icontains")
@@ -150,11 +169,14 @@ def list(self, request, *args, **kwargs):
         serializer = self.get_serializer(page if page is not None else queryset, many=True)
         data = []
         has_trigger_template_ids = set(Trigger.objects.all().values_list("template_id", flat=True))
+        template_ids = [obj["id"] for obj in serializer.data]
+        templates_labels = TemplateLabelRelation.objects.fetch_objects_labels(template_ids)
         for template in serializer.data:
             if template["id"] in has_trigger_template_ids:
                 template["has_interval_trigger"] = True
             else:
                 template["has_interval_trigger"] = False
+            template["labels"] = templates_labels.get(template["id"], [])
             data.append(template)
         if page is not None:
             return self.get_paginated_response(data)
@@ -169,6 +191,7 @@ def create_template(self, request, space_id, *args, **kwargs):
         pipeline_tree = build_default_pipeline_tree_with_space_id(space_id)
         # 涉及到两张表的创建，需要那个开启事物，确保两张表全部都创建成功
         with transaction.atomic():
+            label_ids = ser.validated_data.pop("label_ids", [])
             username = request.user.username
             if SpaceConfig.get_config(space_id=space_id, config_name=FlowVersioning.name) == "true":
                 snapshot = TemplateSnapshot.create_draft_snapshot(pipeline_tree, username)
@@ -179,8 +202,14 @@ def create_template(self, request, space_id, *args, **kwargs):
             )
             snapshot.template_id = template.id
             snapshot.save(update_fields=["template_id"])
+            # 同步标签
+            TemplateLabelRelation.objects.set_labels(template.id, label_ids)
+
         return Response({"result": True, "data": template.to_json()})
 
+    def update(self, request, *args, **kwargs):
+        return super().update(request, *args, **kwargs)
+
     @swagger_auto_schema(method="POST", operation_description="创建任务", request_body=CreateTaskSerializer)
     @action(methods=["POST"], detail=False, url_path="create_task/(?P<space_id>\\d+)")
     def create_task(self, request, space_id, *args, **kwargs):
@@ -303,6 +332,7 @@ def batch_delete(self, request, *args, **kwargs):
             "id", flat=True
         )
         Trigger.objects.batch_delete_by_ids(space_id=space_id, trigger_ids=list(trigger_ids), is_full=is_full)
+        TemplateLabelRelation.objects.filter(template_id__in=template_ids).delete()
         return Response({"delete_num": update_num})
 
     @swagger_auto_schema(method="POST", operation_description="流程模版复制", request_body=TemplateCopySerializer)
@@ -427,7 +457,24 @@ def list_template(self, request, *args, **kwargs):
 
     @record_operation(RecordType.template.name, TemplateOperationType.update.name, TemplateOperationSource.app.name)
     def update(self, request, *args, **kwargs):
-        return super().update(request, *args, **kwargs)
+        partial = kwargs.pop("partial", False)
+        instance = self.get_object()
+        serializer = self.get_serializer(instance, data=request.data, partial=partial)
+        serializer.is_valid(raise_exception=True)
+        self.perform_update(serializer)
+        labels = TemplateLabelRelation.objects.fetch_labels(instance.id)
+        data = deepcopy(serializer.data)
+        data["labels"] = labels
+        return Response(data)
+
+    @swagger_auto_schema(method="POST", operation_description="更新标签", request_body=TemplateUpdateLabelSerializer)
+    @action(detail=True, methods=["post"], url_path="update_labels")
+    def update_labels(self, request, *args, **kwargs):
+        task_instance = self.get_object()
+        label_ids = request.data.get("label_ids", [])
+        with transaction.atomic():
+            TemplateLabelRelation.objects.set_labels(task_instance.id, label_ids)
+        return Response(label_ids)
 
     @action(methods=["POST"], detail=False)
     def analysis_constants_ref(self, request, *args, **kwargs):
diff --git a/bkflow/urls.py b/bkflow/urls.py
index b8c5240f50..f1b34c80f3 100644
--- a/bkflow/urls.py
+++ b/bkflow/urls.py
@@ -41,6 +41,7 @@
         url(r"^api/plugin_query/", include("bkflow.pipeline_plugins.query.urls")),
         url(r"^api/plugin_service/", include("plugin_service.urls")),
         url(r"^api/api_plugin_demo/", include("bkflow.api_plugin_demo.urls")),
+        url(r"^api/label/", include("bkflow.label.urls")),
         url(r"^notice/", include("bk_notice_sdk.urls")),
         url(r"^version_log/", include("version_log.urls", namespace="version_log")),
     ]
diff --git a/frontend/src/config/i18n/cn.js b/frontend/src/config/i18n/cn.js
index 1578a507a9..4232426d77 100644
--- a/frontend/src/config/i18n/cn.js
+++ b/frontend/src/config/i18n/cn.js
@@ -396,7 +396,7 @@ const cn = {
   '数据格式不正确，应为JSON格式': '数据格式不正确，应为JSON格式',
   '确认" {0} "恢复默认值?': '确认" {0} "恢复默认值?',
   '删除成功！': '删除成功！',
-  'ID/任务名称/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值': 'ID/任务名称/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值',
+  'ID/任务名称/标签/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值': 'ID/任务名称/标签/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值',
   引擎操作: '引擎操作',
   任务名称: '任务名称',
   执行人: '执行人',
@@ -413,7 +413,7 @@ const cn = {
   新建流程: '新建流程',
   流程名称: '流程名称',
   流程创建成功: '流程创建成功',
-  'ID/流程名称/创建人/更新人/启用/所属作用域类型/所属作用域值': 'ID/流程名称/创建人/更新人/启用/所属作用域类型/所属作用域值',
+  'ID/流程名称/标签/创建人/更新人/启用/所属作用域类型/所属作用域值': 'ID/流程名称/标签/创建人/更新人/启用/所属作用域类型/所属作用域值',
   创建流程: '创建流程',
   '当前已选择 x 条数据': '当前已选择 {num} 条数据',
   '，': '，',
@@ -1059,6 +1059,23 @@ const cn = {
   参数名不能为空: '参数名不能为空',
   参数名不能重复: '参数名不能重复',
   '请输入值或 $ 选择变量': '请输入值或 $ 选择变量',
+  labelReference: '{0} 个流程在引用，{1} 个任务在引用',
+  '搜索标签名称、标签范围、系统默认标签': '搜索标签名称、标签范围、系统默认标签',
+  新增标签: '新增标签',
+  标签名称: '标签名称',
+  标签描述: '标签描述',
+  标签范围: '标签范围',
+  标签引用: '标签引用',
+  系统默认标签: '系统默认标签',
+  是: '是',
+  否: '否',
+  任务: '任务',
+  流程: '流程',
+  '确认删除该标签？': '确认删除该标签？',
+  关联的流程将同时移出本标签: '关联的流程将同时移出本标签',
+  '标签删除成功！': '标签删除成功！',
+  编辑标签: '编辑标签',
+  标签颜色: '标签颜色',
 };
 
 export default cn;
diff --git a/frontend/src/config/i18n/en.js b/frontend/src/config/i18n/en.js
index 9ba229c05f..4ffb75a47f 100644
--- a/frontend/src/config/i18n/en.js
+++ b/frontend/src/config/i18n/en.js
@@ -396,7 +396,7 @@ const en = {
   '数据格式不正确，应为JSON格式': 'Incorrect data format, should be in JSON format',
   '确认" {0} "恢复默认值?': 'Confirm to reset value for "{0}"?',
   '删除成功！': 'Deleted Successfully!',
-  'ID/任务名称/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值': 'ID/Task Name/Created by/Executor/Template ID/Scope Type/Scope Value',
+  'ID/任务名称/标签/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值': 'ID/Task Name/Label/Created by/Executor/Template ID/Scope Type/Scope Value',
   引擎操作: 'Engine Operation',
   任务名称: 'Task Name',
   执行人: 'Executor',
@@ -413,7 +413,7 @@ const en = {
   新建流程: 'Add',
   流程名称: 'Process Name',
   流程创建成功: 'Process Created Successfully',
-  'ID/流程名称/创建人/更新人/启用/所属作用域类型/所属作用域值': 'ID/Flow Name/Created by/Updater/Enabled/Scope Type/Scope Value',
+  'ID/流程名称/标签/创建人/更新人/启用/所属作用域类型/所属作用域值': 'ID/Flow Name/Label/Created by/Updater/Enabled/Scope Type/Scope Value',
   创建流程: 'Add',
   '当前已选择 x 条数据': 'Currently Selected {num} Items',
   '，': ', ',
@@ -1057,6 +1057,23 @@ const en = {
   参数名不能为空: 'Parameter name cannot be empty',
   参数名不能重复: 'Parameter name cannot be duplicated',
   '请输入值或 $ 选择变量': 'Enter value or $ to select variable',
+  labelReference: '{0} template is being referenced，{1} task is being referenced',
+  '搜索标签名称、标签范围、系统默认标签': 'Search Label Name, Label Scope, System Default Label',
+  新增标签: 'Add Label',
+  标签名称: 'Label Name',
+  标签描述: 'Label Description',
+  标签范围: 'Label Scope',
+  标签引用: 'Label Reference',
+  系统默认标签: 'System Default Label',
+  是: 'Yes',
+  否: 'No',
+  任务: 'Task',
+  流程: 'Template',
+  '确认删除该标签？': 'Confirm delete this label?',
+  关联的流程将同时移出本标签: 'The associated process will also be removed from this label',
+  '标签删除成功！': 'Label deleted successfully!',
+  编辑标签: 'Edit Label',
+  标签颜色: 'Label Color',
 };
 
 export default en;
diff --git a/frontend/src/constants/index.js b/frontend/src/constants/index.js
index 039873ec8d..eaf9489a5a 100644
--- a/frontend/src/constants/index.js
+++ b/frontend/src/constants/index.js
@@ -165,6 +165,12 @@ const COLOR_BLOCK_LIST = [
   },
 ];
 
+// 标签范围
+const LABEL_SCOPE = {
+  template: i18n.t('流程'),
+  task: i18n.t('任务'),
+};
+
 const NAME_REG = /^[^'"‘’“”$<>]+$/;
 const PACKAGE_NAME_REG = /^[^\d][\w]*?$/;
 // celery的crontab时间表达式正则表达式（分钟 小时 星期 日 月）（以空格分割）
@@ -178,5 +184,5 @@ const URL_REG = new RegExp('^(https?|ftp|file)://[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-
 export {
   TASK_STATE_DICT, NODE_DICT, SYSTEM_GROUP_ICON, BK_PLUGIN_ICON, NAME_REG,
   INVALID_NAME_CHAR, PACKAGE_NAME_REG, URL_REG, PERIODIC_REG, STRING_LENGTH,
-  LABEL_COLOR_LIST, DARK_COLOR_LIST, TASK_CATEGORIES, COLOR_BLOCK_LIST,
+  LABEL_COLOR_LIST, DARK_COLOR_LIST, TASK_CATEGORIES, COLOR_BLOCK_LIST, LABEL_SCOPE,
 };
diff --git a/frontend/src/constants/route.js b/frontend/src/constants/route.js
index 21697c7097..efec90906f 100644
--- a/frontend/src/constants/route.js
+++ b/frontend/src/constants/route.js
@@ -40,6 +40,12 @@ export const SPACE_LIST = [
     id: 'credential',
     disabled: false,
   },
+  {
+    name: i18n.t('标签管理'),
+    icon: 'common-icon-credential',
+    id: 'labelManage',
+    disabled: false,
+  },
 ];
 
 export const MODULES_LIST = [
diff --git a/frontend/src/store/index.js b/frontend/src/store/index.js
index 393d366e4a..b8a0be9509 100644
--- a/frontend/src/store/index.js
+++ b/frontend/src/store/index.js
@@ -21,6 +21,7 @@ import decisionTable from './modules/decisionTable';
 import credentialConfig from './modules/credentialConfig';
 import plugin from './modules/plugin';
 import stageCanvas from './modules/stageCanvas';
+import label from './modules/label';
 Vue.use(Vuex);
 
 const getAppLang = () => {
@@ -44,6 +45,7 @@ const store = new Vuex.Store({
     credentialConfig,
     plugin,
     stageCanvas,
+    label,
   },
   // 公共 store
   state: {
diff --git a/frontend/src/store/modules/label.js b/frontend/src/store/modules/label.js
new file mode 100644
index 0000000000..1f949b37a9
--- /dev/null
+++ b/frontend/src/store/modules/label.js
@@ -0,0 +1,36 @@
+/**
+* Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community
+* Edition) available.
+* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
+* Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+* http://opensource.org/licenses/MIT
+* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations under the License.
+*/
+import axios from 'axios';
+
+export default  {
+  namespaced: true,
+  actions: {
+    // 获取标签列表 二级标签传入parent_id
+    loadLabelList({}, params) {
+      return axios.get('/api/label/', { params }).then(response => response.data);
+    },
+    createLabel({}, data) {
+      return axios.post('/api/label/', data).then(response => response.data);
+    },
+    updateLabel({}, { id, data }) {
+      return axios.put(`/api/label/${id}/`, data).then(response => response.data);
+    },
+    deleteLabel({}, id) {
+      return axios.delete(`/api/label/${id}/`).then(response => response.data);
+    },
+    // 获取标签引用参数
+    loadLabelReference({}, params) {
+      return axios.get('/api/label/get_label_ref_count/', { params }).then(response => response.data);
+    },
+  },
+};
+
diff --git a/frontend/src/store/modules/taskList.js b/frontend/src/store/modules/taskList.js
index 33ab0f6e30..ce5f6428a2 100644
--- a/frontend/src/store/modules/taskList.js
+++ b/frontend/src/store/modules/taskList.js
@@ -34,6 +34,9 @@ const taskList = {
     deleteTask({}, data) {
       return axios.post('/task_admin/batch_delete_tasks/', data).then(response => response.data);
     },
+    updateTaskLabel({}, data) {
+      return axios.post(`/task_admin/update_labels/${data.space_id}/${data.task_id}/`, { label_ids: data.label_ids }).then(response => response.data);
+    },
   },
 };
 
diff --git a/frontend/src/store/modules/template.js b/frontend/src/store/modules/template.js
index 1bf93ec7c2..5fa8e8aadb 100644
--- a/frontend/src/store/modules/template.js
+++ b/frontend/src/store/modules/template.js
@@ -9,7 +9,7 @@
 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 */
-import Vue, {  ref } from 'vue';
+import Vue, { ref } from 'vue';
 import nodeFilter from '@/utils/nodeFilter.js';
 import { uuid, random4 } from '@/utils/uuid.js';
 import tools from '@/utils/tools.js';
@@ -186,7 +186,7 @@ const template = {
     category: '',
     description: '',
     executor_proxy: '',
-    template_labels: '',
+    template_labels: [],
     subprocess_info: {
       details: [],
       subproc_has_update: false,
@@ -202,6 +202,9 @@ const template = {
     setTemplateName(state, name) {
       state.name = name;
     },
+    setTemplateLabel(state, labels) {
+      state.template_labels = labels;
+    },
     setReceiversGroup(state, data) {
       state.notify_receivers.receiver_group = data;
     },
@@ -326,7 +329,6 @@ const template = {
         name,
         id: templateId,
         pipeline_tree: pipelineData,
-        template_labels: templateLabels,
         notify_config: notifyConfig,
         description,
         executor_proxy: executorProxy,
@@ -351,7 +353,6 @@ const template = {
       state.notify_type = typeof notifyType === 'string' ? { success: JSON.parse(notifyType), fail: [] } : notifyType;
       state.description = description;
       state.executor_proxy = executorProxy;
-      state.template_labels = templateLabels || [];
       state.time_out = timeOut;
       state.category = category;
       state.subprocess_info = subprocessInfo;
@@ -396,7 +397,6 @@ const template = {
       };
       state.description = '';
       state.executor_proxy = '';
-      state.template_labels = [];
       state.default_flow_type = 'common';
     },
     // 重置模板数据
@@ -1050,7 +1050,7 @@ const template = {
         timeout,
         description,
         executor_proxy,
-        template_labels,
+        labels: template_labels.map(label => label.id),
         default_flow_type,
         pipeline_tree: pipelineTree,
         space_id: spaceId,
diff --git a/frontend/src/store/modules/templateList.js b/frontend/src/store/modules/templateList.js
index d0f9c7e8d1..dff502c911 100644
--- a/frontend/src/store/modules/templateList.js
+++ b/frontend/src/store/modules/templateList.js
@@ -37,6 +37,9 @@ const templateList = {
     copyTemplate({}, data) {
       return axios.post('/api/template/admin/template_copy/', data).then(response => response.data);
     },
+    updateTemplateLabel({}, data) {
+      return axios.post(`/api/template/${data.template_id}/update_labels/`, { label_ids: data.label_ids }).then(response => response.data);
+    },
   },
 };
 
diff --git a/frontend/src/views/admin/Space/Task/index.vue b/frontend/src/views/admin/Space/Task/index.vue
index ad2a3439fa..5352fd96bb 100644
--- a/frontend/src/views/admin/Space/Task/index.vue
+++ b/frontend/src/views/admin/Space/Task/index.vue
@@ -3,7 +3,11 @@
     <table-operate
       ref="tableOperate"
       :space-id="spaceId"
-      :placeholder="$t('ID/任务名称/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值')"
+      :placeholder="
+        $t(
+          'ID/任务名称/标签/创建人/执行人/所属模板 ID/所属作用域类型/所属作用域值'
+        )
+      "
       :search-list="searchList"
       @updateSearchValue="searchValue = $event"
       @changeRequest="handleSearchSelectChange">
@@ -12,7 +16,7 @@
         theme="primary"
         :disabled="!spaceId"
         @click="onEngineOperate">
-        {{ $t('引擎操作') }}
+        {{ $t("引擎操作") }}
       </bk-button>
     </table-operate>
     <bk-table
@@ -30,7 +34,7 @@
         :prop="item.id"
         :render-header="renderTableHeader"
         :width="item.width"
-        show-overflow-tooltip
+        :show-overflow-tooltip="item.id !== 'label'"
         :min-width="item.min_width">
         <template slot-scope="props">
           <div v-if="item.id === 'name'">
@@ -39,28 +43,71 @@
               :to="{
                 name: 'taskExecute',
                 params: {
-                  spaceId: spaceId
+                  spaceId: spaceId,
                 },
                 query: {
                   instanceId: props.row.id,
-                  type: createMethod === 'MOCK' ? 'mock' : undefined
-                }
+                  type:
+                    createMethod === 'MOCK'
+                      ? 'mock'
+                      : undefined,
+                },
               }">
               {{ props.row.name }}
             </router-link>
           </div>
+          <div v-else-if="item.id === 'label'">
+            <label-cascade
+              :value="props.row.labels"
+              scope="task"
+              @confirm="onConfirmEditLabel(props.row, $event)">
+              <template #trigger="{ list, isShow }">
+                <div
+                  v-if="isShow"
+                  class="edit-label-cell">
+                  <div class="label-list">
+                    <span
+                      v-for="label in list"
+                      :key="label.id"
+                      class="label-item"
+                      :style="{
+                        'background-color': label.color,
+                      }">
+                      {{ label.full_path }}
+                      <bk-icon
+                        class="delete-icon"
+                        type="close"
+                        @mousedown.native.stop.prevent="
+                          onDeleteLabel(
+                            props.row,
+                            label
+                          )
+                        " />
+                    </span>
+                  </div>
+                </div>
+                <LabelCell
+                  v-else
+                  :tags="list" />
+              </template>
+            </label-cascade>
+          </div>
           <div
             v-else-if="item.id === 'state'"
             class="task-status">
             <span :class="props.row.cls" />
-            <span class="task-status-text">{{ props.row.state_text || '--' }}</span>
+            <span class="task-status-text">{{
+              props.row.state_text || "--"
+            }}</span>
           </div>
           <div v-else-if="item.id === 'trigger_method'">
-            <span>{{ $t(triggerMethodName[props.row.trigger_method]) }}</span>
+            <span>{{
+              $t(triggerMethodName[props.row.trigger_method])
+            }}</span>
           </div>
           <!-- 其他 -->
           <template v-else>
-            <span>{{ props.row[item.id] || '--' }}</span>
+            <span>{{ props.row[item.id] || "--" }}</span>
           </template>
         </template>
       </bk-table-column>
@@ -73,7 +120,7 @@
             theme="primary"
             text
             @click="onDeleteTask(props.row)">
-            {{ $t('删除') }}
+            {{ $t("删除") }}
           </bk-button>
         </template>
       </bk-table-column>
@@ -97,355 +144,435 @@
 </template>
 
 <script>
-  import { mapState, mapActions } from 'vuex';
-  import CancelRequest from '@/api/cancelRequest.js';
-  import NoData from '@/components/common/base/NoData.vue';
-  import moment from 'moment-timezone';
-  import tableHeader from '@/mixins/tableHeader.js';
-  import tableCommon from '../mixins/tableCommon.js';
-  import TableOperate from '../common/TableOperate.vue';
-  import i18n from '@/config/i18n/index.js';
+import { mapState, mapActions } from 'vuex';
+import CancelRequest from '@/api/cancelRequest.js';
+import NoData from '@/components/common/base/NoData.vue';
+import moment from 'moment-timezone';
+import tableHeader from '@/mixins/tableHeader.js';
+import tableCommon from '../mixins/tableCommon.js';
+import TableOperate from '../common/TableOperate.vue';
+import i18n from '@/config/i18n/index.js';
+import LabelCascade from '../common/LabelCascade.vue';
+import LabelCell from '../Template/label-cell.vue';
 
-  const TABLE_FIELDS = [
+const TABLE_FIELDS = [
+    {
+        id: 'id',
+        label: 'ID',
+        disabled: true,
+        width: 100,
+    },
     {
-      id: 'id',
-      label: 'ID',
-      disabled: true,
-      width: 100,
+        id: 'scope_type',
+        label: i18n.t('所属作用域类型'),
+        width: 160,
     },
     {
-      id: 'scope_type',
-      label: i18n.t('所属作用域类型'),
-      width: 160,
+        id: 'scope_value',
+        label: i18n.t('所属作用域值'),
+        width: 160,
     },
     {
-      id: 'scope_value',
-      label: i18n.t('所属作用域值'),
-      width: 160,
+        id: 'name',
+        label: i18n.t('任务名称'),
+        disabled: true,
+        min_width: 200,
     },
     {
-      id: 'name',
-      label: i18n.t('任务名称'),
-      disabled: true,
-      min_width: 200,
+        id: 'label',
+        label: i18n.t('标签'),
+        width: 272,
     },
     {
-      id: 'template_id',
-      label: i18n.t('所属模板 ID'),
-      width: 100,
+        id: 'template_id',
+        label: i18n.t('所属模板 ID'),
+        width: 100,
     },
     {
-      id: 'create_time',
-      label: i18n.t('创建时间'),
-      width: 280,
+        id: 'create_time',
+        label: i18n.t('创建时间'),
+        width: 280,
     },
     {
-      id: 'creator',
-      label: i18n.t('创建人'),
-      width: 160,
+        id: 'creator',
+        label: i18n.t('创建人'),
+        width: 160,
     },
     {
-      id: 'executor',
-      label: i18n.t('执行人'),
-      width: 160,
+        id: 'executor',
+        label: i18n.t('执行人'),
+        width: 160,
     },
     {
-      id: 'state',
-      label: i18n.t('状态'),
-      width: 160,
+        id: 'state',
+        label: i18n.t('状态'),
+        width: 160,
     },
     {
-      id: 'trigger_method',
-      label: i18n.t('触发类型'),
-      width: 160,
+        id: 'trigger_method',
+        label: i18n.t('触发类型'),
+        width: 160,
     },
     {
-      id: 'start_time',
-      label: i18n.t('开始时间'),
-      width: 280,
+        id: 'start_time',
+        label: i18n.t('开始时间'),
+        width: 280,
     },
     {
-      id: 'finish_time',
-      label: i18n.t('结束时间'),
-      width: 280,
+        id: 'finish_time',
+        label: i18n.t('结束时间'),
+        width: 280,
     },
     {
-      id: 'instance_id',
-      label: i18n.t('引擎实例 Id'),
-      width: 280,
+        id: 'instance_id',
+        label: i18n.t('引擎实例 Id'),
+        width: 280,
     },
-  ];
-  const SEARCH_LIST = [
+];
+const SEARCH_LIST = [
     {
-      id: 'id',
-      name: 'ID',
+        id: 'id',
+        name: 'ID',
     },
     {
-      id: 'name',
-      name: i18n.t('任务名称'),
-      isDefaultOption: true,
+        id: 'name',
+        name: i18n.t('任务名称'),
+        isDefaultOption: true,
     },
     {
-      id: 'creator',
-      name: i18n.t('创建人'),
+        id: 'label',
+        name: i18n.t('标签'),
     },
     {
-      id: 'executor',
-      name: i18n.t('执行人'),
+        id: 'creator',
+        name: i18n.t('创建人'),
     },
     {
-      id: 'template_id',
-      name: i18n.t('所属模板 ID'),
+        id: 'executor',
+        name: i18n.t('执行人'),
     },
     {
-      id: 'scope_type',
-      name: i18n.t('所属作用域类型'),
+        id: 'template_id',
+        name: i18n.t('所属模板 ID'),
     },
     {
-      id: 'scope_value',
-      name: i18n.t('所属作用域值'),
+        id: 'scope_type',
+        name: i18n.t('所属作用域类型'),
     },
-  ];
-  const TRIGGER_METHOD = {
+    {
+        id: 'scope_value',
+        name: i18n.t('所属作用域值'),
+    },
+];
+const TRIGGER_METHOD = {
     api: 'api触发',
     manual: '手动触发',
     timing: '定时触发',
     subprocess: '子流程触发',
-  };
-  export default {
+};
+export default {
     name: 'TaskList',
     components: {
-      NoData,
-      TableOperate,
+        NoData,
+        TableOperate,
+        LabelCascade,
+        LabelCell,
     },
     mixins: [tableHeader, tableCommon],
     data() {
-      return {
-        taskList: [],
-        deleting: false,
-        tableFields: TABLE_FIELDS,
-        defaultSelected: ['id', 'name', 'creator_time', 'creator', 'executor', 'state', 'start_time', 'finish_time'],
-        setting: {
-          fieldList: TABLE_FIELDS,
-          selectedFields: [],
-          size: 'small',
-        },
-        dateFields: ['create_time', 'start_time', 'finish_time'],
-        searchList: SEARCH_LIST,
-        pageType: 'taskList', // 页面类型，在mixins中分页表格头显示使用
-        triggerMethodName: TRIGGER_METHOD,
-      };
+        return {
+            taskList: [],
+            deleting: false,
+            tableFields: TABLE_FIELDS,
+            defaultSelected: [
+                'id',
+                'name',
+                'label',
+                'creator_time',
+                'creator',
+                'executor',
+                'state',
+                'start_time',
+                'finish_time',
+            ],
+            setting: {
+                fieldList: TABLE_FIELDS,
+                selectedFields: [],
+                size: 'small',
+            },
+            dateFields: ['create_time', 'start_time', 'finish_time'],
+            searchList: SEARCH_LIST,
+            pageType: 'taskList', // 页面类型，在mixins中分页表格头显示使用
+            triggerMethodName: TRIGGER_METHOD,
+        };
     },
     computed: {
-      ...mapState({
-        isAdmin: state => state.isAdmin,
-      }),
+        ...mapState({
+            isAdmin: state => state.isAdmin,
+        }),
     },
     methods: {
-      ...mapActions('taskList/', [
-        'loadTaskList',
-        'deleteTask',
-      ]),
-      ...mapActions('task/', [
-        'getTaskStatus',
-      ]),
-      async getTaskList() {
-        try {
-          if (!this.spaceId) return;
-          this.listLoading = true;
-          const data = this.getQueryData();
-          const resp = await this.loadTaskList(data);
-          const list = await this.setFillTaskField(resp.data.results);
-          this.taskList = list;
-          this.pagination.count = resp.data.count;
-          const totalPage = Math.ceil(this.pagination.count / this.pagination.limit);
-          if (!totalPage) {
-            this.totalPage = 1;
-          } else {
-            this.totalPage = totalPage;
-          }
-        } catch (error) {
-          console.warn(error);
-        } finally {
-          this.listLoading = false;
-        }
-      },
-      async setFillTaskField(list) {
-        try {
-          const ids = list.map(task => task.id);
-          const params = {
-            space_id: this.spaceId,
-            task_ids: ids,
-          };
-          const resp = await this.getTaskStatus(params);
-          list.forEach((task) => {
-            const status = {};
-            if (task.is_expired) {
-              status.cls = 'expired bk-icon icon-clock-shape';
-              status.state_text = this.$t('已过期');
-            } else if (task.is_finished) {
-              status.cls = 'finished bk-icon icon-check-circle-shape';
-              status.state_text = this.$t('完成');
-            } else if (task.is_revoked) {
-              status.cls = 'revoke common-icon-dark-stop';
-              status.state_text = this.$t('终止');
-            } else if (task.is_started) {
-              status.cls = 'loading common-icon-loading';
-              const { state } = resp.data[task.id];
-              switch (state) {
-                case 'RUNNING':
-                case 'BLOCKED':
-                  status.cls = 'running common-icon-dark-circle-ellipsis';
-                  status.state_text = this.$t('执行中');
-                  break;
-                case 'READY':
-                  status.cls = 'running common-icon-dark-circle-ellipsis';
-                  status.state_text = this.$t('排队中');
-                  break;
-                case 'SUSPENDED':
-                  status.cls = 'execute common-icon-dark-circle-pause';
-                  status.state_text = this.$t('已暂停');
-                  break;
-                case 'NODE_SUSPENDED':
-                  status.cls = 'execute';
-                  status.state_text = this.$t('节点暂停');
-                  break;
-                case 'FAILED':
-                  status.cls = 'failed common-icon-dark-circle-close';
-                  status.state_text = this.$t('失败');
-                  break;
-                default:
-                  status.state_text = this.$t('未知');
-              }
-            } else {
-              status.cls = 'created common-icon-waitting';
-              status.state_text = this.$t('未执行');
+        ...mapActions('taskList/', [
+            'loadTaskList',
+            'deleteTask',
+            'updateTaskLabel',
+        ]),
+        ...mapActions('task/', ['getTaskStatus']),
+        async getTaskList() {
+            try {
+                if (!this.spaceId) return;
+                this.listLoading = true;
+                const data = this.getQueryData();
+                const resp = await this.loadTaskList(data);
+                const list = await this.setFillTaskField(resp.data.results);
+                this.taskList = list;
+                this.pagination.count = resp.data.count;
+                const totalPage = Math.ceil(this.pagination.count / this.pagination.limit);
+                if (!totalPage) {
+                    this.totalPage = 1;
+                } else {
+                    this.totalPage = totalPage;
+                }
+            } catch (error) {
+                console.warn(error);
+            } finally {
+                this.listLoading = false;
             }
-            Object.assign(task, status);
-          });
-          return list;
-        } catch (error) {
-          console.warn(error);
-        }
-      },
-      getQueryData() {
-        const source = new CancelRequest();
-        const { query } = this.$route;
-        this.pagination.current = query.current ?  Number(query.current) : this.pagination.current;
-        const {
-          name,
-          id,
-          creator,
-          create_time: createTime,
-          start_time: startTime,
-          finish_time: finishTime,
-          executor,
-          scope_type,
-          scope_value,
-          template_id,
-          limit = this.pagination.limit,
-        } = this.requestData;
-        const data = {
-          space_id: this.spaceId,
-          limit,
-          offset: (this.pagination.current - 1) * limit,
-          name__icontains: name,
-          id,
-          creator,
-          executor,
-          scope_type,
-          scope_value,
-          template_id,
-          cancelToken: source.token,
-          create_method: this.createMethod,
-        };
-        if (createTime && createTime[0] && createTime[1]) {
-          data.create_time__gte = moment(createTime[0]).format('YYYY-MM-DD HH:mm:ss');
-          data.create_time__lte = moment(createTime[1]).format('YYYY-MM-DD HH:mm:ss');
-        }
-        if (startTime && startTime[0] && startTime[1]) {
-          data.start_time__gte = moment(startTime[0]).format('YYYY-MM-DD HH:mm:ss');
-          data.start_time__lte = moment(startTime[1]).format('YYYY-MM-DD HH:mm:ss');
-        }
-        if (finishTime && finishTime[0] && finishTime[1]) {
-          data.finish_time__gte = moment(finishTime[0]).format('YYYY-MM-DD HH:mm:ss');
-          data.finish_time__lte = moment(finishTime[1]).format('YYYY-MM-DD HH:mm:ss');
-        }
-        return data;
-      },
-      onDeleteTask(template) {
-        const h = this.$createElement;
-        this.$bkInfo({
-          subHeader: h('div', { class: 'custom-header' }, [
-            h('div', {
-              class: 'custom-header-title',
-              directives: [{
-                name: 'bk-overflow-tips',
-              }],
-            }, [this.$t('确认删除任务"{0}"?', [template.name])]),
-          ]),
-          extCls: 'dialog-custom-header-title',
-          maskClose: false,
-          width: 450,
-          confirmLoading: true,
-          cancelText: this.$t('取消'),
-          confirmFn: async () => {
-            await this.onDeleteConfirm(template.id);
-          },
-        });
-      },
-      async onDeleteConfirm(taskId) {
-        if (this.deleting) return;
-        this.deleting = true;
-        try {
-          const data = {
-            space_id: this.spaceId,
-            task_ids: [taskId],
-          };
-          const resp = await this.deleteTask(data);
-          if (resp.result === false) return;
-          // 最后一页最后一条删除后，往前翻一页
-          if (
-            this.pagination.current > 1
-            && this.totalPage === this.pagination.current
-            && this.pagination.count - (this.totalPage - 1) * this.pagination.limit === 1
-          ) {
-            this.pagination.current -= 1;
-          }
-          this.getTaskList();
-          this.updateUrl({ current: 1 });
-          this.$bkMessage({
-            message: this.$t('任务删除成功！'),
-            theme: 'success',
-          });
-        } catch (e) {
-          console.log(e);
-        } finally {
-          this.deleting = false;
-        }
-      },
-      onEngineOperate() {
-        this.$router.push({
-          name: 'EnginePanel',
-          params: {
-            spaceId: this.spaceId,
-          },
-          query: { type: this.$route.query.activeTab },
-        });
-      },
+        },
+        async setFillTaskField(list) {
+            try {
+                const ids = list.map(task => task.id);
+                const params = {
+                    space_id: this.spaceId,
+                    task_ids: ids,
+                };
+                const resp = await this.getTaskStatus(params);
+                list.forEach((task) => {
+                    const status = {};
+                    if (task.is_expired) {
+                        status.cls = 'expired bk-icon icon-clock-shape';
+                        status.state_text = this.$t('已过期');
+                    } else if (task.is_finished) {
+                        status.cls = 'finished bk-icon icon-check-circle-shape';
+                        status.state_text = this.$t('完成');
+                    } else if (task.is_revoked) {
+                        status.cls = 'revoke common-icon-dark-stop';
+                        status.state_text = this.$t('终止');
+                    } else if (task.is_started) {
+                        status.cls = 'loading common-icon-loading';
+                        const { state } = resp.data[task.id];
+                        switch (state) {
+                            case 'RUNNING':
+                            case 'BLOCKED':
+                                status.cls =                                    'running common-icon-dark-circle-ellipsis';
+                                status.state_text = this.$t('执行中');
+                                break;
+                            case 'READY':
+                                status.cls =                                    'running common-icon-dark-circle-ellipsis';
+                                status.state_text = this.$t('排队中');
+                                break;
+                            case 'SUSPENDED':
+                                status.cls =                                    'execute common-icon-dark-circle-pause';
+                                status.state_text = this.$t('已暂停');
+                                break;
+                            case 'NODE_SUSPENDED':
+                                status.cls = 'execute';
+                                status.state_text = this.$t('节点暂停');
+                                break;
+                            case 'FAILED':
+                                status.cls =                                    'failed common-icon-dark-circle-close';
+                                status.state_text = this.$t('失败');
+                                break;
+                            default:
+                                status.state_text = this.$t('未知');
+                        }
+                    } else {
+                        status.cls = 'created common-icon-waitting';
+                        status.state_text = this.$t('未执行');
+                    }
+                    Object.assign(task, status);
+                });
+                return list;
+            } catch (error) {
+                console.warn(error);
+            }
+        },
+        getQueryData() {
+            const source = new CancelRequest();
+            const { query } = this.$route;
+            this.pagination.current = query.current
+                ? Number(query.current)
+                : this.pagination.current;
+            const {
+                name,
+                id,
+                label,
+                creator,
+                create_time: createTime,
+                start_time: startTime,
+                finish_time: finishTime,
+                executor,
+                scope_type,
+                scope_value,
+                template_id,
+                limit = this.pagination.limit,
+            } = this.requestData;
+            const data = {
+                space_id: this.spaceId,
+                limit,
+                offset: (this.pagination.current - 1) * limit,
+                name__icontains: name,
+                id,
+                label,
+                creator,
+                executor,
+                scope_type,
+                scope_value,
+                template_id,
+                cancelToken: source.token,
+                create_method: this.createMethod,
+            };
+            if (createTime && createTime[0] && createTime[1]) {
+                data.create_time__gte = moment(createTime[0]).format('YYYY-MM-DD HH:mm:ss');
+                data.create_time__lte = moment(createTime[1]).format('YYYY-MM-DD HH:mm:ss');
+            }
+            if (startTime && startTime[0] && startTime[1]) {
+                data.start_time__gte = moment(startTime[0]).format('YYYY-MM-DD HH:mm:ss');
+                data.start_time__lte = moment(startTime[1]).format('YYYY-MM-DD HH:mm:ss');
+            }
+            if (finishTime && finishTime[0] && finishTime[1]) {
+                data.finish_time__gte = moment(finishTime[0]).format('YYYY-MM-DD HH:mm:ss');
+                data.finish_time__lte = moment(finishTime[1]).format('YYYY-MM-DD HH:mm:ss');
+            }
+            return data;
+        },
+        onDeleteTask(template) {
+            const h = this.$createElement;
+            this.$bkInfo({
+                subHeader: h('div', { class: 'custom-header' }, [
+                    h(
+                        'div',
+                        {
+                            class: 'custom-header-title',
+                            directives: [
+                                {
+                                    name: 'bk-overflow-tips',
+                                },
+                            ],
+                        },
+                        [this.$t('确认删除任务"{0}"?', [template.name])]
+                    ),
+                ]),
+                extCls: 'dialog-custom-header-title',
+                maskClose: false,
+                width: 450,
+                confirmLoading: true,
+                cancelText: this.$t('取消'),
+                confirmFn: async () => {
+                    await this.onDeleteConfirm(template.id);
+                },
+            });
+        },
+        async onDeleteConfirm(taskId) {
+            if (this.deleting) return;
+            this.deleting = true;
+            try {
+                const data = {
+                    space_id: this.spaceId,
+                    task_ids: [taskId],
+                };
+                const resp = await this.deleteTask(data);
+                if (resp.result === false) return;
+                // 最后一页最后一条删除后，往前翻一页
+                if (
+                    this.pagination.current > 1
+                    && this.totalPage === this.pagination.current
+                    && this.pagination.count
+                        - (this.totalPage - 1) * this.pagination.limit
+                        === 1
+                ) {
+                    this.pagination.current -= 1;
+                }
+                this.getTaskList();
+                this.updateUrl({ current: 1 });
+                this.$bkMessage({
+                    message: this.$t('任务删除成功！'),
+                    theme: 'success',
+                });
+            } catch (e) {
+                console.log(e);
+            } finally {
+                this.deleting = false;
+            }
+        },
+        onEngineOperate() {
+            this.$router.push({
+                name: 'EnginePanel',
+                params: {
+                    spaceId: this.spaceId,
+                },
+                query: { type: this.$route.query.activeTab },
+            });
+        },
+        onDeleteLabel(row, label) {
+            if (!row || !label) return;
+            const filterLabel = row.labels.filter(item => item.id !== label.id);
+            this.$set(row, 'labels', filterLabel);
+        },
+        async onConfirmEditLabel(task, labels) {
+            const data = {
+                space_id: this.spaceId,
+                task_id: task.id,
+                label_ids: labels.map(item => item.id),
+            };
+            await this.updateTaskLabel(data);
+            this.getTaskList();
+        },
     },
-  };
+};
 </script>
 
 <style lang="scss" scoped>
-  @import '../../../../scss/task.scss';
-  .task-status {
+@import "../../../../scss/task.scss";
+.task-status {
     @include ui-task-status;
     .task-status-text {
-      vertical-align: middle;
+        vertical-align: middle;
     }
-  }
-  ::v-deep .bk-table-empty-text {
+}
+::v-deep .bk-table-empty-text {
     width: 100%;
-  }
+}
+.cascade-trigger {
+    height: 32px;
+    width: 242px;
+}
+.edit-label-cell {
+    width: 242px;
+    border: 1px solid #3a84ff;
+    padding: 6px 16px;
+    max-height: 120px;
+    min-height: 20px;
+    overflow: auto;
+    .label-list {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+        height: 100%;
+        overflow: auto;
+        .label-item {
+            height: 16px;
+            line-height: 16px;
+            font-size: 12px;
+            padding: 0 6px;
+            border-radius: 11px;
+            color: #ffffff;
+            .delete-icon {
+                font-size: 16px !important;
+                margin-left: 5px;
+                cursor: pointer;
+            }
+        }
+    }
+}
 </style>
diff --git a/frontend/src/views/admin/Space/Template/CreateTaskSideslider.vue b/frontend/src/views/admin/Space/Template/CreateTaskSideslider.vue
index ab3ca2f73a..20d5c1ef8c 100644
--- a/frontend/src/views/admin/Space/Template/CreateTaskSideslider.vue
+++ b/frontend/src/views/admin/Space/Template/CreateTaskSideslider.vue
@@ -27,14 +27,22 @@
           property="constants">
           <div class="bk-button-group">
             <bk-button
-              :class="taskFormData.mode === 'form' ? 'is-selected' : ''"
+              :class="
+                taskFormData.mode === 'form'
+                  ? 'is-selected'
+                  : ''
+              "
               @click="taskFormData.mode = 'form'">
-              {{ $t('表单模式') }}
+              {{ $t("表单模式") }}
             </bk-button>
             <bk-button
-              :class="taskFormData.mode === 'json' ? 'is-selected' : ''"
+              :class="
+                taskFormData.mode === 'json'
+                  ? 'is-selected'
+                  : ''
+              "
               @click="taskFormData.mode = 'json'">
-              {{ $t('json模式') }}
+              {{ $t("json模式") }}
             </bk-button>
           </div>
           <div
@@ -49,7 +57,7 @@
               v-if="isUnreferencedShow"
               accordion>
               <bk-collapse-item name="1">
-                {{ $t('查看未引用变量') }}
+                {{ $t("查看未引用变量") }}
                 <div slot="content">
                   <TaskParamEdit
                     :template-id="row.id"
@@ -65,13 +73,54 @@
             <FullCodeEditor
               ref="fullCodeEditor"
               v-model="taskFormData.constants"
-              :options="{ language: 'json', placeholder: { '${key}': 'value' } }" />
+              :options="{
+                language: 'json',
+                placeholder: { '${key}': 'value' },
+              }" />
             <p
               v-if="!isJsonConstantsValid"
-              v-bk-tooltips.top="$t('请求参数格式不正确，应为JSON格式')"
+              v-bk-tooltips.top="
+                $t('请求参数格式不正确，应为JSON格式')
+              "
               class="valid-error-tips bk-icon icon-exclamation-circle-shape" />
           </div>
         </bk-form-item>
+        <bk-form-item
+          :label="$t('标签')"
+          :required="true"
+          :property="'labels'">
+          <label-cascade
+            :value="taskFormData.labels"
+            scope="task"
+            @confirm="handleSelected">
+            <template #trigger="{ list, isShow }">
+              <div
+                :class="['cascade-trigger', { focus: isShow }]">
+                <div class="label-list">
+                  <div
+                    v-for="label in list"
+                    :key="label.id"
+                    class="label-item"
+                    :style="{
+                      'background-color': label.color,
+                    }">
+                    {{ label.full_path }}
+                    <bk-icon
+                      class="delete-icon"
+                      type="close"
+                      @click="handleDeleteLabel(label.id)" />
+                  </div>
+                </div>
+                <bk-icon
+                  :class="[
+                    'angle-icon',
+                    { 'is-show': isShow },
+                  ]"
+                  type="angle-down" />
+              </div>
+            </template>
+          </label-cascade>
+        </bk-form-item>
       </bk-form>
     </template>
     <template slot="footer">
@@ -79,231 +128,286 @@
         class="mr10"
         theme="primary"
         @click="createTaskConfirm">
-        {{ $t('提交') }}
+        {{ $t("提交") }}
       </bk-button>
       <bk-button
         theme="default"
         @click="handleCancel">
-        {{ $t('取消') }}
+        {{ $t("取消") }}
       </bk-button>
     </template>
   </bk-sideslider>
 </template>
 <script>
-  import { STRING_LENGTH } from '@/constants/index.js';
-  import { mapState, mapActions, mapMutations } from 'vuex';
-  import moment from 'moment-timezone';
-  import FullCodeEditor from '@/components/common/FullCodeEditor.vue';
-  import TaskParamEdit from '../../../template/TemplateMock/MockExecute/components/TaskParamEdit.vue';
-  import tools from '@/utils/tools.js';
+import { STRING_LENGTH } from '@/constants/index.js';
+import { mapState, mapActions, mapMutations } from 'vuex';
+import moment from 'moment-timezone';
+import FullCodeEditor from '@/components/common/FullCodeEditor.vue';
+import TaskParamEdit from '../../../template/TemplateMock/MockExecute/components/TaskParamEdit.vue';
+import tools from '@/utils/tools.js';
+import LabelCascade from '../common/LabelCascade.vue';
 
-  export default {
+export default {
     name: 'CreateTaskSideslider',
     components: {
-      FullCodeEditor,
-      TaskParamEdit,
+        FullCodeEditor,
+        TaskParamEdit,
+        LabelCascade,
     },
     props: {
-      isShow: {
-        type: Boolean,
-        default: false,
-      },
-      row: {
-        type: Object,
-        default: () => ({}),
-      },
-  },
+        isShow: {
+            type: Boolean,
+            default: false,
+        },
+        row: {
+            type: Object,
+            default: () => ({}),
+        },
+    },
     data() {
-      return {
-        taskFormData: {},
-        pipelineTree: {},
-        rules: {
-          name: [
-            {
-              required: true,
-              message: this.$t('必填项'),
-              trigger: 'blur',
+        return {
+            taskFormData: {},
+            pipelineTree: {},
+            rules: {
+                name: [
+                    {
+                        required: true,
+                        message: this.$t('必填项'),
+                        trigger: 'blur',
+                    },
+                ],
             },
-          ],
-        },
-        stringLength: STRING_LENGTH,
-        createLoading: false,
-        unReferencedConstants: {},
-      };
+            stringLength: STRING_LENGTH,
+            createLoading: false,
+            unReferencedConstants: {},
+        };
     },
     computed: {
-      ...mapState({
-        spaceId: state => state.spaceId,
-        username: state => state.username,
-      }),
-      isJsonConstantsValid() {
-        const { constants, mode } = this.taskFormData;
-        return mode === 'json' ? tools.checkIsJSON(constants) : true;
-      },
-      isUnreferencedShow() {
-        const variableKeys = Object.keys(this.unReferencedConstants);
-        const unreferenced = variableKeys.filter(key => this.unReferencedConstants[key].show_type === 'show');
-        return !!unreferenced.length;
-      },
+        ...mapState({
+            spaceId: state => state.spaceId,
+            username: state => state.username,
+        }),
+        isJsonConstantsValid() {
+            const { constants, mode } = this.taskFormData;
+            return mode === 'json' ? tools.checkIsJSON(constants) : true;
+        },
+        isUnreferencedShow() {
+            const variableKeys = Object.keys(this.unReferencedConstants);
+            const unreferenced = variableKeys.filter(key => this.unReferencedConstants[key].show_type === 'show');
+            return !!unreferenced.length;
+        },
     },
     watch: {
-      isShow: {
-        handler(val) {
-          if (val) {
-            this.loadInitialData();
-          } else {
-            this.taskFormData = {};
-            this.pipelineTree = {};
-            this.unReferencedConstants = {};
-          }
+        isShow: {
+            handler(val) {
+                if (val) {
+                    this.loadInitialData();
+                } else {
+                    this.taskFormData = {};
+                    this.pipelineTree = {};
+                    this.unReferencedConstants = {};
+                }
+            },
+            immediate: true,
         },
-        immediate: true,
-      },
     },
     methods: {
-      ...mapActions('template/', [
-        'getPreviewTaskTree',
-      ]),
-      ...mapActions('task/', [
-        'createTask',
-      ]),
-      ...mapMutations('template/', [
-        'setPipelineTree',
-      ]),
-      async loadInitialData() {
-        try {
-          this.taskFormData = {
-            mode: 'form',
-            template_id: this.row.id,
-            name: `${this.row.name}_${moment().format('YYYYMMDDHHmmss')}`,
-            creator: this.username,
-            constants: '',
-          };
-          const resp = await this.getPreviewTaskTree({
-            templateId: this.row.id,
-            is_all_nodes: true,
-          });
-          const { pipeline_tree: pipelineTree, constants_not_referred: notReferredConstants } = resp.data;
-          this.setPipelineTree(pipelineTree);
-          this.pipelineTree = pipelineTree;
-          this.unReferencedConstants = notReferredConstants;
-        } catch (error) {
-          console.warn(error);
-        }
-      },
-      async createTaskConfirm() {
-        try {
-          const isFormValid = await this.$refs.createTaskForm.validate();
-          const isParamsValid = this.taskFormData.mode === 'json'
-            ? this.isJsonConstantsValid
-            : this.$refs.taskParamEdit.validate();
+        ...mapActions('template/', ['getPreviewTaskTree']),
+        ...mapActions('task/', ['createTask']),
+        ...mapMutations('template/', ['setPipelineTree']),
+        async loadInitialData() {
+            try {
+                this.taskFormData = {
+                    mode: 'form',
+                    template_id: this.row.id,
+                    name: `${this.row.name}_${moment().format('YYYYMMDDHHmmss')}`,
+                    creator: this.username,
+                    constants: '',
+                    labels: [],
+                };
+                const resp = await this.getPreviewTaskTree({
+                    templateId: this.row.id,
+                    is_all_nodes: true,
+                });
+                const {
+                    pipeline_tree: pipelineTree,
+                    constants_not_referred: notReferredConstants,
+                } = resp.data;
+                this.setPipelineTree(pipelineTree);
+                this.pipelineTree = pipelineTree;
+                this.unReferencedConstants = notReferredConstants;
+            } catch (error) {
+                console.warn(error);
+            }
+        },
+        async createTaskConfirm() {
+            try {
+                const isFormValid = await this.$refs.createTaskForm.validate();
+                const isParamsValid = this.taskFormData.mode === 'json'
+                        ? this.isJsonConstantsValid
+                        : this.$refs.taskParamEdit.validate();
 
-          if (!isFormValid || !isParamsValid) {
-            this.createLoading = false;
-            return;
-          };
+                if (!isFormValid || !isParamsValid) {
+                    this.createLoading = false;
+                    return;
+                }
 
-          this.createLoading = true;
-          const resp = await this.createTask({
-            spaceId: this.spaceId,
-            params: {
-              ...this.taskFormData,
-              constants: this.getParameterConstants(),
-            },
-          });
+                this.createLoading = true;
+                const resp = await this.createTask({
+                    spaceId: this.spaceId,
+                    params: {
+                        ...this.taskFormData,
+                        label_ids: this.taskFormData.labels.map(label => label.id),
+                        constants: this.getParameterConstants(),
+                    },
+                });
 
-          if (resp.result) {
-            this.$bkMessage({
-              message: this.$t('任务创建成功'),
-              theme: 'success',
-            });
-            const { href } = this.$router.resolve({
-              name: 'taskExecute',
-              params: {
-                spaceId: this.spaceId,
-              },
-              query: {
-                instanceId: resp.data.id,
-              },
-            });
-            window.open(href, '_blank');
+                if (resp.result) {
+                    this.$bkMessage({
+                        message: this.$t('任务创建成功'),
+                        theme: 'success',
+                    });
+                    const { href } = this.$router.resolve({
+                        name: 'taskExecute',
+                        params: {
+                            spaceId: this.spaceId,
+                        },
+                        query: {
+                            instanceId: resp.data.id,
+                        },
+                    });
+                    window.open(href, '_blank');
+                    this.$emit('close');
+                }
+            } catch (error) {
+                console.warn(error);
+            } finally {
+                this.createLoading = false;
+            }
+        },
+        getParameterConstants() {
+            const { constants, mode } = this.taskFormData;
+            if (mode === 'json') {
+                return JSON.parse(constants);
+            }
+            const variableData = this.$refs.taskParamEdit.getVariableData();
+            return Object.values(variableData).reduce(
+                (acc, cur) => Object.assign(acc, { [cur.key]: cur.value }),
+                {}
+            );
+        },
+        handleCancel() {
             this.$emit('close');
-          };
-        } catch (error) {
-          console.warn(error);
-        } finally {
-          this.createLoading = false;
-        };
-      },
-      getParameterConstants() {
-        const { constants, mode } = this.taskFormData;
-        if (mode === 'json') {
-          return JSON.parse(constants);
-        };
-        const variableData = this.$refs.taskParamEdit.getVariableData();
-        return Object.values(variableData).reduce((acc, cur) => Object.assign(acc, { [cur.key]: cur.value }), {});
-      },
-      handleCancel() {
-        this.$emit('close');
-      },
+        },
+        handleSelected(val) {
+            this.taskFormData.labels = val;
+        },
+        handleDeleteLabel(val) {
+            this.taskFormData.labels = this.taskFormData.labels.filter(item => item.id !== val);
+        },
     },
-  };
+};
 </script>
 <style lang="scss">
-  @import '../../../../scss/mixins/scrollbar.scss';
-  .create-task-slider {
+@import "../../../../scss/mixins/scrollbar.scss";
+.create-task-slider {
     .bk-sideslider-wrapper {
-      display: flex;
-      flex-direction: column;
+        display: flex;
+        flex-direction: column;
     }
     .bk-sideslider-content {
-      height: max-content;
-      padding: 28px 24px 8px;
-      @include scrollbar;
+        height: max-content;
+        padding: 28px 24px 8px;
+        @include scrollbar;
     }
     .bk-sideslider-footer {
-      height: max-content;
-      padding: 24px 0 24px 124px;
-      background: none !important;
+        height: max-content;
+        padding: 24px 0 24px 124px;
+        background: none !important;
     }
     .bk-button-group {
-      margin-bottom: 8px;
+        margin-bottom: 8px;
     }
     .bk-form-item {
-      .form-wrapper {
-        padding: 12px;
-        background: #F0F1F5;
-        border-radius: 2px;
-      }
-      .code-wrapper {
-        height: 300px;
-      }
-      .valid-error-tips {
-        position: absolute;
-        top: 12px;
-        right: 0;
-        color: #ea3636;
-        cursor: pointer;
-        font-size: 16px;
-      }
-      &:not(:first-child) {
-        margin-top: 28px;
-      }
+        .form-wrapper {
+            padding: 12px;
+            background: #f0f1f5;
+            border-radius: 2px;
+        }
+        .code-wrapper {
+            height: 300px;
+        }
+        .valid-error-tips {
+            position: absolute;
+            top: 12px;
+            right: 0;
+            color: #ea3636;
+            cursor: pointer;
+            font-size: 16px;
+        }
+        &:not(:first-child) {
+            margin-top: 28px;
+        }
     }
     .render-form {
-      .rf-group-name .name {
-        font-weight: normal;
-      }
+        .rf-group-name .name {
+            font-weight: normal;
+        }
     }
     .bk-collapse-item-header {
-      margin-top: 20px;
-      font-weight: 600;
-      color: #313238;
-      background: #e4e6ed;
-      &:hover {
+        margin-top: 20px;
+        font-weight: 600;
         color: #313238;
         background: #e4e6ed;
-      }
+        &:hover {
+            color: #313238;
+            background: #e4e6ed;
+        }
+    }
+}
+.cascade-trigger {
+    display: flex;
+    align-items: center;
+    width: 411px;
+    padding: 0 0 0 8px;
+    background: #ffffff;
+    border: 1px solid #c4c6cc;
+    border-radius: 2px;
+    &.focus {
+        border-color: #3a84ff;
+    }
+    .label-list {
+        flex: 1;
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 6px;
+        height: 100%;
+        min-height: 32px;
+        padding: 7px 0 9px 0;
+        .label-item {
+            height: 16px;
+            font-size: 12px;
+            display: flex;
+            align-items: center;
+            padding: 0 4px;
+            border-radius: 11px;
+            color: #ffffff;
+            .delete-icon {
+                font-size: 16px !important;
+                margin-left: 5px;
+                cursor: pointer;
+            }
+        }
+    }
+    .angle-icon {
+        width: 30px;
+        height: 100%;
+        font-size: 16px !important;
+        color: #979ba5;
+        &.is-show {
+            transform: rotate(180deg);
+        }
     }
-  }
+}
 </style>
diff --git a/frontend/src/views/admin/Space/Template/CreateTemplateDialog.vue b/frontend/src/views/admin/Space/Template/CreateTemplateDialog.vue
index ea057b1e47..35d4783ca9 100644
--- a/frontend/src/views/admin/Space/Template/CreateTemplateDialog.vue
+++ b/frontend/src/views/admin/Space/Template/CreateTemplateDialog.vue
@@ -42,19 +42,49 @@
           :maxlength="64"
           :show-word-limit="true" />
       </bk-form-item>
+      <bk-form-item
+        :label="$t('标签')"
+        :required="true"
+        :property="'labels'">
+        <label-cascade
+          :value="selectedLabels"
+          scope="template"
+          @confirm="handleSelected">
+          <template #trigger="{ list, isShow }">
+            <div :class="['cascade-trigger', { focus: isShow }]">
+              <div class="label-list">
+                <div
+                  v-for="label in list"
+                  :key="label.id"
+                  class="label-item"
+                  :style="{ 'background-color': label.color }">
+                  {{ label.full_path }}
+                  <bk-icon
+                    class="delete-icon"
+                    type="close"
+                    @click="handleDeleteLabel(label.id)" />
+                </div>
+              </div>
+              <bk-icon
+                :class="['angle-icon', { 'is-show': isShow }]"
+                type="angle-down" />
+            </div>
+          </template>
+        </label-cascade>
+      </bk-form-item>
       <bk-form-item>
         <bk-button
           theme="primary"
           :loading="createLoading"
           @click="createTemplateConfirm">
-          {{ $t('提交') }}
+          {{ $t("提交") }}
         </bk-button>
         <bk-button
           ext-cls="mr5"
           theme="default"
           :disabled="createLoading"
           @click="$emit('close')">
-          {{ $t('取消') }}
+          {{ $t("取消") }}
         </bk-button>
       </bk-form-item>
     </bk-form>
@@ -62,102 +92,161 @@
 </template>
 
 <script>
-  import { NAME_REG, STRING_LENGTH } from '@/constants/index.js';
-  import { mapActions, mapState } from 'vuex';
-  export default {
+import { NAME_REG, STRING_LENGTH } from '@/constants/index.js';
+import { mapActions, mapState } from 'vuex';
+import LabelCascade from '../common/LabelCascade.vue';
+export default {
     name: 'CreateTemplateDialog',
+    components: {
+        LabelCascade,
+    },
     props: {
-      isShow: {
-        type: Boolean,
-        default: false,
-      },
+        isShow: {
+            type: Boolean,
+            default: false,
+        },
     },
     data() {
-      return {
-        showCreateTplDialog: false,
-        templateFormData: {
-          name: '',
-          scope_type: '',
-          scope_value: '',
-        },
-        stringLength: STRING_LENGTH,
-        rules: {
-          name: [
-            {
-              required: true,
-              message: this.$t('必填项'),
-              trigger: 'blur',
+        return {
+            showCreateTplDialog: false,
+            templateFormData: {
+                name: '',
+                scope_type: '',
+                scope_value: '',
+                label_ids: [],
             },
-            {
-              regex: NAME_REG,
-              message: `${this.$t('流程名称不能包含')}'‘"”$&<>${this.$t('非法字符')}`,
-              trigger: 'blur',
+            stringLength: STRING_LENGTH,
+            rules: {
+                name: [
+                    {
+                        required: true,
+                        message: this.$t('必填项'),
+                        trigger: 'blur',
+                    },
+                    {
+                        regex: NAME_REG,
+                        message: `${this.$t('流程名称不能包含')}'‘"”$&<>${this.$t('非法字符')}`,
+                        trigger: 'blur',
+                    },
+                ],
             },
-          ],
-        },
-        createLoading: false,
-      };
+            createLoading: false,
+            selectedLabels: [],
+        };
     },
     computed: {
-      ...mapState({
-        spaceId: state => state.spaceId,
-      }),
+        ...mapState({
+            spaceId: state => state.spaceId,
+        }),
     },
     watch: {
-      isShow: {
-        handler(val) {
-          if (!val) {
-            this.templateFormData = {
-              name: '',
-              scope_type: '',
-              scope_value: '',
-            };
-          }
-          this.showCreateTplDialog = val;
+        isShow: {
+            handler(val) {
+                if (!val) {
+                    this.templateFormData = {
+                        name: '',
+                        scope_type: '',
+                        scope_value: '',
+                        label_ids: [],
+                    };
+                }
+                this.showCreateTplDialog = val;
+            },
+            immediate: true,
         },
-        immediate: true,
-      },
     },
     methods: {
-      ...mapActions('template/', [
-        'createTemplate',
-      ]),
-      createTemplateConfirm() {
-        this.$refs.createTemplateForm.validate().then(async (validator) => {
-          if (!validator) {
-            this.createLoading = false;
-            return;
-          }
-          try {
-            this.createLoading = true;
-            const data = { spaceId: this.spaceId };
-            data.params = Object.keys(this.templateFormData).reduce((acc, cur) => {
-              const value = this.templateFormData[cur];
-              if (value) {
-                acc[cur] = value;
-              }
-              return acc;
-            }, {});
-            const resp = await this.createTemplate(data);
-            if (!resp.result) return;
-            this.$bkMessage({
-              message: this.$t('流程创建成功'),
-              theme: 'success',
+        ...mapActions('template/', ['createTemplate']),
+        createTemplateConfirm() {
+            this.$refs.createTemplateForm.validate().then(async (validator) => {
+                if (!validator) {
+                    this.createLoading = false;
+                    return;
+                }
+                try {
+                    this.createLoading = true;
+                    const data = { spaceId: this.spaceId };
+                    data.params = Object.keys(this.templateFormData).reduce(
+                        (acc, cur) => {
+                            const value = this.templateFormData[cur];
+                            if (value) {
+                                acc[cur] = value;
+                            }
+                            return acc;
+                        },
+                        {}
+                    );
+                    const resp = await this.createTemplate(data);
+                    if (!resp.result) return;
+                    this.$bkMessage({
+                        message: this.$t('流程创建成功'),
+                        theme: 'success',
+                    });
+                    this.createLoading = false;
+                    this.$emit('close');
+                    this.$emit('updateList');
+                } catch (error) {
+                    this.createLoading = false;
+                    console.warn(error);
+                }
             });
-            this.createLoading = false;
-            this.$emit('close');
-            this.$emit('updateList');
-          } catch (error) {
-            this.createLoading = false;
-            console.warn(error);
-          }
-        });
-      },
+        },
+        handleSelected(val) {
+            this.selectedLabels = val;
+            this.templateFormData.label_ids = val.map(item => item.id);
+        },
+        handleDeleteLabel(val) {
+            this.selectedLabels = this.selectedLabels.filter(item => item.id !== val);
+            this.templateFormData.label_ids = this.templateFormData.label_ids.filter(item => item !== val);
+        },
     },
-
-  };
+};
 </script>
 
 <style lang="scss" scoped>
-
+.cascade-trigger {
+    display: flex;
+    align-items: center;
+    width: 411px;
+    padding: 0 0 0 8px;
+    background: #ffffff;
+    border: 1px solid #c4c6cc;
+    border-radius: 2px;
+    &.focus {
+        border-color: #3a84ff;
+    }
+    .label-list {
+        flex: 1;
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 6px;
+        height: 100%;
+        min-height: 32px;
+        padding: 7px 0 9px 0;
+        .label-item {
+            height: 16px;
+            font-size: 12px;
+            display: flex;
+            align-items: center;
+            padding: 0 4px;
+            border-radius: 11px;
+            color: #ffffff;
+            .delete-icon {
+                font-size: 16px !important;
+                margin-left: 5px;
+                cursor: pointer;
+            }
+        }
+    }
+    .angle-icon {
+        width: 30px;
+        height: 100%;
+        font-size: 16px !important;
+        color: #979ba5;
+        &.is-show {
+            transform: rotate(180deg);
+        }
+    }
+}
 </style>
diff --git a/frontend/src/views/admin/Space/Template/index.vue b/frontend/src/views/admin/Space/Template/index.vue
index a463f18a84..8ba91ff6a8 100644
--- a/frontend/src/views/admin/Space/Template/index.vue
+++ b/frontend/src/views/admin/Space/Template/index.vue
@@ -3,7 +3,9 @@
     <table-operate
       ref="tableOperate"
       :space-id="spaceId"
-      :placeholder="$t('ID/流程名称/创建人/更新人/启用/所属作用域类型/所属作用域值')"
+      :placeholder="
+        $t('ID/流程名称/标签/创建人/更新人/启用/所属作用域类型/所属作用域值')
+      "
       :search-list="searchList"
       @updateSearchValue="searchValue = $event"
       @changeRequest="handleSearchSelectChange">
@@ -12,12 +14,12 @@
         :disabled="!spaceId"
         class="mr10"
         @click="showCreateTplDialog = true">
-        {{ $t('创建流程') }}
+        {{ $t("创建流程") }}
       </bk-button>
       <bk-button
         v-if="selectedTpls.length"
         @click="onBatchDelete">
-        {{ $t('删除') }}
+        {{ $t("删除") }}
       </bk-button>
     </table-operate>
     <bk-table
@@ -33,7 +35,11 @@
         :render-header="renderHeaderCheckbox">
         <template slot-scope="props">
           <bk-checkbox
-            :value="!!selectedTpls.find(tpl => tpl.id === props.row.id)"
+            :value="
+              !!selectedTpls.find(
+                (tpl) => tpl.id === props.row.id
+              )
+            "
             @change="onToggleTplItem($event, props.row)" />
         </template>
       </bk-table-column>
@@ -45,21 +51,52 @@
         :prop="item.id"
         :render-header="renderTableHeader"
         :width="item.width"
-        show-overflow-tooltip
+        :show-overflow-tooltip="item.id !== 'label'"
         :min-width="item.min_width">
         <template slot-scope="props">
           <div v-if="item.id === 'name'">
-            <router-link
-              class="template-name"
-              :to="{
-                name: 'templatePanel',
-                params: {
-                  templateId: props.row.id,
-                  type: 'view'
-                }
-              }">
+            <bk-button
+              theme="primary"
+              text
+              @click="onNameClick(props.row)">
               {{ props.row.name }}
-            </router-link>
+            </bk-button>
+          </div>
+          <div v-else-if="item.id === 'label'">
+            <label-cascade
+              :value="props.row.labels"
+              scope="template"
+              @confirm="onConfirmEditLabel(props.row, $event)">
+              <template #trigger="{ list, isShow }">
+                <div
+                  v-if="isShow"
+                  class="edit-label-cell">
+                  <div class="label-list">
+                    <span
+                      v-for="label in list"
+                      :key="label.id"
+                      class="label-item"
+                      :style="{
+                        'background-color': label.color,
+                      }">
+                      {{ label.full_path }}
+                      <bk-icon
+                        class="delete-icon"
+                        type="close"
+                        @mousedown.native.stop.prevent="
+                          onDeleteLabel(
+                            props.row,
+                            label
+                          )
+                        " />
+                    </span>
+                  </div>
+                </div>
+                <LabelCell
+                  v-else
+                  :tags="list" />
+              </template>
+            </label-cascade>
           </div>
           <div
             v-else-if="item.id === 'subflow_count'"
@@ -69,23 +106,33 @@
               :disabled="!props.row.subprocess_info || props.row.subprocess_info.length <= 0"
               ext-cls="subflow-popover">
               <span
-                v-if="props.row.subprocess_info && props.row.subprocess_info.length > 0"
+                v-if="props.row.subprocess_info.length > 0"
                 class="blue-text">
                 {{ props.row.subprocess_info.length }}
               </span>
               <span v-else>--</span>
               <bk-button
-                v-if="getSubflowUpdateCount(props.row.subprocess_info) > 0"
+                v-if="
+                  getSubflowUpdateCount(
+                    props.row.subprocess_info
+                  ) > 0
+                "
                 :text="true">
                 <span class="red-text">
                   <span class="blue-text">(</span>
-                  {{ $t(' x 个子流程待更新', { num: getSubflowUpdateCount(props.row.subprocess_info) }) }}
+                  {{
+                    $t(" x 个子流程待更新", {
+                      num: getSubflowUpdateCount(
+                        props.row.subprocess_info
+                      ),
+                    })
+                  }}
                   <span class="blue-text">)</span>
                 </span>
-              <!-- 立即更新 -->
+                <!-- 立即更新 -->
               </bk-button>
               <div
-                v-if="props.row.subprocess_info && props.row.subprocess_info.length > 0"
+                v-if="props.row.subprocess_info.length > 0"
                 slot="content">
                 <ul
                   v-for="sub in props.row.subprocess_info"
@@ -107,7 +154,7 @@
           </div>
           <!-- 其他 -->
           <template v-else>
-            <span>{{ props.row[item.id] || '--' }}</span>
+            <span>{{ props.row[item.id] || "--" }}</span>
           </template>
         </template>
       </bk-table-column>
@@ -120,21 +167,21 @@
             theme="primary"
             text
             @click="onCreateTask(props.row)">
-            {{ $t('新建任务') }}
+            {{ $t("新建任务") }}
           </bk-button>
           <bk-button
             theme="primary"
             class="ml10"
             text
             @click="onCopyTemplate(props.row)">
-            {{ $t('复制') }}
+            {{ $t("复制") }}
           </bk-button>
           <bk-button
             theme="primary"
             class="ml10"
             text
             @click="onDeleteTemplate(props.row)">
-            {{ $t('删除') }}
+            {{ $t("删除") }}
           </bk-button>
         </template>
       </bk-table-column>
@@ -149,11 +196,12 @@
         v-if="selectedTpls.length > 0"
         slot="prepend"
         class="selected-tpl-num">
-        {{ $t('当前已选择 x 条数据', { num: selectedTpls.length }) }}{{ $t('，') }}
+        {{ $t("当前已选择 x 条数据", { num: selectedTpls.length })
+        }}{{ $t("，") }}
         <bk-link
           theme="primary"
           @click="selectedTpls = []">
-          {{ $t('清除选择') }}
+          {{ $t("清除选择") }}
         </bk-link>
       </div>
       <div
@@ -188,15 +236,20 @@
             type="exclamation"
             class="info-icon dialog-icon" />
           <div class="title-text">
-            {{ $t('是否复制该流程？') }}
+            {{ $t("是否复制该流程？") }}
           </div>
         </div>
         <div class="mock-text">
-          <div>{{ $t('关联的mock数据不会同步复制，暂不支持复制带有决策表节点的流程') }}</div>
+          <div>
+            {{
+              $t(
+                "关联的mock数据不会同步复制，暂不支持复制带有决策表节点的流程"
+              )
+            }}
+          </div>
         </div>
-        <bk-checkbox
-          v-model="isSelectCopySubflow">
-          {{ $t('复制包含的子流程') }}
+        <bk-checkbox v-model="isSelectCopySubflow">
+          {{ $t("复制包含的子流程") }}
         </bk-checkbox>
       </div>
     </bk-dialog>
@@ -213,25 +266,52 @@
           <bk-icon
             type="exclamation"
             class="del-error-icon dialog-icon" />
-          <div
-            class="title-text">
-            {{ $t('删除失败') }}
+          <div class="title-text">
+            {{ $t("删除失败") }}
           </div>
         </div>
-        <div class="reference-list-wrapper">
-          <reference-list
-            v-if="referencedProcessList.length > 0"
-            :reference-list="referencedProcessList"
-            :title="$t('当前流程被以下流程引用:')"
-            reference-type="process"
-            :render-header-method="renderReferendLabelHeader" />
-          <reference-list
-            v-if="decisionReferencedList.length > 0"
-            :reference-list="decisionReferencedList"
-            :title="$t('当前流程被以下决策表引用:')"
-            title-class="decision-reference-list"
-            reference-type="decision"
-            :render-header-method="renderDecisonLabelHeader" />
+        <div v-if="referencedProcessList.length > 0">
+          <div>{{ $t("当前流程被以下流程引用:") }}</div>
+          <div
+            v-for="subflowList in referencedProcessList"
+            :key="subflowList[0]">
+            <bk-table
+              :data="subflowList[1].referenced"
+              ext-cls="referenced-process-table"
+              :max-height="197"
+              :dark-header="true"
+              :stripe="true">
+              <bk-table-column
+                :render-header="
+                  (h) =>
+                    renderReferendLabelHeader(
+                      h,
+                      subflowList
+                    )
+                ">
+                <template slot-scope="props">
+                  <div class="reference-list">
+                    <span>{{
+                      props.row.root_template_name
+                    }}</span>
+                    <router-link
+                      :to="{
+                        name: 'templatePanel',
+                        params: {
+                          templateId:
+                            props.row
+                              .root_template_id,
+                          type: 'view',
+                        },
+                      }">
+                      <i
+                        class="common-icon-box-top-right-corner icon-view-sub" />
+                    </router-link>
+                  </div>
+                </template>
+              </bk-table-column>
+            </bk-table>
+          </div>
         </div>
       </div>
     </bk-dialog>
@@ -239,515 +319,556 @@
 </template>
 
 <script>
-  import { mapActions, mapMutations } from 'vuex';
-  import CancelRequest from '@/api/cancelRequest.js';
-  import NoData from '@/components/common/base/NoData.vue';
-  import ReferenceList from './ReferenceList.vue';
-  import moment from 'moment-timezone';
-  import tableHeader from '@/mixins/tableHeader.js';
-  import tableCommon from '../mixins/tableCommon.js';
-  import TableOperate from '../common/TableOperate.vue';
-  import CreateTaskSideslider from './CreateTaskSideslider.vue';
-  import CreateTemplateDialog from './CreateTemplateDialog.vue';
-  import i18n from '@/config/i18n/index.js';
+import { mapActions, mapMutations } from 'vuex';
+import CancelRequest from '@/api/cancelRequest.js';
+import NoData from '@/components/common/base/NoData.vue';
+import moment from 'moment-timezone';
+import tableHeader from '@/mixins/tableHeader.js';
+import tableCommon from '../mixins/tableCommon.js';
+import TableOperate from '../common/TableOperate.vue';
+import CreateTaskSideslider from './CreateTaskSideslider.vue';
+import CreateTemplateDialog from './CreateTemplateDialog.vue';
+import LabelCascade from '../common/LabelCascade.vue';
+import LabelCell from './label-cell.vue';
+import i18n from '@/config/i18n/index.js';
 
-  const TABLE_FIELDS = [
+const TABLE_FIELDS = [
+    {
+        id: 'id',
+        label: 'ID',
+        disabled: true,
+        width: 100,
+    },
+    {
+        id: 'scope_type',
+        label: i18n.t('所属作用域类型'),
+        width: 160,
+    },
     {
-      id: 'id',
-      label: 'ID',
-      disabled: true,
-      width: 100,
+        id: 'scope_value',
+        label: i18n.t('所属作用域值'),
+        width: 160,
     },
     {
-      id: 'scope_type',
-      label: i18n.t('所属作用域类型'),
-      width: 160,
+        id: 'name',
+        label: i18n.t('流程名称'),
+        disabled: true,
+        min_width: 250,
     },
     {
-      id: 'scope_value',
-      label: i18n.t('所属作用域值'),
-      width: 160,
+        id: 'label',
+        label: i18n.t('标签'),
+        width: 272,
     },
     {
-      id: 'name',
-      label: i18n.t('流程名称'),
-      disabled: true,
-      min_width: 250,
+        id: 'creator',
+        label: i18n.t('创建人'),
+        width: 160,
     },
     {
-      id: 'creator',
-      label: i18n.t('创建人'),
-      width: 160,
+        id: 'create_at',
+        label: i18n.t('创建时间'),
+        width: 280,
     },
     {
-      id: 'create_at',
-      label: i18n.t('创建时间'),
-      width: 280,
+        id: 'subflow_count',
+        label: i18n.t('子流程数量'),
+        width: 200,
     },
     {
-      id: 'subflow_count',
-      label: i18n.t('子流程数量'),
-      width: 200,
+        id: 'updated_by',
+        label: i18n.t('更新人'),
+        width: 160,
     },
     {
-      id: 'updated_by',
-      label: i18n.t('更新人'),
-      width: 160,
+        id: 'update_at',
+        label: i18n.t('更新时间'),
+        width: 280,
     },
     {
-      id: 'update_at',
-      label: i18n.t('更新时间'),
-      width: 280,
+        id: 'is_enabled',
+        label: i18n.t('启用'),
+        width: 160,
     },
+];
+const SEARCH_LIST = [
     {
-      id: 'is_enabled',
-      label: i18n.t('启用'),
-      width: 160,
+        id: 'id',
+        name: 'ID',
     },
-  ];
-  const SEARCH_LIST = [
     {
-      id: 'id',
-      name: 'ID',
+        id: 'name',
+        name: i18n.t('流程名称'),
+        isDefaultOption: true,
     },
     {
-      id: 'name',
-      name: i18n.t('流程名称'),
-      isDefaultOption: true,
+        id: 'label',
+        name: i18n.t('标签'),
     },
     {
-      id: 'creator',
-      name: i18n.t('创建人'),
+        id: 'creator',
+        name: i18n.t('创建人'),
     },
     {
-      id: 'updated_by',
-      name: i18n.t('更新人'),
+        id: 'updated_by',
+        name: i18n.t('更新人'),
     },
     {
-      id: 'is_enabled',
-      name: i18n.t('启用'),
-      children: [
-        { id: 'true', name: true },
-        { id: 'false', name: false },
-      ],
+        id: 'is_enabled',
+        name: i18n.t('启用'),
+        children: [
+            { id: 'true', name: true },
+            { id: 'false', name: false },
+        ],
     },
     {
-      id: 'scope_type',
-      name: i18n.t('所属作用域类型'),
+        id: 'scope_type',
+        name: i18n.t('所属作用域类型'),
     },
     {
-      id: 'scope_value',
-      name: i18n.t('所属作用域值'),
+        id: 'scope_value',
+        name: i18n.t('所属作用域值'),
     },
-  ];
-  export default {
+];
+export default {
     name: 'TemplateList',
     components: {
-      NoData,
-      ReferenceList,
-      TableOperate,
-      CreateTemplateDialog,
-      CreateTaskSideslider,
+        NoData,
+        TableOperate,
+        CreateTemplateDialog,
+        CreateTaskSideslider,
+        LabelCascade,
+        LabelCell,
     },
     mixins: [tableHeader, tableCommon],
     data() {
-      return {
-        templateList: [],
-        selectRow: {},
-        showCreateTaskSlider: false,
-        showCreateTplDialog: false,
-        selectedTpls: [], // 选中的流程模板
-        batchDeleting: false,
-        deleting: false,
-        tableFields: TABLE_FIELDS,
-        defaultSelected: ['id', 'name', 'creator', 'create_at', 'subflow_count', 'update_by', 'update_at'],
-        setting: {
-          fieldList: TABLE_FIELDS,
-          selectedFields: [],
-          size: 'small',
-        },
-        dateFields: ['create_at', 'update_at'],
-        searchList: SEARCH_LIST,
-        pageType: 'templateList', // 页面类型，在mixins中分页表格头显示使用
-        isShowCopyDialog: false,
-        isShowDelDialog: false,
-        isSelectCopySubflow: false,
-        copyTemplateId: null,
-        referencedProcessList: [], // 引用的流程列表
-        decisionReferencedList: [], // 流程被决策表引用的决策表列表
-      };
+        return {
+            templateList: [],
+            selectRow: {},
+            showCreateTaskSlider: false,
+            showCreateTplDialog: false,
+            selectedTpls: [], // 选中的流程模板
+            batchDeleting: false,
+            deleting: false,
+            tableFields: TABLE_FIELDS,
+            defaultSelected: [
+                'id',
+                'name',
+                'label',
+                'creator',
+                'create_at',
+                'subflow_count',
+                'update_by',
+                'update_at',
+            ],
+            setting: {
+                fieldList: TABLE_FIELDS,
+                selectedFields: [],
+                size: 'small',
+            },
+            dateFields: ['create_at', 'update_at'],
+            searchList: SEARCH_LIST,
+            pageType: 'templateList', // 页面类型，在mixins中分页表格头显示使用
+            isShowCopyDialog: false,
+            isShowDelDialog: false,
+            isSelectCopySubflow: false,
+            copyTemplateId: null,
+            referencedProcessList: [], // 引用的流程列表
+        };
     },
     computed: {
-      crtPageSelectedAll() {
-        return this.templateList.length > 0
-          && this.templateList.every(item => this.selectedTpls.find(tpl => tpl.id === item.id));
-      },
+        crtPageSelectedAll() {
+            return (
+                this.templateList.length > 0
+                && this.templateList.every(item => this.selectedTpls.find(tpl => tpl.id === item.id))
+            );
+        },
     },
     methods: {
-      ...mapActions('templateList/', [
-        'loadTemplateList',
-        'deleteTemplate',
-        'copyTemplate',
-      ]),
-      ...mapActions('task/', [
-        'createTask',
-      ]),
-      ...mapMutations('template/', [
-        'setSpaceId',
-      ]),
-      renderReferendLabelHeader(h, value) {
-        return h('div', [
-          h('span', i18n.t('流程')),
-          h(
-'bk-popover',
-            {
-              props: {
-                content: value[1].sub_template_name,
-              },
-            },
-            [
-              h('span', ` (${value[0]}) `),
-            ]
-          ),
-          h('span', i18n.t('包含 x 个流程', {
-            num: value[1].referenced.length,
-          })),
-        ]);
-      },
-      renderDecisonLabelHeader(h, value) {
-        return h('div', [
-          h('span', i18n.t('流程')),
-          h(
-'bk-popover',
-            {
-              props: {
-                content: value[1].template_name,
-              },
-            },
-            [
-              h('span', ` (${value[0]}) `),
-            ]
-          ),
-          h('span', i18n.t('被以下决策表引用')),
-        ]);
-      },
-      async getTemplateList() {
-        try {
-          if (!this.spaceId) return;
-          this.listLoading = true;
-          const data = this.getQueryData();
-          const resp = await this.loadTemplateList(data);
-          this.templateList = resp.data.results;
-          this.pagination.count = resp.data.count;
-          const totalPage = Math.ceil(this.pagination.count / this.pagination.limit);
-          if (!totalPage) {
-            this.totalPage = 1;
-          } else {
-            this.totalPage = totalPage;
-          }
-        } catch (error) {
-          console.warn(error);
-        } finally {
-          this.listLoading = false;
-        }
-      },
-      getQueryData() {
-        const source = new CancelRequest();
-        const {
-          name,
-          id,
-          creator,
-          updated_by,
-          create_at: createAt,
-          update_at: updateAt,
-          scope_type,
-          scope_value,
-          is_enabled,
-          limit = this.pagination.limit,
-          current = this.pagination.current,
-        } = this.requestData;
-        const data = {
-          space_id: this.spaceId,
-          limit,
-          offset: (current - 1) * limit,
-          name__icontains: name,
-          id,
-          creator,
-          updated_by,
-          scope_type,
-          scope_value,
-          is_enabled,
-          cancelToken: source.token,
-        };
-        if (createAt && createAt[0] && createAt[1]) {
-          data.create_at__gte = moment(createAt[0]).format('YYYY-MM-DD HH:mm:ss');
-          data.create_at__lte = moment(createAt[1]).format('YYYY-MM-DD HH:mm:ss');
-        }
-        if (updateAt && updateAt[0] && updateAt[1]) {
-          data.update_at__gte = moment(updateAt[0]).format('YYYY-MM-DD HH:mm:ss');
-          data.update_at__lte = moment(updateAt[1]).format('YYYY-MM-DD HH:mm:ss');
-        }
-        return data;
-      },
-      onCreateTask(row) {
-        this.selectRow = row;
-        this.showCreateTaskSlider = true;
-        this.setSpaceId(this.spaceId);
-      },
-      renderHeaderCheckbox(h) {
-        const self = this;
-        return h('div', {
-          class: {
-            'select-all-cell': true,
-            'full-selected': this.pagination.count === this.selectedTpls.length,
-          },
-        }, [
-          h('bk-checkbox', {
-            props: {
-              value: this.crtPageSelectedAll,
-            },
-            on: {
-              change(val) {
-                self.onToggleTplAll(val);
-              },
-            },
-          }),
-          h('bk-popover', {
-            props: {
-              placement: 'bottom',
-              theme: 'light',
-              distance: 0,
-              'tippy-options': {
-                hideOnClick: false,
-              },
-              'ext-cls': 'select-all-tpl-popover',
-            },
-          }, [
-            h('i', {
-              class: 'bk-icon icon-angle-down',
-            }),
-            h('div', {
-              slot: 'content',
-            }, [
-              h('div', {
-                class: 'mode-item',
-                on: {
-                  click() {
-                    self.onSelectTplAll('current');
-                  },
+        ...mapActions('templateList/', [
+            'loadTemplateList',
+            'deleteTemplate',
+            'copyTemplate',
+            'updateTemplateLabel',
+        ]),
+        ...mapActions('task/', ['createTask']),
+        ...mapMutations('template/', ['setSpaceId', 'setTemplateLabel']),
+        renderReferendLabelHeader(h, value) {
+            return h('div', [
+                h('span', i18n.t('流程')),
+                h(
+                    'bk-popover',
+                    {
+                        props: {
+                            content: value[1].sub_template_name,
+                        },
+                    },
+                    [h('span', ` (${value[0]}) `)]
+                ),
+                h(
+                    'span',
+                    i18n.t('包含 x 个流程', {
+                        num: value[1].referenced.length,
+                    })
+                ),
+            ]);
+        },
+        async getTemplateList() {
+            try {
+                if (!this.spaceId) return;
+                this.listLoading = true;
+                const data = this.getQueryData();
+                const resp = await this.loadTemplateList(data);
+                this.templateList = resp.data.results;
+                this.pagination.count = resp.data.count;
+                const totalPage = Math.ceil(this.pagination.count / this.pagination.limit);
+                if (!totalPage) {
+                    this.totalPage = 1;
+                } else {
+                    this.totalPage = totalPage;
+                }
+            } catch (error) {
+                console.warn(error);
+            } finally {
+                this.listLoading = false;
+            }
+        },
+        getQueryData() {
+            const source = new CancelRequest();
+            const {
+                name,
+                id,
+                label,
+                creator,
+                updated_by,
+                create_at: createAt,
+                update_at: updateAt,
+                scope_type,
+                scope_value,
+                is_enabled,
+                limit = this.pagination.limit,
+                current = this.pagination.current,
+            } = this.requestData;
+            const data = {
+                space_id: this.spaceId,
+                limit,
+                offset: (current - 1) * limit,
+                name__icontains: name,
+                label,
+                id,
+                creator,
+                updated_by,
+                scope_type,
+                scope_value,
+                is_enabled,
+                cancelToken: source.token,
+            };
+            if (createAt && createAt[0] && createAt[1]) {
+                data.create_at__gte = moment(createAt[0]).format('YYYY-MM-DD HH:mm:ss');
+                data.create_at__lte = moment(createAt[1]).format('YYYY-MM-DD HH:mm:ss');
+            }
+            if (updateAt && updateAt[0] && updateAt[1]) {
+                data.update_at__gte = moment(updateAt[0]).format('YYYY-MM-DD HH:mm:ss');
+                data.update_at__lte = moment(updateAt[1]).format('YYYY-MM-DD HH:mm:ss');
+            }
+            return data;
+        },
+        onCreateTask(row) {
+            this.selectRow = row;
+            this.showCreateTaskSlider = true;
+            this.setSpaceId(this.spaceId);
+        },
+        renderHeaderCheckbox(h) {
+            const self = this;
+            return h(
+                'div',
+                {
+                    class: {
+                        'select-all-cell': true,
+                        'full-selected':
+                            this.pagination.count === this.selectedTpls.length,
+                    },
                 },
-              }, [this.$t('本页全选')]),
-              h('div', {
-                class: 'mode-item',
-                on: {
-                  click() {
-                    self.onSelectTplAll('full');
-                  },
+                [
+                    h('bk-checkbox', {
+                        props: {
+                            value: this.crtPageSelectedAll,
+                        },
+                        on: {
+                            change(val) {
+                                self.onToggleTplAll(val);
+                            },
+                        },
+                    }),
+                    h(
+                        'bk-popover',
+                        {
+                            props: {
+                                placement: 'bottom',
+                                theme: 'light',
+                                distance: 0,
+                                'tippy-options': {
+                                    hideOnClick: false,
+                                },
+                                'ext-cls': 'select-all-tpl-popover',
+                            },
+                        },
+                        [
+                            h('i', {
+                                class: 'bk-icon icon-angle-down',
+                            }),
+                            h(
+                                'div',
+                                {
+                                    slot: 'content',
+                                },
+                                [
+                                    h(
+                                        'div',
+                                        {
+                                            class: 'mode-item',
+                                            on: {
+                                                click() {
+                                                    self.onSelectTplAll('current');
+                                                },
+                                            },
+                                        },
+                                        [this.$t('本页全选')]
+                                    ),
+                                    h(
+                                        'div',
+                                        {
+                                            class: 'mode-item',
+                                            on: {
+                                                click() {
+                                                    self.onSelectTplAll('full');
+                                                },
+                                            },
+                                        },
+                                        [this.$t('跨页全选')]
+                                    ),
+                                ]
+                            ),
+                        ]
+                    ),
+                ]
+            );
+        },
+        // 本页全选、取消本页/跨页全选
+        onToggleTplAll(val) {
+            if (val) {
+                this.onSelectTplAll('current');
+            } else {
+                if (this.selectedTpls.length === this.pagination.count) {
+                    this.selectedTpls = [];
+                } else {
+                    this.templateList.forEach((tpl) => {
+                        const index = this.selectedTpls.findIndex(item => item.id === tpl.id);
+                        this.selectedTpls.splice(index, 1);
+                    });
+                }
+            }
+        },
+        // 本页全选、跨页全选
+        async onSelectTplAll(type) {
+            if (type === 'full') {
+                const data = this.getQueryData();
+                data.limit = -1;
+                data.offset = 0;
+                const resp = await this.loadTemplateList(data);
+                if (resp.result) {
+                    this.selectedTpls = resp.data.results.slice(0);
+                }
+            } else {
+                this.templateList.forEach((item) => {
+                    if (!this.selectedTpls.find(tpl => tpl.id === item.id)) {
+                        this.selectedTpls.push(item);
+                    }
+                });
+            }
+        },
+        onToggleTplItem(val, tpl) {
+            if (val) {
+                this.selectedTpls.push(tpl);
+            } else {
+                const index = this.selectedTpls.findIndex(item => item.id === tpl.id);
+                this.selectedTpls.splice(index, 1);
+            }
+        },
+        onBatchDelete() {
+            if (this.selectedTpls.length === 0 || this.batchDeleting) {
+                return;
+            }
+            this.$bkInfo({
+                title: this.$t('确认删除所选的 {0} 项流程吗?', [
+                    this.selectedTpls.length,
+                ]),
+                maskClose: false,
+                width: 450,
+                confirmLoading: true,
+                confirmFn: async () => {
+                    await this.batchDeleteConfirm();
                 },
-              }, [this.$t('跨页全选')]),
-            ]),
-          ]),
-        ]);
-      },
-      // 本页全选、取消本页/跨页全选
-      onToggleTplAll(val) {
-        if (val) {
-          this.onSelectTplAll('current');
-        } else {
-          if (this.selectedTpls.length === this.pagination.count) {
-            this.selectedTpls = [];
-          } else {
-            this.templateList.forEach((tpl) => {
-              const index = this.selectedTpls.findIndex(item => item.id === tpl.id);
-              this.selectedTpls.splice(index, 1);
             });
-          }
-        }
-      },
-      // 本页全选、跨页全选
-      async onSelectTplAll(type) {
-        if (type === 'full') {
-          const data = this.getQueryData();
-          data.limit = -1;
-          data.offset = 0;
-          const resp = await this.loadTemplateList(data);
-          if (resp.result) {
-            this.selectedTpls = resp.data.results.slice(0);
-          }
-        } else {
-          this.templateList.forEach((item) => {
-            if (!this.selectedTpls.find(tpl => tpl.id === item.id)) {
-              this.selectedTpls.push(item);
+        },
+        async batchDeleteConfirm() {
+            this.referencedProcessList = [];
+            const data = {
+                space_id: this.spaceId,
+                is_full: this.pagination.count === this.selectedTpls.length,
+                template_ids: this.selectedTpls.map(tpl => tpl.id),
+            };
+            const res = await this.deleteTemplate(data);
+            if (res.result) {
+                this.selectedTpls = [];
+                this.pagination.current = 1;
+                this.updateUrl({ current: 1 });
+                this.getTemplateList();
+                this.$bkMessage({
+                    message: this.$t('流程删除成功！'),
+                    theme: 'success',
+                });
+            } else {
+                if (res.data.sub_root_map) {
+                    this.referencedProcessList = Object.entries(res.data.sub_root_map);
+                }
+                this.isShowDelDialog = true;
+                return;
             }
-          });
-        }
-      },
-      onToggleTplItem(val, tpl) {
-        if (val) {
-          this.selectedTpls.push(tpl);
-        } else {
-          const index = this.selectedTpls.findIndex(item => item.id === tpl.id);
-          this.selectedTpls.splice(index, 1);
-        }
-      },
-      onBatchDelete() {
-        if (this.selectedTpls.length === 0 || this.batchDeleting) {
-          return;
-        }
-        this.$bkInfo({
-          title: this.$t('确认删除所选的 {0} 项流程吗?', [this.selectedTpls.length]),
-          maskClose: false,
-          width: 450,
-          confirmLoading: true,
-          confirmFn: async () => {
-            await this.batchDeleteConfirm();
-          },
-        });
-      },
-      async batchDeleteConfirm() {
-        this.referencedProcessList = [];
-        this.decisionReferencedList = [];
-        const data = {
-          space_id: this.spaceId,
-          is_full: this.pagination.count === this.selectedTpls.length,
-          template_ids: this.selectedTpls.map(tpl => tpl.id),
-        };
-        const res = await this.deleteTemplate(data);
-        if (res.result) {
-          this.selectedTpls = [];
-          this.pagination.current = 1;
-          this.updateUrl({ current: 1 });
-          this.getTemplateList();
-          this.$bkMessage({
-            message: this.$t('流程删除成功！'),
-            theme: 'success',
-          });
-        } else {
-          if (res.data.sub_root_map) {
-            this.referencedProcessList = Object.entries(res.data.sub_root_map);
-          }
-          if (res.data.decision_detail) {
-            this.decisionReferencedList = Object.entries(res.data.decision_detail);
-          }
-          this.isShowDelDialog = true;
-          return;
-        }
-        return Promise.resolve();
-      },
-      getSubflowUpdateCount(subflowList) {
-        if (!subflowList || !Array.isArray(subflowList)) {
-          return 0;
-        }
-        try {
-          return subflowList.filter(subItem => typeof subItem === 'object' && subItem !== null && subItem.expired).length;
-        } catch (e) {
-          console.error(e);
-          return 0;
-        }
-      },
-      onCopyTemplate(template) {
-        this.isShowCopyDialog = true;
-        this.copyTemplateId = template.id;
-      },
-      async onCopyConfirm() {
-        try {
-          const resp = await this.copyTemplate({
-            space_id: this.spaceId,
-            template_id: this.copyTemplateId,
-            copy_subprocess: this.isSelectCopySubflow,
-          });
-          if (!resp.result) return;
-          this.getTemplateList();
-          this.$bkMessage({
-            message: this.$t('流程复制成功！'),
-            theme: 'success',
-          });
-          this.isSelectCopySubflow = false;
-        } catch (error) {
-          console.warn(error);
-        }
-      },
-      onDeleteTemplate(template) {
-        const h = this.$createElement;
-        this.$bkInfo({
-          subHeader: h('div', { class: 'custom-header' }, [
-            h('div', {
-              class: 'custom-header-title',
-              directives: [{
-                name: 'bk-overflow-tips',
-              }],
-            }, [this.$t('确认删除流程"{0}"?', [template.name])]),
-          ]),
-          extCls: 'dialog-custom-header-title',
-          maskClose: false,
-          width: 450,
-          confirmLoading: true,
-          cancelText: this.$t('取消'),
-          confirmFn: async () => {
-            await this.onDeleteConfirm(template);
-          },
-        });
-      },
-      async onDeleteConfirm(template) {
-        this.referencedProcessList = [];
-        this.decisionReferencedList = [];
-        if (this.deleting) return;
-        this.deleting = true;
-        try {
-          const data = {
-            space_id: this.spaceId,
-            template_ids: [template.id],
-          };
-          const resp = await this.deleteTemplate(data);
-          if (resp.result === false) {
-            if (resp.data.sub_root_map) {
-                this.referencedProcessList = Object.entries(resp.data.sub_root_map);
+            return Promise.resolve();
+        },
+        getSubflowUpdateCount(subflowList) {
+            return subflowList.filter(sub => sub.expired).length;
+        },
+        onCopyTemplate(template) {
+            this.isShowCopyDialog = true;
+            this.copyTemplateId = template.id;
+        },
+        async onCopyConfirm() {
+            try {
+                const resp = await this.copyTemplate({
+                    space_id: this.spaceId,
+                    template_id: this.copyTemplateId,
+                    copy_subprocess: this.isSelectCopySubflow,
+                });
+                if (!resp.result) return;
+                this.getTemplateList();
+                this.$bkMessage({
+                    message: this.$t('流程复制成功！'),
+                    theme: 'success',
+                });
+                this.isSelectCopySubflow = false;
+            } catch (error) {
+                console.warn(error);
             }
-            if (resp.data.decision_detail) {
-              this.decisionReferencedList = Object.entries(resp.data.decision_detail);
+        },
+        onDeleteTemplate(template) {
+            const h = this.$createElement;
+            this.$bkInfo({
+                subHeader: h('div', { class: 'custom-header' }, [
+                    h(
+                        'div',
+                        {
+                            class: 'custom-header-title',
+                            directives: [
+                                {
+                                    name: 'bk-overflow-tips',
+                                },
+                            ],
+                        },
+                        [this.$t('确认删除流程"{0}"?', [template.name])]
+                    ),
+                ]),
+                extCls: 'dialog-custom-header-title',
+                maskClose: false,
+                width: 450,
+                confirmLoading: true,
+                cancelText: this.$t('取消'),
+                confirmFn: async () => {
+                    await this.onDeleteConfirm(template);
+                },
+            });
+        },
+        async onDeleteConfirm(template) {
+            this.referencedProcessList = [];
+            if (this.deleting) return;
+            this.deleting = true;
+            try {
+                const data = {
+                    space_id: this.spaceId,
+                    template_ids: [template.id],
+                };
+                const resp = await this.deleteTemplate(data);
+                if (resp.result === false) {
+                    if (resp.data.sub_root_map) {
+                        this.referencedProcessList = Object.entries(resp.data.sub_root_map);
+                    }
+                    this.isShowDelDialog = true;
+                    return;
+                }
+                if (this.selectedTpls.find(tpl => tpl.id === template.id)) {
+                    const index = this.selectedTpls.findIndex(tpl => tpl.id === template.id);
+                    this.selectedTpls.splice(index, 1);
+                }
+                // 最后一页最后一条删除后，往前翻一页
+                if (
+                    this.pagination.current > 1
+                    && this.totalPage === this.pagination.current
+                    && this.pagination.count
+                        - (this.totalPage - 1) * this.pagination.limit
+                        === 1
+                ) {
+                    this.pagination.current -= 1;
+                }
+                this.getTemplateList();
+                this.updateUrl({ current: 1 });
+                this.$bkMessage({
+                    message: this.$t('流程') + this.$t('删除成功！'),
+                    theme: 'success',
+                });
+            } catch (e) {
+                console.log(e);
+            } finally {
+                this.deleting = false;
             }
-            this.isShowDelDialog = true;
-            return;
-          };
-          if (this.selectedTpls.find(tpl => tpl.id === template.id)) {
-            const index = this.selectedTpls.findIndex(tpl => tpl.id === template.id);
-            this.selectedTpls.splice(index, 1);
-          }
-          // 最后一页最后一条删除后，往前翻一页
-          if (
-            this.pagination.current > 1
-            && this.totalPage === this.pagination.current
-            && this.pagination.count - (this.totalPage - 1) * this.pagination.limit === 1
-          ) {
-            this.pagination.current -= 1;
-          }
-          this.getTemplateList();
-          this.updateUrl({ current: 1 });
-          this.$bkMessage({
-            message: this.$t('流程') + this.$t('删除成功！'),
-            theme: 'success',
-          });
-        } catch (e) {
-          console.log(e);
-        } finally {
-          this.deleting = false;
-        }
-      },
+        },
+        onDeleteLabel(row, label) {
+            const filterLabel = row.labels.filter(item => item.id !== label.id);
+            this.$set(row, 'labels', filterLabel);
+        },
+        async onConfirmEditLabel(template, labels) {
+            const data = {
+                template_id: template.id,
+                label_ids: labels.map(item => item.id),
+            };
+            await this.updateTemplateLabel(data);
+            this.getTemplateList();
+        },
+        onNameClick(row) {
+            this.setTemplateLabel(row.labels);
+            this.$router.push({
+                name: 'templatePanel',
+                params: {
+                    templateId: row.id,
+                    type: 'view',
+                },
+            });
+        },
     },
-  };
+};
 </script>
 
 <style lang="scss" scoped>
-  ::v-deep .code-form-item {
+::v-deep .code-form-item {
     .bk-form-content {
-      height: 300px;
-      .code-wrapper {
-        position: relative;
-        height: 100%;
-      }
+        height: 300px;
+        .code-wrapper {
+            position: relative;
+            height: 100%;
+        }
     }
-  }
-  .selected-tpl-num {
+}
+.selected-tpl-num {
     height: 32px;
     display: flex;
     align-items: center;
@@ -756,175 +877,198 @@
     background: #f0f1f5;
     border-bottom: 1px solid #dfe0e5;
     ::v-deep .bk-link-text {
-      margin-left: 6px;
-      font-size: 12px;
-      line-height: 1;
+        margin-left: 6px;
+        font-size: 12px;
+        line-height: 1;
     }
-  }
-  ::v-deep .select-all-cell {
+}
+::v-deep .select-all-cell {
     display: flex;
     align-items: center;
     &.full-selected {
-      .bk-form-checkbox {
-        .bk-checkbox {
-          background: #ffffff;
-          &:after {
-            border-color: #3a84ff;
-          }
+        .bk-form-checkbox {
+            .bk-checkbox {
+                background: #ffffff;
+                &:after {
+                    border-color: #3a84ff;
+                }
+            }
         }
-      }
     }
     .icon-angle-down {
-      margin-left: 2px;
-      font-size: 18px;
-      color: #979ba5;
+        margin-left: 2px;
+        font-size: 18px;
+        color: #979ba5;
     }
-  }
-  ::v-deep .bk-table-empty-text {
+}
+::v-deep .bk-table-empty-text {
     width: 100%;
-  }
-  ::v-deep .bk-dialog-wrapper .bk-dialog-body {
+}
+::v-deep .bk-dialog-wrapper .bk-dialog-body {
     padding: 3px 32px 26px;
-  }
-  .copy-del-dialog-content{
-     .title{
-      display: flex;
-      align-items: center;
-      flex-direction: column;
-      .dialog-icon{
-        font-size: 26px !important;
-        border-radius: 50%;
-        width: 42px;
-        height: 42px;
-        line-height: 42px;
-      }
-      .info-icon{
-        background-color: #ffe8c3;
-        color: #ff9c01;
-      }
-      .del-error-icon{
-        background-color: #FFDDDD;
-        color: #ea3636;
-      }
-      .title-text{
-        font-size: 20px;
-        color: #313238;
-        line-height: 32px;
-        margin-top: 19px;
-        margin-bottom: 16px;
-
-      }
-    }
-    .reference-list-wrapper{
-      max-height: 350px;
-      overflow: auto;
-    }
-    .mock-text{
-      padding: 12px 16px;
-      background: #F5F6FA;
-      border-radius: 2px;
-      color: #4D4F56;
-      margin-bottom: 13px;
+}
+.copy-del-dialog-content {
+    .title {
+        display: flex;
+        align-items: center;
+        flex-direction: column;
+        .dialog-icon {
+            font-size: 26px !important;
+            border-radius: 50%;
+            width: 42px;
+            height: 42px;
+            line-height: 42px;
+        }
+        .info-icon {
+            background-color: #ffe8c3;
+            color: #ff9c01;
+        }
+        .del-error-icon {
+            background-color: #ffdddd;
+            color: #ea3636;
+        }
+        .title-text {
+            font-size: 20px;
+            color: #313238;
+            line-height: 32px;
+            margin-top: 19px;
+            margin-bottom: 16px;
+        }
     }
-  }
-  ::v-deep .del-dialog{
-    .bk-dialog-body{
-      padding-bottom: 38px;
+    .mock-text {
+        padding: 12px 16px;
+        background: #f5f6fa;
+        border-radius: 2px;
+        color: #4d4f56;
+        margin-bottom: 13px;
     }
-    .tpl-error-message{
-      display: flex;
-      justify-content: center;
-      padding: 12px 16px;
-      background: #F5F6FA;
-      border-radius: 2px;
+}
+::v-deep .del-dialog {
+    .bk-dialog-body {
+        padding-bottom: 38px;
     }
-  }
+}
 
-  ::v-deep .bk-dialog-footer{
+::v-deep .bk-dialog-footer {
     border: none;
-    background-color:#FFFFFF;
+    background-color: #ffffff;
     padding: 0px 24px 24px;
-  }
-  ::v-deep .referenced-process-table{
+}
+::v-deep .referenced-process-table {
     margin-top: 16px;
-    .bk-table-header-wrapper{
-      height: 32px;
-      display: flex;
-      align-items: center;
-
-      .cell{
+    .bk-table-header-wrapper {
         height: 32px;
-        line-height: 32px;
-      }
+        display: flex;
+        align-items: center;
+
+        .cell {
+            height: 32px;
+            line-height: 32px;
+        }
     }
-    .bk-table-header-label{
-      font-size: 14px;
-      color: #313238;
-      line-height: 22px
+    .bk-table-header-label {
+        font-size: 14px;
+        color: #313238;
+        line-height: 22px;
     }
-    .bk-table-body-wrapper{
-      scrollbar-color: #DCDEE5 transparent;
-      scrollbar-width: thin;
-      &::-webkit-scrollbar-button {
-        display: none !important;
-      }
-      .bk-table-row td{
-        height: 32px;
-        line-height: 32px;
-      }
+    .bk-table-body-wrapper {
+        scrollbar-color: #dcdee5 transparent;
+        scrollbar-width: thin;
+        &::-webkit-scrollbar-button {
+            display: none !important;
+        }
+        .bk-table-row td {
+            height: 32px;
+            line-height: 32px;
+        }
     }
-  }
-  ::v-deep .subflow_update{
+}
+::v-deep .subflow_update {
     cursor: pointer;
-    .blue-text{
-      color: #3a84ff;
+    .blue-text {
+        color: #3a84ff;
+    }
+    .red-text {
+        color: #ff5757;
     }
-    .red-text{
-      color: #ff5757;
+}
+.cascade-trigger {
+    height: 32px;
+    width: 242px;
+}
+.edit-label-cell {
+    width: 242px;
+    border: 1px solid #3a84ff;
+    padding: 6px 16px;
+    max-height: 120px;
+    min-height: 20px;
+    overflow: auto;
+    .label-list {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 6px;
+        height: 100%;
+        overflow: auto;
+        .label-item {
+            height: 16px;
+            line-height: 16px;
+            font-size: 12px;
+            display: flex;
+            align-items: center;
+            padding: 0 6px;
+            border-radius: 11px;
+            color: #ffffff;
+            .delete-icon {
+                font-size: 16px !important;
+                margin-left: 5px;
+                cursor: pointer;
+            }
+        }
     }
-  }
+}
 </style>
+
 <style lang="scss">
-.subflow-popover{
-  .tippy-tooltip{
-      background-color: #FFFFFF;
-      border: 1px solid #DCDEE5;
-      box-shadow: 0 2px 6px 0 #0000001a;
-      padding: 8px;
+.subflow-popover {
+    .tippy-tooltip {
+        background-color: #ffffff;
+        border: 1px solid #dcdee5;
+        box-shadow: 0 2px 6px 0 #0000001a;
+        padding: 8px;
     }
-  ul{
-    li{
-      display: flex;
-      align-items: center;
-      margin-bottom: 5px;
-      &:last-child {
-        margin-bottom: 0;
-      }
-      .text-name{
-        color: #63656E;
-      }
-      .update-text{
-        margin-left: 2px;
-        background: #FCE9E8;
-        border-radius: 2px;
-        color: #EA3636;
-        p{
-          margin: 2px 3px;
+    ul {
+        li {
+            display: flex;
+            align-items: center;
+            margin-bottom: 5px;
+            &:last-child {
+                margin-bottom: 0;
+            }
+            .text-name {
+                color: #63656e;
+            }
+            .update-text {
+                margin-left: 2px;
+                background: #fce9e8;
+                border-radius: 2px;
+                color: #ea3636;
+                p {
+                    margin: 2px 3px;
+                }
+            }
         }
-      }
     }
-  }
-  .tippy-arrow{
-    border-top: 8px solid #ffffff !important;
-  }
+    .tippy-arrow {
+        border-top: 8px solid #ffffff !important;
+    }
 }
-.reference-list{
-  display: flex;
-  align-items: center;
-  .icon-view-sub{
-    color: #3a84ff;
-    margin-top: 1px;
-    margin-left: 10px;
-  }
+.reference-list {
+    display: flex;
+    align-items: center;
+    .icon-view-sub {
+        color: #3a84ff;
+        margin-top: 1px;
+        margin-left: 10px;
+    }
 }
 </style>
diff --git a/frontend/src/views/admin/Space/Template/label-cell.vue b/frontend/src/views/admin/Space/Template/label-cell.vue
new file mode 100644
index 0000000000..68e1445722
--- /dev/null
+++ b/frontend/src/views/admin/Space/Template/label-cell.vue
@@ -0,0 +1,191 @@
+<template>
+  <div
+    ref="container"
+    class="tag-container">
+    <span
+      v-for="tag in visibleTags"
+      :key="tag.id"
+      class="tag"
+      :style="tagStyle(tag)">
+      {{ tag.full_path }}
+    </span>
+    <bk-popover
+      ext-cls="label-cell-popover"
+      theme="light">
+      <span
+        v-if="hiddenTags.length"
+        class="more">
+        +{{ hiddenTags.length }}
+      </span>
+      <template #content>
+        <div class="tooltip">
+          <span
+            v-for="tag in hiddenTags"
+            :key="tag.id"
+            v-bk-overflow-tips
+            class="tag"
+            :style="tagStyle(tag)">
+            {{ tag.full_path }}
+          </span>
+        </div>
+      </template>
+    </bk-popover>
+    <div
+      ref="measure"
+      class="measure">
+      <span
+        v-for="tag in tags"
+        :key="tag.id"
+        class="tag"
+        :style="tagStyle(tag)">
+        {{ tag.full_path }}
+      </span>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+    name: 'TagOverflow',
+
+    props: {
+        tags: {
+            type: Array,
+            default: () => [],
+        },
+    },
+
+    data() {
+        return {
+            visibleTags: [],
+            hiddenTags: [],
+        };
+    },
+
+    watch: {
+        tags: {
+            deep: true,
+            handler() {
+                this.$nextTick(this.calcOverflow);
+            },
+        },
+    },
+
+    mounted() {
+        this.$nextTick(this.calcOverflow);
+        window.addEventListener('resize', this.calcOverflow);
+    },
+
+    beforeDestroy() {
+        window.removeEventListener('resize', this.calcOverflow);
+    },
+
+    methods: {
+        tagStyle(tag) {
+            return {
+                background: tag.color,
+                color: '#fff',
+            };
+        },
+
+        calcOverflow() {
+            if (!this.tags.length) {
+                this.visibleTags = [];
+                this.hiddenTags = [];
+                return;
+            }
+            const containerWidth = this.$refs.container.offsetWidth;
+            const tagNodes = Array.from(this.$refs.measure.children);
+            const tagInfos = tagNodes.map((node, index) => ({
+                tag: this.tags[index],
+                width: node.offsetWidth + 6,
+                index,
+            }));
+            // 优先展示tag宽度小的
+            tagInfos.sort((a, b) => a.width - b.width);
+            let usedWidth = 0;
+            const visible = [];
+            const hidden = [];
+            for (const info of tagInfos) {
+                if (usedWidth + info.width <= containerWidth) {
+                    usedWidth += info.width;
+                    visible.push(info);
+                } else {
+                    hidden.push(info);
+                }
+            }
+            this.visibleTags = visible
+                .sort((a, b) => a.index - b.index)
+                .map(i => i.tag);
+            this.hiddenTags = hidden
+                .sort((a, b) => a.index - b.index)
+                .map(i => i.tag);
+        },
+    },
+};
+</script>
+<style lang="scss">
+.tag-container {
+    position: relative;
+    display: flex;
+    align-items: center;
+    white-space: nowrap;
+    overflow: hidden;
+    width: 242px;
+}
+
+.tag {
+    padding: 0 4px;
+    margin-right: 4px;
+    background: #f0f2f5;
+    border-radius: 11px;
+    font-size: 12px;
+    line-height: 16px;
+}
+
+.more {
+    display: inline-block;
+    padding: 0 4px;
+    height: 16px;
+    background: #c4c6cc;
+    border-radius: 11px;
+    line-height: 16px;
+    text-align: center;
+    color: #ffffff;
+}
+
+.tooltip {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    color: #fff;
+    border-radius: 11px;
+    color: #ffffff;
+    font-size: 10px;
+    max-height: 126px;
+    overflow: auto;
+    .tag {
+        align-self: flex-start;
+        margin: 0;
+        white-space: nowrap;
+        overflow: hidden;
+    }
+}
+
+.measure {
+    position: absolute;
+    visibility: hidden;
+    white-space: nowrap;
+    height: 0;
+    overflow: hidden;
+}
+</style>
+
+<style>
+    .label-cell-popover {
+    .tippy-tooltip {
+        padding: 8px;
+
+    }
+}
+</style>
diff --git a/frontend/src/views/admin/Space/common/LabelCascade.vue b/frontend/src/views/admin/Space/common/LabelCascade.vue
new file mode 100644
index 0000000000..1dedb0f22d
--- /dev/null
+++ b/frontend/src/views/admin/Space/common/LabelCascade.vue
@@ -0,0 +1,441 @@
+<template>
+  <div>
+    <bk-popover
+      ref="labelPopover"
+      theme="light"
+      placement="bottom-start"
+      :is-show="true"
+      trigger="manual"
+      width="350"
+      class="label-popover"
+      ext-cls="label-cascade-popover"
+      :arrow="false"
+      :on-hide="hide">
+      <div @click="isVisible(true)">
+        <slot
+          name="trigger"
+          :list="selectLabelList"
+          :is-show="isShow" />
+      </div>
+      <template #content>
+        <bk-input
+          v-model.trim="searchStr"
+          :left-icon="'bk-icon icon-search'"
+          class="search-input" />
+        <div
+          v-bkloading="{ isLoading: loading, zIndex: 102 }"
+          class="cascade-content">
+          <div class="first-label">
+            <ul class="label-list">
+              <li
+                v-for="label in labelList"
+                :key="label.id"
+                :class="[
+                  'label-item',
+                  { active: label.id === foucsId },
+                ]"
+                @click="handleClickFirstLabel(label)">
+                <bk-checkbox
+                  :value="labelIds.includes(label.id)"
+                  @change="handleCheckChange(label, $event)">
+                  {{ label.name }}
+                </bk-checkbox>
+                <bk-icon
+                  v-if="label.has_children"
+                  type="angle-right"
+                  class="angle-icon" />
+              </li>
+            </ul>
+          </div>
+          <div
+            v-if="secondLabelList.length"
+            class="second-label">
+            <ul class="label-list">
+              <li
+                v-for="label in secondLabelList"
+                :key="label.id"
+                class="label-item">
+                <bk-checkbox
+                  :value="labelIds.includes(label.id)"
+                  @change="handleCheckChange(label, $event)">
+                  {{ label.name }}
+                </bk-checkbox>
+              </li>
+            </ul>
+          </div>
+        </div>
+        <div class="label-select-extension">
+          <div
+            class="add-label"
+            data-test-id="tabTemplateConfig_form_editLabel"
+            @click="onCreateLabel">
+            <i class="bk-icon icon-plus-circle" />
+            <span>{{ $t("新建标签") }}</span>
+          </div>
+          <div
+            class="label-manage"
+            data-test-id="tabTemplateConfig_form_LabelManage"
+            @click="onManageLabel">
+            <i class="common-icon-label" />
+            <span>{{ $t("标签管理") }}</span>
+          </div>
+          <div
+            class="refresh-label"
+            data-test-id="process_list__refreshLabel"
+            @click="getLabelList">
+            <i class="bk-icon icon-right-turn-line" />
+          </div>
+        </div>
+      </template>
+    </bk-popover>
+    <CreateLabelDialog
+      :is-show="isShowCreate"
+      :scope="scope"
+      @close="isShowCreate = false"
+      @updateList="getLabelList" />
+  </div>
+</template>
+
+<script>
+import { mapActions, mapState } from 'vuex';
+import CreateLabelDialog from '../labelManage/CreateLabelDialog.vue';
+import tools from '@/utils/tools.js';
+export default {
+    name: 'LabelCascade',
+    components: {
+        CreateLabelDialog,
+    },
+    props: {
+        value: {
+            type: Array,
+            default: () => [],
+        },
+        scope: {
+            type: String,
+            default: '',
+        },
+    },
+    data() {
+        return {
+            showCreateLabelDialog: false,
+            labelList: [],
+            selectLabelList: [], // 实际选中的标签列表
+            labelIds: [], // 绑定列表选中态
+            isShow: false,
+            secondLabelList: [],
+            foucsId: 0,
+            loading: false,
+            isInitialized: false,
+            isShowCreate: false,
+            searchStr: '',
+            needReload: true, // 是否需要重新绑定一级标签选中态（刷新列表后重新绑定）
+        };
+    },
+    computed: {
+        ...mapState({
+            spaceId: state => state.spaceId,
+        }),
+    },
+    watch: {
+        value: {
+            handler(val) {
+                this.selectLabelList = [...val];
+                this.labelIds = val.map(item => item.id);
+            },
+            immediate: true,
+        },
+        searchStr() {
+            tools.throttle(this.getLabelList, 300).call(this);
+        },
+    },
+    methods: {
+        ...mapActions('label', ['loadLabelList', 'deleteLabel']),
+        async getLabelList(parentLabel = null) {
+            try {
+                this.loading = true;
+                const params = {
+                    space_id: this.spaceId,
+                    parent_id: parentLabel ? parentLabel.id : null,
+                    limit: 1000,
+                    offset: 0,
+                    name: this.searchStr,
+                    label_scope: this.scope,
+                };
+                const resp = await this.loadLabelList(params);
+                if (parentLabel) {
+                    const children = resp.data.results || [];
+                    parentLabel.children = children;
+                    this.secondLabelList = children;
+                    const parentChecked = this.labelIds.includes(parentLabel.id);
+                    if (parentChecked) {
+                        children.forEach((child) => {
+                            this.addLabelId(child);
+                            this.addToSelect(child);
+                        });
+                    } else {
+                        children.forEach((child) => {
+                            this.removeLabelId(child.id);
+                        });
+                    }
+                    return;
+                }
+                this.secondLabelList = [];
+                this.labelList = resp.data.results;
+            } catch (e) {
+                console.error(e);
+            } finally {
+                this.loading = false;
+            }
+        },
+        getPopoverInstance() {
+            return this.$refs.labelPopover.instance;
+        },
+        async isVisible(val) {
+            const popover = this.getPopoverInstance();
+            if (val) {
+                popover.show();
+                this.isShow = true;
+                if (!this.isInitialized) {
+                    // 初始化
+                    await this.getLabelList();
+                    this.isInitialized = true;
+                }
+                if (this.needReload) {
+                    // 有二级标签选中时，选中其一级标签
+                    this.selectLabelList.forEach((label) => {
+                        if (label.full_path.includes('/')) {
+                            const parentFullPath = label.full_path.split('/')[0];
+                            const parentLabel = this.labelList.find(item => item.name === parentFullPath);
+                            if (parentLabel) {
+                                this.addLabelId(parentLabel);
+                            }
+                        }
+                    });
+                    this.needReload = false;
+                }
+            } else {
+                popover.hide();
+                this.isShow = false;
+            }
+        },
+        async handleClickFirstLabel(label) {
+            this.foucsId = label.id;
+            if (!label.has_children) {
+                this.secondLabelList = [];
+            } else {
+                if (label.children) {
+                    this.secondLabelList = label.children;
+                } else {
+                  await this.getLabelList(label);
+                }
+            }
+        },
+        handleCheckChange(label, checked) {
+            if (checked) {
+                this.handleCheck(label);
+            } else {
+                this.handleUncheck(label);
+            }
+        },
+        handleCheck(label) {
+            this.addLabelId(label);
+            // 选中一级 → 选中所有二级
+            if (label.has_children && Array.isArray(label.children)) {
+                label.children.forEach((child) => {
+                    this.addLabelId(child);
+                    this.addToSelect(child);
+                });
+                return;
+            }
+            // 选中二级
+            if (label.parent_id) {
+                const parent = this.labelList.find(item => item.id === label.parent_id);
+                if (parent) {
+                    // 父级只进 labelIds
+                    this.addLabelId(parent);
+                    // 展示列表里如果有父级，移除
+                    this.removeFromSelect(parent.id);
+                }
+                // 二级进展示
+                this.addToSelect(label);
+                return;
+            }
+            // 普通一级（没有 children 的）
+            if (!label.has_children) {
+                this.addToSelect(label);
+            }
+        },
+        handleUncheck(label) {
+            this.removeLabelId(label.id);
+            // 取消一级 → 取消所有二级
+            if (label.has_children && Array.isArray(label.children)) {
+                label.children.forEach((child) => {
+                    this.removeLabelId(child.id);
+                });
+                // 确保一级也不在 select 中
+                this.removeFromSelect(label.id);
+            }
+
+            // 取消二级 → 如果没有兄弟被选中，取消一级
+            if (label.parent_id) {
+                const parent = this.labelList.find(item => item.id === label.parent_id);
+                if (!parent || !Array.isArray(parent.children)) return;
+                const hasSelectedSibling = parent.children.some(child => this.labelIds.includes(child.id));
+                if (!hasSelectedSibling) {
+                    this.removeLabelId(parent.id);
+                }
+            }
+        },
+        addLabelId(label) {
+            if (!this.labelIds.includes(label.id)) {
+                this.labelIds.push(label.id);
+            }
+        },
+        addToSelect(label) {
+            if (this.selectLabelList.some(item => item.id === label.id)) return;
+            this.selectLabelList.push({
+                id: label.id,
+                name: label.name,
+                color: label.color,
+                full_path: label.full_path,
+            });
+        },
+        removeFromSelect(id) {
+            this.selectLabelList = this.selectLabelList.filter(item => item.id !== id);
+        },
+        removeLabelId(id) {
+            this.removeFromSelect(id);
+            this.labelIds = this.labelIds.filter(labelId => labelId !== id);
+        },
+        hide() {
+            this.isShow = false;
+            const isEqual = tools.isDataEqual(this.value, this.selectLabelList);
+            if (isEqual) return;
+            this.$emit('confirm', this.selectLabelList);
+            this.needReload = true;
+        },
+        onCreateLabel() {
+            this.isShowCreate = true;
+        },
+        onManageLabel() {
+            const { href } = this.$router.resolve({
+                name: 'spaceAdmin',
+                query: {
+                    space_id: this.spaceId,
+                    activeTab: 'labelManage',
+                },
+            });
+            window.open(href, '_blank');
+        },
+    },
+};
+</script>
+
+<style lang="scss" scoped>
+.search-input {
+    height: 32px;
+    :deep(.bk-form-input) {
+        border: none;
+    }
+}
+.label-popover {
+    width: 100%;
+}
+.cascade-content {
+    display: flex;
+    height: 205px;
+    overflow: auto;
+    border: 1px solid #dcdee5;
+    border-left: none;
+    border-right: none;
+    .first-label {
+        border-right: 1px solid #dcdee5;
+        width: 50%;
+    }
+    .second-label {
+        width: 50%;
+    }
+    .label-list {
+        padding-top: 9px;
+        .label-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 8px;
+            height: 32px;
+            width: 100%;
+            cursor: pointer;
+            .angle-icon {
+                font-size: 16px !important;
+                color: #c4c6cc;
+            }
+            &:hover {
+                background-color: #f5f7fa;
+            }
+            &.active {
+                color: #3a84ff;
+                background: #e1ecff;
+                :deep(.bk-checkbox-text) {
+                    color: #3a84ff;
+                }
+            }
+        }
+    }
+}
+.label-select-extension {
+    height: 40px;
+    display: flex;
+    text-align: center;
+    line-height: 40px;
+    cursor: pointer;
+    .add-label {
+        width: 50%;
+    }
+    .label-manage {
+        flex: 1;
+    }
+    .add-label,
+    .label-manage {
+        position: relative;
+        &:hover {
+            background: #f0f1f5;
+        }
+        &::after {
+            content: "";
+            position: absolute;
+            width: 1px;
+            height: 16px;
+            display: block;
+            right: -1px;
+            top: 12px;
+            background: #dcdee5;
+        }
+    }
+    .refresh-label {
+        padding: 0 16px;
+        &:hover {
+            background: #f0f1f5;
+        }
+    }
+    & .common-icon-label,
+    & .icon-plus-circle {
+        font-size: 14px;
+        color: #979ba5;
+    }
+    & > span {
+        font-size: 12px;
+    }
+}
+</style>
+
+<style lang="scss">
+.bk-tooltip-ref {
+    width: 100%;
+}
+.label-cascade-popover {
+    .tippy-tooltip {
+        border: 1px solid #dcdee5;
+        padding: 4px 0 0 0;
+    }
+}
+</style>
diff --git a/frontend/src/views/admin/Space/index.vue b/frontend/src/views/admin/Space/index.vue
index 2b4aa12952..79b8f21831 100644
--- a/frontend/src/views/admin/Space/index.vue
+++ b/frontend/src/views/admin/Space/index.vue
@@ -14,6 +14,7 @@
   import SpaceConfigList from './SpaceConfig/index.vue';
   import DecisionTable from './DecisionTable/index.vue';
   import CredentialList from './Credential/index.vue';
+  import LabelManage from './labelManage/index.vue';
   import { mapState } from 'vuex';
 
   export default {
@@ -24,6 +25,7 @@
       SpaceConfigList,
       DecisionTable,
       CredentialList,
+      LabelManage,
     },
     data() {
       const { activeTab = 'template' } = this.$route.query;
@@ -41,7 +43,7 @@
         component = tab === 'decisionTable' ? 'DecisionTable' : component;
         component = tab === 'template' ? 'TemplateList' : component;
         component = tab === 'credential' ? 'CredentialList' : component;
-
+        component = tab === 'labelManage' ? 'LabelManage' : component;
         return component;
       },
     },
diff --git a/frontend/src/views/admin/Space/labelManage/CreateLabelDialog.vue b/frontend/src/views/admin/Space/labelManage/CreateLabelDialog.vue
new file mode 100644
index 0000000000..40b7a038bb
--- /dev/null
+++ b/frontend/src/views/admin/Space/labelManage/CreateLabelDialog.vue
@@ -0,0 +1,206 @@
+<template>
+  <bk-dialog
+    v-model="showCreateDialog"
+    theme="primary"
+    :mask-close="false"
+    header-position="left"
+    :width="640"
+    render-directive="if"
+    :title="isEdit ? $t('编辑标签') : $t('新增标签')"
+    @cancel="$emit('close')">
+    <bk-form
+      ref="createLabelForm"
+      :model="labelFormData"
+      :label-width="100"
+      :rules="rules">
+      <bk-form-item
+        :label="$t('标签名称')"
+        :required="true"
+        :property="'name'">
+        <bk-input
+          v-model="labelFormData.name"
+          :maxlength="stringLength.TEMPLATE_NAME_MAX_LENGTH" />
+      </bk-form-item>
+      <bk-form-item
+        :label="$t('标签颜色')"
+        :required="true"
+        :property="'color'">
+        <bk-color-picker
+          v-model="labelFormData.color"
+          :recommend="labelColorList" />
+      </bk-form-item>
+      <bk-form-item
+        :label="$t('标签描述')"
+        :required="true"
+        :property="'description'">
+        <bk-input
+          v-model="labelFormData.description"
+          :show-word-limit="true"
+          :type="'textarea'"
+          :rows="3"
+          :maxlength="500" />
+      </bk-form-item>
+      <bk-form-item
+        v-if="!scope"
+        :label="$t('标签范围')"
+        :required="true"
+        :property="'label_scope'">
+        <bk-checkbox-group
+          v-model="labelFormData.label_scope"
+          class="scope-checkbox">
+          <bk-checkbox :value="'task'">
+            {{ $t("任务") }}
+          </bk-checkbox>
+          <bk-checkbox :value="'template'">
+            {{ $t("流程") }}
+          </bk-checkbox>
+        </bk-checkbox-group>
+      </bk-form-item>
+    </bk-form>
+    <template #footer>
+      <bk-button
+        theme="primary"
+        :loading="confirmLoading"
+        @click="handleConfirm">
+        {{ $t("确认") }}
+      </bk-button>
+      <bk-button
+        ext-cls="mr5"
+        theme="default"
+        :disabled="confirmLoading"
+        @click="$emit('close')">
+        {{ $t("取消") }}
+      </bk-button>
+    </template>
+  </bk-dialog>
+</template>
+
+<script>
+import { STRING_LENGTH, LABEL_COLOR_LIST } from '@/constants/index.js';
+import { mapActions, mapState } from 'vuex';
+export default {
+    name: 'CreateTemplateDialog',
+    props: {
+        isShow: {
+            type: Boolean,
+            default: false,
+        },
+        isEdit: {
+            type: Boolean,
+            default: false,
+        },
+        labelData: {
+            type: Object,
+            default: () => ({}),
+        },
+        scope: {
+            type: String,
+            default: '',
+        },
+    },
+    data() {
+        return {
+            showCreateDialog: false,
+            labelFormData: {
+                name: '',
+                color: '#1C9574',
+                description: '',
+                label_scope: ['task', 'template'],
+            },
+            stringLength: STRING_LENGTH,
+            confirmLoading: false,
+            labelColorList: LABEL_COLOR_LIST,
+            editLabelId: 0,
+            rules: {
+                name: [
+                    {
+                        required: true,
+                        message: this.$t('必填项'),
+                        trigger: 'blur',
+                    },
+                ],
+                description: [
+                    {
+                        required: true,
+                        message: this.$t('必填项'),
+                        trigger: 'blur',
+                    },
+                ],
+            },
+        };
+    },
+    computed: {
+        ...mapState({
+            spaceId: state => state.spaceId,
+        }),
+    },
+    watch: {
+        isShow: {
+            handler(val) {
+                if (!val) {
+                    this.labelFormData = {
+                        name: '',
+                        color: '#1C9574',
+                        description: '',
+                        label_scope: this.scope ? [this.scope] : ['task', 'template'],
+                    };
+                } else {
+                    if (this.isEdit) {
+                        this.labelFormData = {
+                            name: this.labelData.name,
+                            color: this.labelData.color,
+                            description: this.labelData.description,
+                            label_scope: this.labelData.label_scope,
+                            parent_id: this.labelData.parent_id,
+                        };
+                        this.editLabelId = this.labelData.id;
+                    }
+                }
+                this.showCreateDialog = val;
+            },
+            immediate: true,
+        },
+    },
+    methods: {
+        ...mapActions('label/', ['createLabel', 'updateLabel']),
+        async validate() {
+            return await this.$refs.createLabelForm.validate();
+        },
+        async handleConfirm() {
+            const isValid = await this.validate();
+            if (!isValid) return;
+            this.confirmLoading = true;
+            try {
+                const payload = {
+                    ...this.labelFormData,
+                    space_id: this.spaceId,
+                };
+
+                if (this.isEdit) {
+                    await this.updateLabel({
+                        id: this.editLabelId,
+                        data: payload,
+                    });
+                } else {
+                    await this.createLabel(payload);
+                }
+
+                this.$emit('updateList');
+                this.$emit('close');
+            } catch (error) {
+                console.warn(error);
+            } finally {
+                this.confirmLoading = false;
+            }
+        },
+    },
+};
+</script>
+
+<style lang="scss" scoped>
+.scope-checkbox {
+    .bk-form-checkbox {
+        margin-right: 24px;
+    }
+}
+</style>
diff --git a/frontend/src/views/admin/Space/labelManage/index.vue b/frontend/src/views/admin/Space/labelManage/index.vue
new file mode 100644
index 0000000000..7de8ffc648
--- /dev/null
+++ b/frontend/src/views/admin/Space/labelManage/index.vue
@@ -0,0 +1,376 @@
+<template>
+  <div class="label-list">
+    <table-operate
+      ref="tableOperate"
+      :space-id="spaceId"
+      :placeholder="$t('搜索标签名称、标签范围、系统默认标签')"
+      :search-list="searchList"
+      @updateSearchValue="searchValue = $event"
+      @changeRequest="handleSearchSelectChange">
+      <bk-button
+        theme="primary"
+        :disabled="!spaceId"
+        @click="showCreateLabelDialog = true">
+        {{ $t("新增标签") }}
+      </bk-button>
+    </table-operate>
+    <bk-table
+      v-bkloading="{ isLoading: listLoading }"
+      :data="labelList"
+      :pagination="pagination"
+      :max-height="tableMaxHeight"
+      @page-change="handlePageChange"
+      @page-limit-change="handlePageLimitChange"
+      @expand-change="handleRowExpand">
+      <bk-table-column
+        type="expand"
+        disabled
+        width="30">
+        <template slot-scope="props">
+          <bk-table
+            v-bkloading="{ isLoading: props.row.childrenLoading }"
+            :data="props.row.children"
+            :outer-border="false">
+            <bk-table-column :label="$t('标签名称')">
+              <template slot-scope="{ row }">
+                <span
+                  class="label-name"
+                  :style="{ 'background-color': row.color }">
+                  {{ row.full_path }}
+                </span>
+              </template>
+            </bk-table-column>
+            <bk-table-column
+              :label="$t('标签描述')"
+              prop="description" />
+            <bk-table-column :label="$t('标签范围')">
+              <template slot-scope="{ row }">
+                <bk-tag
+                  v-for="scope in row.label_scope"
+                  :key="scope">
+                  {{ labelScope[scope] }}
+                </bk-tag>
+              </template>
+            </bk-table-column>
+            <bk-table-column :label="$t('标签引用')">
+              <template slot-scope="{ row }">
+                <i18n
+                  tag="div"
+                  path="labelReference">
+                  <span class="highlight">{{
+                    row.reference.template_count
+                  }}</span>
+                  <span class="highlight">{{
+                    row.reference.task_count
+                  }}</span>
+                </i18n>
+              </template>
+            </bk-table-column>
+            <bk-table-column :label="$t('系统默认标签')">
+              <template slot-scope="{ row }">
+                <bk-tag
+                  :theme="
+                    row.is_default ? 'success' : 'default'
+                  ">
+                  {{ row.is_default ? $t("是") : $t("否") }}
+                </bk-tag>
+              </template>
+            </bk-table-column>
+            <bk-table-column
+              :label="$t('操作')"
+              width="200">
+              <template slot-scope="{ row }">
+                <bk-button
+                  theme="primary"
+                  text
+                  @click="onEditLabel(row)">
+                  {{ $t("编辑") }}
+                </bk-button>
+                <bk-button
+                  theme="primary"
+                  class="ml10"
+                  text
+                  @click="onDeleteLabel(row.id)">
+                  {{ $t("删除") }}
+                </bk-button>
+              </template>
+            </bk-table-column>
+          </bk-table>
+        </template>
+      </bk-table-column>
+      <bk-table-column :label="$t('标签名称')">
+        <template slot-scope="{ row }">
+          <span
+            class="label-name"
+            :style="{ 'background-color': row.color }">
+            {{ row.name }}
+          </span>
+        </template>
+      </bk-table-column>
+      <bk-table-column
+        :label="$t('标签描述')"
+        prop="description" />
+      <bk-table-column :label="$t('标签范围')">
+        <template slot-scope="{ row }">
+          <bk-tag
+            v-for="scope in row.label_scope"
+            :key="scope">
+            {{ labelScope[scope] }}
+          </bk-tag>
+        </template>
+      </bk-table-column>
+      <bk-table-column :label="$t('标签引用')">
+        <template slot-scope="{ row }">
+          <i18n
+            tag="div"
+            path="labelReference">
+            <span class="highlight">{{
+              row.reference.template_count
+            }}</span>
+            <span class="highlight">{{
+              row.reference.task_count
+            }}</span>
+          </i18n>
+        </template>
+      </bk-table-column>
+      <bk-table-column :label="$t('系统默认标签')">
+        <template slot-scope="{ row }">
+          <bk-tag :theme="row.is_default ? 'success' : 'default'">
+            {{ row.is_default ? $t("是") : $t("否") }}
+          </bk-tag>
+        </template>
+      </bk-table-column>
+      <bk-table-column
+        :label="$t('操作')"
+        width="200">
+        <template slot-scope="{ row }">
+          <bk-button
+            theme="primary"
+            text
+            @click="onEditLabel(row)">
+            {{ $t("编辑") }}
+          </bk-button>
+          <bk-button
+            theme="primary"
+            class="ml10"
+            text
+            @click="onDeleteLabel(row.id)">
+            {{ $t("删除") }}
+          </bk-button>
+        </template>
+      </bk-table-column>
+    </bk-table>
+    <create-label-dialog
+      :is-show="showCreateLabelDialog"
+      :label-data="editLabel"
+      :is-edit="isEdit"
+      @close="showCreateLabelDialog = false"
+      @updateList="getLabelList" />
+  </div>
+</template>
+
+<script>
+import { LABEL_SCOPE } from '../../../../constants/index.js';
+import { mapActions } from 'vuex';
+import TableOperate from '../common/TableOperate.vue';
+import tableHeader from '@/mixins/tableHeader.js';
+import tableCommon from '../mixins/tableCommon.js';
+import i18n from '@/config/i18n/index.js';
+import CreateLabelDialog from './CreateLabelDialog.vue';
+const SEARCH_LIST = [
+    {
+        id: 'name',
+        name: i18n.t('标签名称'),
+        isDefaultOption: true,
+    },
+    {
+        id: 'label_scope',
+        name: i18n.t('标签范围'),
+        children: [
+            { id: 'task', name: i18n.t('任务') },
+            { id: 'template', name: i18n.t('流程') },
+        ],
+    },
+    {
+        id: 'is_default',
+        name: i18n.t('系统默认标签'),
+        children: [
+            { id: 'true', name: true },
+            { id: 'false', name: false },
+        ],
+    },
+];
+export default {
+    name: 'LabelManage',
+    components: {
+        TableOperate,
+        CreateLabelDialog,
+    },
+    mixins: [tableHeader, tableCommon],
+    data() {
+        return {
+            searchList: SEARCH_LIST,
+            searchValue: '',
+            selectedTpls: [],
+            showCreateLabelDialog: false,
+            labelList: [],
+            labelScope: LABEL_SCOPE,
+            editLabel: {},
+            expandListLoading: false,
+            pageType: 'labelList',
+            isEdit: false,
+            deleting: false,
+        };
+    },
+    methods: {
+        ...mapActions('label', [
+            'loadLabelList',
+            'deleteLabel',
+            'loadLabelReference',
+        ]),
+        async getLabelList(parent = null) {
+            const parentId = parent ? parent.id : null;
+            // 二级标签拉取全量数据
+            const params = this.getQueryData(parentId);
+            try {
+                if (parentId) {
+                    parent.childrenLoading = true;
+                } else {
+                    this.listLoading = true;
+                }
+
+                // 1. 获取标签列表
+                const res = await this.loadLabelList(params);
+                const list = res.data?.results.map(item =>
+                        // 拼接 full_path
+                        ({
+                            ...item,
+                            childrenLoading: false,
+                        })
+                    ) || [];
+
+                // 2. 获取引用数据
+                let referenceMap = {};
+                if (list.length) {
+                    const refResp = await this.loadLabelReference({
+                        space_id: this.spaceId,
+                        label_ids: list.map(item => item.id).join(','),
+                    });
+                    referenceMap = refResp?.data || {};
+                }
+
+                // 3. 绑定 reference
+                const bindReference = (labels) => {
+                    labels.forEach((label) => {
+                        label.reference = referenceMap[label.id] || { template_count: 0, task_count: 0 };
+                    });
+                };
+
+                if (parentId) {
+                    parent.children = list;
+                    bindReference(parent.children);
+                } else {
+                    this.labelList = list;
+                    bindReference(this.labelList);
+                    this.pagination.count = res.data?.count || 0;
+                    this.totalPage = Math.ceil(this.pagination.count / this.pagination.limit);
+                }
+            } catch (error) {
+                console.error(error);
+            } finally {
+                if (parentId) {
+                    parent.childrenLoading = false;
+                } else {
+                    this.listLoading = false;
+                }
+            }
+        },
+        getQueryData(parentId) {
+            const {
+                name,
+                label_scope,
+                is_default,
+            } = this.requestData;
+            const data = {
+                name,
+                label_scope,
+                is_default,
+                space_id: this.spaceId,
+                parent_id: parentId,
+                limit: parentId ? 1000 : this.pagination.limit,
+                offset: parentId
+                    ? 0
+                    : (this.pagination.current - 1) * this.pagination.limit,
+            };
+            return data;
+        },
+        onEditLabel(label) {
+            this.editLabel = label;
+            this.isEdit = true;
+            this.showCreateLabelDialog = true;
+        },
+        onDeleteLabel(id) {
+            this.$bkInfo({
+                title: this.$t('确认删除该标签？'),
+                subTitle: this.$t('关联的流程将同时移出本标签'),
+                width: 400,
+                confirmLoading: true,
+                cancelText: this.$t('取消'),
+                confirmFn: async () => {
+                    await this.onDeleteConfirm(id);
+                },
+            });
+        },
+        async onDeleteConfirm(id) {
+            if (this.deleting) return;
+            this.deleting = true;
+            try {
+                const resp = await this.deleteLabel(id);
+                if (resp.result === false) return;
+                // 最后一页最后一条删除后，往前翻一页
+                if (
+                    this.pagination.current > 1
+                    && this.totalPage === this.pagination.current
+                    && this.pagination.count
+                        - (this.totalPage - 1) * this.pagination.limit
+                        === 1
+                ) {
+                    this.pagination.current -= 1;
+                }
+                this.getLabelList();
+                this.updateUrl({ current: 1 });
+                this.$bkMessage({
+                    message: this.$t('标签删除成功！'),
+                    theme: 'success',
+                });
+            } catch (e) {
+                console.log(e);
+            } finally {
+                this.deleting = false;
+            }
+        },
+        handleRowExpand(label) {
+            if (!label.has_children || label.children) return;
+            this.getLabelList(label);
+        },
+    },
+};
+</script>
+
+<style lang="scss" scoped>
+.label-name {
+    padding: 0 4px;
+    border-radius: 11px;
+    line-height: 16px;
+    color: #ffffff;
+}
+:deep(.bk-table-expanded-cell) {
+    padding-right: 0 !important;
+    .bk-table-header-wrapper {
+        display: none;
+    }
+}
+.highlight {
+    color: #3a84ff;
+}
+</style>
diff --git a/frontend/src/views/template/TemplateEdit/TemplateSetting/TabTemplateConfig.vue b/frontend/src/views/template/TemplateEdit/TemplateSetting/TabTemplateConfig.vue
index 973fb01b38..19fb449a7f 100644
--- a/frontend/src/views/template/TemplateEdit/TemplateSetting/TabTemplateConfig.vue
+++ b/frontend/src/views/template/TemplateEdit/TemplateSetting/TabTemplateConfig.vue
@@ -1,14 +1,13 @@
-/**
-* Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community
-* Edition) available.
-* Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved.
-* Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-* http://opensource.org/licenses/MIT
-* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-* specific language governing permissions and limitations under the License.
-*/
+/** * Tencent is pleased to support the open source community by making
+蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community * Edition) available. *
+Copyright (C) 2017 THL A29 Limited, a Tencent company. All rights reserved. *
+Licensed under the MIT License (the "License"); you may not use this file except
+in compliance with the License. * You may obtain a copy of the License at *
+http://opensource.org/licenses/MIT * Unless required by applicable law or agreed
+to in writing, software distributed under the License is distributed on * an "AS
+IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the * specific language governing permissions and
+limitations under the License. */
 <template>
   <bk-sideslider
     :title="$t('基础信息')"
@@ -26,7 +25,7 @@
         :label-width="140"
         :rules="rules">
         <section class="form-section">
-          <h4>{{ $t('基础') }}</h4>
+          <h4>{{ $t("基础") }}</h4>
           <bk-form-item
             :property="'name'"
             :label="$t('流程名称')"
@@ -40,6 +39,46 @@
               :maxlength="stringLength.TEMPLATE_NAME_MAX_LENGTH"
               :show-word-limit="true" />
           </bk-form-item>
+          <bk-form-item
+            :label="$t('标签')"
+            data-test-id="tabTemplateConfig_form_label">
+            <label-cascade
+              :value="formData.template_labels"
+              scope="template"
+              @confirm="onSelectLabel">
+              <template #trigger="{ list, isShow }">
+                <div
+                  :class="[
+                    'cascade-trigger',
+                    { focus: isShow },
+                  ]">
+                  <div class="label-list">
+                    <div
+                      v-for="label in list"
+                      :key="label.id"
+                      class="label-item"
+                      :style="{
+                        'background-color': label.color,
+                      }">
+                      {{ label.full_path }}
+                      <bk-icon
+                        class="delete-icon"
+                        type="close"
+                        @click="
+                          handleDeleteLabel(label.id)
+                        " />
+                    </div>
+                  </div>
+                  <bk-icon
+                    :class="[
+                      'angle-icon',
+                      { 'is-show': isShow },
+                    ]"
+                    type="angle-down" />
+                </div>
+              </template>
+            </label-cascade>
+          </bk-form-item>
           <!-- <bk-form-item v-if="!common" :label="$t('标签')" data-test-id="tabTemplateConfig_form_label">
             <bk-select
               :key="templateLabels.length"
@@ -122,8 +161,10 @@
         </section>
         <section class="form-section">
           <h4>
-            <span>{{ $t('通知') }}</span>
-            <span class="tip-desc">{{ $t('选择通知方式后，将默认通知到任务执行人') }}</span>
+            <span>{{ $t("通知") }}</span>
+            <span class="tip-desc">{{
+              $t("选择通知方式后，将默认通知到任务执行人")
+            }}</span>
           </h4>
           <NotifyTypeConfig
             :label-width="140"
@@ -137,19 +178,23 @@
         </section>
         <section class="form-section">
           <h4>
-            <span>{{ $t('触发器') }}</span>
-            <span class="tip-desc">{{ $t('可以通过配置触发器来执行流程任务') }}</span>
+            <span>{{ $t("触发器") }}</span>
+            <span class="tip-desc">{{
+              $t("可以通过配置触发器来执行流程任务")
+            }}</span>
           </h4>
           <TimedTriggerConfig
             :is-view-mode="isViewMode"
             :triggers="formData.triggers"
             :template-id="templateId"
-            :is-allow-set-multiple-trigger="isAllowSetMultipleTrigger"
+            :is-allow-set-multiple-trigger="
+              isAllowSetMultipleTrigger
+            "
             @change="onTriggerConfigChange" />
         </section>
 
         <section class="form-section">
-          <h4>{{ $t('其他') }}</h4>
+          <h4>{{ $t("其他") }}</h4>
           <!-- <bk-form-item v-if="!common" :label="$t('执行代理人')" data-test-id="tabTemplateConfig_form_executorProxy">
             <member-select
               :multiple="false"
@@ -197,13 +242,13 @@
           theme="primary"
           data-test-id="tabTemplateConfig_form_saveBtn"
           @click="onSaveConfig">
-          {{ $t('确定') }}
+          {{ $t("确定") }}
         </bk-button>
         <bk-button
           theme="default"
           data-test-id="tabTemplateConfig_form_cancelBtn"
           @click="closeTab">
-          {{ isViewMode ? $t('关闭') : $t('取消') }}
+          {{ isViewMode ? $t("关闭") : $t("取消") }}
         </bk-button>
       </div>
       <!-- <bk-dialog
@@ -257,357 +302,406 @@
 </template>
 
 <script>
-  import { mapState, mapMutations, mapActions } from 'vuex';
-  // import MemberSelect from '@/components/common/Individualization/MemberSelect.vue'
-  import tools from '@/utils/tools.js';
-  import { NAME_REG, STRING_LENGTH, TASK_CATEGORIES, LABEL_COLOR_LIST } from '@/constants/index.js';
-  import i18n from '@/config/i18n/index.js';
-  import NotifyTypeConfig from './NotifyTypeConfig.vue';
-  import permission from '@/mixins/permission.js';
-  import TimedTriggerConfig from './TimedTriggerConfig.vue';
+import { mapState, mapMutations, mapActions } from 'vuex';
+// import MemberSelect from '@/components/common/Individualization/MemberSelect.vue'
+import tools from '@/utils/tools.js';
+import {
+    NAME_REG,
+    STRING_LENGTH,
+    TASK_CATEGORIES,
+    LABEL_COLOR_LIST,
+} from '@/constants/index.js';
+import i18n from '@/config/i18n/index.js';
+import NotifyTypeConfig from './NotifyTypeConfig.vue';
+import permission from '@/mixins/permission.js';
+import TimedTriggerConfig from './TimedTriggerConfig.vue';
+import LabelCascade from '../../../admin/Space/common/LabelCascade.vue';
 
-  export default {
+export default {
     name: 'TabTemplateConfig',
     components: {
-      // MemberSelect,
-      NotifyTypeConfig,
-      TimedTriggerConfig,
+        // MemberSelect,
+        NotifyTypeConfig,
+        TimedTriggerConfig,
+        LabelCascade,
     },
     mixins: [permission],
     props: {
-      projectInfoLoading: Boolean,
-      templateLabelLoading: Boolean,
-      templateLabels: {
-        type: Array,
-        default: () => ([]),
-      },
-      isShow: Boolean,
-      common: {
-        type: [String, Number],
-        default: '',
-      },
-      isViewMode: Boolean,
+        projectInfoLoading: Boolean,
+        templateLabelLoading: Boolean,
+        isShow: Boolean,
+        common: {
+            type: [String, Number],
+            default: '',
+        },
+        isViewMode: Boolean,
     },
     data() {
-      const {
-        name, category, notify_type: notifyType, notify_receivers: notifyReceivers = {}, description,
-        executor_proxy: execProxy, template_labels, default_flow_type, triggers,
-      } = this.$store.state.template;
+        const {
+            name,
+            category,
+            notify_type: notifyType,
+            notify_receivers: notifyReceivers = {},
+            description,
+            executor_proxy: execProxy,
+            template_labels,
+            default_flow_type,
+            triggers,
+        } = this.$store.state.template;
 
-      return {
-        formData: {
-          name,
-          category,
-          description,
-          executorProxy: execProxy ? [execProxy] : [],
-          receiverGroup: [],
-          notifyReceiver: notifyReceivers.more_receiver ? notifyReceivers.more_receiver.split(',') : [],
-          notifyType: notifyType ? [notifyType.success.slice(0), notifyType.fail.slice(0)] : [],
-          labels: template_labels,
-          defaultFlowType: default_flow_type,
-          triggers,
-        },
-        stringLength: STRING_LENGTH,
-        rules: {
-          name: [
-            {
-              required: true,
-              message: i18n.t('必填项'),
-              trigger: 'blur',
-            },
-            {
-              max: STRING_LENGTH.TEMPLATE_NAME_MAX_LENGTH,
-              message: i18n.t('流程名称长度不能超过') + STRING_LENGTH.TEMPLATE_NAME_MAX_LENGTH + i18n.t('个字符'),
-              trigger: 'blur',
-            },
-            {
-              regex: NAME_REG,
-              message: `${i18n.t('流程名称不能包含')}'‘"”$&<>${i18n.t('非法字符')}`,
-              trigger: 'blur',
-            },
-          ],
-        },
-        taskCategories: TASK_CATEGORIES,
-        labelDialogShow: false,
-        labelRules: {
-          color: [
-            {
-              required: true,
-              message: i18n.t('必填项'),
-              trigger: 'blur',
-            },
-          ],
-          name: [
-            {
-              required: true,
-              message: i18n.t('必填项'),
-              trigger: 'blur',
+        return {
+            formData: {
+                name,
+                category,
+                description,
+                executorProxy: execProxy ? [execProxy] : [],
+                receiverGroup: [],
+                notifyReceiver: notifyReceivers.more_receiver
+                    ? notifyReceivers.more_receiver.split(',')
+                    : [],
+                notifyType: notifyType
+                    ? [notifyType.success.slice(0), notifyType.fail.slice(0)]
+                    : [],
+                template_labels,
+                defaultFlowType: default_flow_type,
+                triggers,
             },
-            {
-              max: 50,
-              message: i18n.t('标签名称不能超过') + 50 + i18n.t('个字符'),
-              trigger: 'blur',
+            stringLength: STRING_LENGTH,
+            rules: {
+                name: [
+                    {
+                        required: true,
+                        message: i18n.t('必填项'),
+                        trigger: 'blur',
+                    },
+                    {
+                        max: STRING_LENGTH.TEMPLATE_NAME_MAX_LENGTH,
+                        message:
+                            i18n.t('流程名称长度不能超过')
+                            + STRING_LENGTH.TEMPLATE_NAME_MAX_LENGTH
+                            + i18n.t('个字符'),
+                        trigger: 'blur',
+                    },
+                    {
+                        regex: NAME_REG,
+                        message: `${i18n.t('流程名称不能包含')}'‘"”$&<>${i18n.t('非法字符')}`,
+                        trigger: 'blur',
+                    },
+                ],
             },
-            {
-              validator: val => this.templateLabels.every(label => label.name !== val),
-              message: i18n.t('标签已存在，请重新输入'),
-              trigger: 'blur',
+            taskCategories: TASK_CATEGORIES,
+            labelDialogShow: false,
+            labelRules: {
+                color: [
+                    {
+                        required: true,
+                        message: i18n.t('必填项'),
+                        trigger: 'blur',
+                    },
+                ],
+                name: [
+                    {
+                        required: true,
+                        message: i18n.t('必填项'),
+                        trigger: 'blur',
+                    },
+                    {
+                        max: 50,
+                        message:
+                            i18n.t('标签名称不能超过') + 50 + i18n.t('个字符'),
+                        trigger: 'blur',
+                    },
+                    {
+                        validator: val => this.templateLabels.every(label => label.name !== val),
+                        message: i18n.t('标签已存在，请重新输入'),
+                        trigger: 'blur',
+                    },
+                ],
             },
-          ],
-        },
-        labelDetail: {},
-        colorDropdownShow: false,
-        colorList: LABEL_COLOR_LIST,
-        labelLoading: false,
-        proxyPlaceholder: '',
-        isAllowSetMultipleTrigger: false, // 允许设置多个触发器
-      };
+            labelDetail: {},
+            colorDropdownShow: false,
+            colorList: LABEL_COLOR_LIST,
+            labelLoading: false,
+            proxyPlaceholder: '',
+            isAllowSetMultipleTrigger: false, // 允许设置多个触发器
+        };
     },
     computed: {
-      ...mapState({
-        username: state => state.username,
-        timeout: state => state.template.time_out,
-        infoBasicConfig: state => state.infoBasicConfig,
-      }),
-      ...mapState('project', {
-        projectId: state => state.project_id,
-        projectName: state => state.projectName,
-        authActions: state => state.authActions,
-      }),
-      ...mapState('template', {
-        templateId: state => state.template_id,
-        spaceId: state => state.spaceId,
-      }),
+        ...mapState({
+            username: state => state.username,
+            timeout: state => state.template.time_out,
+            infoBasicConfig: state => state.infoBasicConfig,
+        }),
+        ...mapState('project', {
+            projectId: state => state.project_id,
+            projectName: state => state.projectName,
+            authActions: state => state.authActions,
+        }),
+        ...mapState('template', {
+            templateId: state => state.template_id,
+            spaceId: state => state.spaceId,
+        }),
     },
     async mounted() {
-      // 模板没有设置执行代理人时，默认使用项目下的执行代理人
-      // if (!this.formData.executorProxy.length) {
-      //   this.setExecutorProxy()
-      // }
-      this.$refs.nameInput.focus();
-      // 获取空间配置判断是否允许设置多个触发器
-      const res = await this.getNotAuthSpaceConfig();
-      if (res.data.allow_multiple_triggers) {
-        const { name } = res.data.allow_multiple_triggers;
-        const result = await this.checkSpaceConfig({ id: this.spaceId, name });
-        if (result) {
-          this.isAllowSetMultipleTrigger = result.data.value === 'true';
+        // 模板没有设置执行代理人时，默认使用项目下的执行代理人
+        // if (!this.formData.executorProxy.length) {
+        //   this.setExecutorProxy()
+        // }
+        console.log(this.$store.state.template);
+        this.$refs.nameInput.focus();
+        // 获取空间配置判断是否允许设置多个触发器
+        const res = await this.getNotAuthSpaceConfig();
+        if (res.data.allow_multiple_triggers) {
+            const { name } = res.data.allow_multiple_triggers;
+            const result = await this.checkSpaceConfig({
+                id: this.spaceId,
+                name,
+            });
+            if (result) {
+                this.isAllowSetMultipleTrigger = result.data.value === 'true';
+            }
+        } else {
+            this.isAllowSetMultipleTrigger = false;
         }
-      } else {
-        this.isAllowSetMultipleTrigger = false;
-      }
     },
     methods: {
-      ...mapMutations('template/', [
-        'setTplConfig',
-      ]),
-      ...mapActions('project', [
-        'getProjectConfig',
-        'createTemplateLabel',
-      ]),
-      ...mapActions('spaceConfig/', [
-        'getNotAuthSpaceConfig',
-        'checkSpaceConfig',
-      ]),
-      onEditLabel() {
-        if (!this.hasPermission(['project_edit'], this.authActions)) {
-          const resourceData = {
-            project: [{
-              id: this.projectId,
-              name: this.projectName,
-            }],
-          };
-          this.applyForPermission(['project_edit'], this.authActions, resourceData);
-          return;
-        }
-        this.labelDetail = { color: '#1c9574', name: '', description: '' };
-        this.labelDialogShow = true;
-        this.colorDropdownShow = false;
-      },
-      onManageLabel() {
-        if (!this.hasPermission(['project_view'], this.authActions)) {
-          const resourceData = {
-            project: [{
-              id: this.projectId,
-              name: this.projectName,
-            }],
-          };
-          this.applyForPermission(['project_view'], this.authActions, resourceData);
-          return;
-        }
-        const { href } = this.$router.resolve({
-          name: 'projectConfig',
-          params: { id: this.projectId },
-          query: { configActive: 'label_config' },
-        });
-        window.open(href, '_blank');
-      },
-      getTemplateConfig() {
-        const {
-          name,
-          category,
-          description,
-          executorProxy,
-          notifyReceiver,
-          receiverGroup,
-          notifyType,
-          labels,
-          defaultFlowType,
-          triggers,
-        } = this.formData;
-        return {
-          name,
-          category,
-          description,
-          template_labels: labels,
-          executor_proxy: executorProxy.length === 1 ? executorProxy[0] : '',
-          more_receiver: notifyReceiver,
-          receiver_group: receiverGroup,
-          notify_type: { success: notifyType[0], fail: notifyType[1] },
-          default_flow_type: defaultFlowType,
-          triggers,
-        };
-      },
-      jumpProjectManagement() {
-        if (this.isViewMode) return;
-        if (this.authActions.includes('project_edit')) {
-          const { href } = this.$router.resolve({
-            name: 'projectConfig',
-            params: { id: this.projectId },
-          });
-          window.open(href, '_blank');
-        } else {
-          const resourceData = {
-            project: [{
-              id: this.projectId,
-              name: this.projectName,
-            }],
-          };
-          this.applyForPermission(['project_edit'], this.authActions, resourceData);
-        }
-      },
-      onSelectNotifyConfig(formData) {
-        const { notifyType, receiverGroup, receiver } = formData;
-        this.formData.notifyType = notifyType;
-        this.formData.notifyReceiver = receiver;
-        this.formData.receiverGroup = receiverGroup;
-      },
-      onTriggerConfigChange(triggers) {
-        this.formData.triggers = triggers;
-      },
-      onSaveConfig() {
-        this.$refs.configForm.validate().then((result) => {
-          if (!result) {
-            return;
-          }
-          const data = this.getTemplateConfig();
-          this.setTplConfig(data);
-          this.closeTab();
-          this.$emit('templateDataChanged');
-        });
-      },
-      beforeClose() {
-        if (this.isViewMode) {
-          this.closeTab();
-          return true;
-        }
-        const {
-          name,
-          category,
-          description,
-          template_labels,
-          executor_proxy,
-          notify_receivers,
-          notify_type,
-          default_flow_type,
-        } = this.$store.state.template;
-        const originData = {
-          name,
-          category,
-          description,
-          template_labels,
-          executor_proxy,
-          more_receiver: notify_receivers.receiver?.split(',') || [],
-          receiver_group: notify_receivers.receiver_group,
-          notify_type,
-          default_flow_type,
-        };
-        const editingData = this.getTemplateConfig();
-        if (tools.isDataEqual(originData, editingData)) {
-          this.closeTab();
-          return true;
-        }
-        this.$bkInfo({
-          ...this.infoBasicConfig,
-          confirmFn: () => {
-            this.closeTab();
-          },
-        });
-        return false;
-      },
-      closeTab() {
-        this.$emit('closeTab');
-      },
-      editLabelConfirm() {
-        if (this.labelLoading) {
-          return;
-        }
-        this.labelLoading = true;
-        try {
-          this.$refs.labelForm.validate().then(async (result) => {
-            if (result) {
-              const { color, name, description } = this.labelDetail;
-              const { project_id } = this.$route.params;
-              const data = {
-                creator: this.username,
-                project_id: Number(project_id),
-                color,
+        ...mapMutations('template/', ['setTplConfig']),
+        ...mapActions('project', ['getProjectConfig', 'createTemplateLabel']),
+        ...mapActions('spaceConfig/', [
+            'getNotAuthSpaceConfig',
+            'checkSpaceConfig',
+        ]),
+        onEditLabel() {
+            if (!this.hasPermission(['project_edit'], this.authActions)) {
+                const resourceData = {
+                    project: [
+                        {
+                            id: this.projectId,
+                            name: this.projectName,
+                        },
+                    ],
+                };
+                this.applyForPermission(
+                    ['project_edit'],
+                    this.authActions,
+                    resourceData
+                );
+                return;
+            }
+            this.labelDetail = { color: '#1c9574', name: '', description: '' };
+            this.labelDialogShow = true;
+            this.colorDropdownShow = false;
+        },
+        onManageLabel() {
+            if (!this.hasPermission(['project_view'], this.authActions)) {
+                const resourceData = {
+                    project: [
+                        {
+                            id: this.projectId,
+                            name: this.projectName,
+                        },
+                    ],
+                };
+                this.applyForPermission(
+                    ['project_view'],
+                    this.authActions,
+                    resourceData
+                );
+                return;
+            }
+            const { href } = this.$router.resolve({
+                name: 'projectConfig',
+                params: { id: this.projectId },
+                query: { configActive: 'label_config' },
+            });
+            window.open(href, '_blank');
+        },
+        getTemplateConfig() {
+            const {
+                name,
+                category,
+                description,
+                executorProxy,
+                notifyReceiver,
+                receiverGroup,
+                notifyType,
+                template_labels,
+                defaultFlowType,
+                triggers,
+            } = this.formData;
+            return {
                 name,
+                category,
                 description,
-              };
-              const resp = await this.createTemplateLabel(data);
-              if (resp.result) {
-                this.$emit('updateTemplateLabelList');
-                this.labelDialogShow = false;
-                this.formData.labels.push(resp.data.id);
-                this.$bkMessage({
-                  message: i18n.t('标签新建成功'),
-                  theme: 'success',
+                template_labels,
+                executor_proxy:
+                    executorProxy.length === 1 ? executorProxy[0] : '',
+                more_receiver: notifyReceiver,
+                receiver_group: receiverGroup,
+                notify_type: { success: notifyType[0], fail: notifyType[1] },
+                default_flow_type: defaultFlowType,
+                triggers,
+            };
+        },
+        jumpProjectManagement() {
+            if (this.isViewMode) return;
+            if (this.authActions.includes('project_edit')) {
+                const { href } = this.$router.resolve({
+                    name: 'projectConfig',
+                    params: { id: this.projectId },
                 });
-              }
+                window.open(href, '_blank');
+            } else {
+                const resourceData = {
+                    project: [
+                        {
+                            id: this.projectId,
+                            name: this.projectName,
+                        },
+                    ],
+                };
+                this.applyForPermission(
+                    ['project_edit'],
+                    this.authActions,
+                    resourceData
+                );
             }
-          });
-        } catch (e) {
-          console.log(e);
-        } finally {
-          this.labelLoading = false;
-        }
-      },
-      // 获取代理人设置数据
-      async setExecutorProxy() {
-        try {
-          const resp = await this.getProjectConfig(this.projectId);
-          if (resp.result) {
-            const { executor_proxy: execProxy, executor_proxy_exempts: execProxyExempts } = resp.data;
-            if (execProxy) {
-              this.formData.executorProxy = [execProxy];
+        },
+        onSelectNotifyConfig(formData) {
+            const { notifyType, receiverGroup, receiver } = formData;
+            this.formData.notifyType = notifyType;
+            this.formData.notifyReceiver = receiver;
+            this.formData.receiverGroup = receiverGroup;
+        },
+        onTriggerConfigChange(triggers) {
+            this.formData.triggers = triggers;
+        },
+        onSaveConfig() {
+            this.$refs.configForm.validate().then((result) => {
+                if (!result) {
+                    return;
+                }
+                const data = this.getTemplateConfig();
+                console.log(data, 'config data');
+                this.setTplConfig(data);
+                this.closeTab();
+                this.$emit('templateDataChanged');
+            });
+        },
+        beforeClose() {
+            if (this.isViewMode) {
+                this.closeTab();
+                return true;
             }
-            this.proxyPlaceholder = i18n.t('项目执行代理人(n)；免代理用户(m)', {
-              n: execProxy || '--',
-              m: execProxyExempts || '--',
+            const {
+                name,
+                category,
+                description,
+                template_labels,
+                executor_proxy,
+                notify_receivers,
+                notify_type,
+                default_flow_type,
+            } = this.$store.state.template;
+            const originData = {
+                name,
+                category,
+                description,
+                template_labels,
+                executor_proxy,
+                more_receiver: notify_receivers.receiver?.split(',') || [],
+                receiver_group: notify_receivers.receiver_group,
+                notify_type,
+                default_flow_type,
+            };
+            const editingData = this.getTemplateConfig();
+            if (tools.isDataEqual(originData, editingData)) {
+                this.closeTab();
+                return true;
+            }
+            this.$bkInfo({
+                ...this.infoBasicConfig,
+                confirmFn: () => {
+                    this.closeTab();
+                },
             });
-          }
-        } catch (e) {
-          console.log(e);
-        }
-      },
+            return false;
+        },
+        closeTab() {
+            this.$emit('closeTab');
+        },
+        editLabelConfirm() {
+            if (this.labelLoading) {
+                return;
+            }
+            this.labelLoading = true;
+            try {
+                this.$refs.labelForm.validate().then(async (result) => {
+                    if (result) {
+                        const { color, name, description } = this.labelDetail;
+                        const { project_id } = this.$route.params;
+                        const data = {
+                            creator: this.username,
+                            project_id: Number(project_id),
+                            color,
+                            name,
+                            description,
+                        };
+                        const resp = await this.createTemplateLabel(data);
+                        if (resp.result) {
+                            this.$emit('updateTemplateLabelList');
+                            this.labelDialogShow = false;
+                            this.formData.labels.push(resp.data.id);
+                            this.$bkMessage({
+                                message: i18n.t('标签新建成功'),
+                                theme: 'success',
+                            });
+                        }
+                    }
+                });
+            } catch (e) {
+                console.log(e);
+            } finally {
+                this.labelLoading = false;
+            }
+        },
+        // 获取代理人设置数据
+        async setExecutorProxy() {
+            try {
+                const resp = await this.getProjectConfig(this.projectId);
+                if (resp.result) {
+                    const {
+                        executor_proxy: execProxy,
+                        executor_proxy_exempts: execProxyExempts,
+                    } = resp.data;
+                    if (execProxy) {
+                        this.formData.executorProxy = [execProxy];
+                    }
+                    this.proxyPlaceholder = i18n.t(
+                        '项目执行代理人(n)；免代理用户(m)',
+                        {
+                            n: execProxy || '--',
+                            m: execProxyExempts || '--',
+                        }
+                    );
+                }
+            } catch (e) {
+                console.log(e);
+            }
+        },
+        onSelectLabel(labels) {
+            this.formData.template_labels = labels;
+        },
+        handleDeleteLabel(id) {
+            this.formData.template_labels = this.formData.template_labels.filter(item => item.id !== id);
+        },
     },
-  };
+};
 </script>
 
 <style lang="scss" scoped>
-@import '../../../../scss/config.scss';
-@import '../../../../scss/mixins/scrollbar.scss';
+@import "../../../../scss/config.scss";
+@import "../../../../scss/mixins/scrollbar.scss";
 .config-wrapper {
     height: calc(100vh - 60px);
     background: none;
@@ -678,4 +772,51 @@
         display: block;
     }
 }
+.bk-tooltip-ref {
+    width: 100%;
+}
+.cascade-trigger {
+    display: flex;
+    align-items: center;
+    padding: 0 0 0 8px;
+    background: #ffffff;
+    border: 1px solid #c4c6cc;
+    border-radius: 2px;
+    width: 100%;
+    &.focus {
+        border-color: #3a84ff;
+    }
+    .label-list {
+        flex: 1;
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 6px;
+        min-height: 32px;
+        padding: 7px 0 9px 0;
+        .label-item {
+            height: 16px;
+            font-size: 12px;
+            display: flex;
+            align-items: center;
+            padding: 0 4px;
+            border-radius: 11px;
+            color: #ffffff;
+            .delete-icon {
+                font-size: 16px !important;
+                margin-left: 5px;
+                cursor: pointer;
+            }
+        }
+    }
+    .angle-icon {
+        width: 30px;
+        height: 100%;
+        font-size: 16px !important;
+        color: #979ba5;
+        &.is-show {
+            transform: rotate(180deg);
+        }
+    }
+}
 </style>
diff --git a/frontend/src/views/template/TemplateEdit/TemplateSetting/index.vue b/frontend/src/views/template/TemplateEdit/TemplateSetting/index.vue
index 0874539b1b..a0b5dc646e 100644
--- a/frontend/src/views/template/TemplateEdit/TemplateSetting/index.vue
+++ b/frontend/src/views/template/TemplateEdit/TemplateSetting/index.vue
@@ -29,8 +29,7 @@
       :is-view-mode="isViewMode"
       :project-info-loading="projectInfoLoading"
       :template-label-loading="templateLabelLoading"
-      :template-labels="templateLabels"
-      @templateDataChanged="$emit('templateDataChanged', 'tabTemplateConfig')"
+      @templateDataChanged="$emit('templateDataChanged')"
       @updateTemplateLabelList="$emit('updateTemplateLabelList')"
       @closeTab="closeTab" />
     <TabTemplateSnapshoot
@@ -67,10 +66,10 @@
       isViewMode: Boolean,
       projectInfoLoading: Boolean,
       templateLabelLoading: Boolean,
-      templateLabels: {
-        type: Array,
-        default: () => ([]),
-      },
+    //   templateLabels: {
+    //     type: Array,
+    //     default: () => ([]),
+    //   },
       activeTab: {
         type: String,
         default: '',
diff --git a/frontend/src/views/template/TemplateEdit/index.vue b/frontend/src/views/template/TemplateEdit/index.vue
index c7da14c753..fbb727613c 100644
--- a/frontend/src/views/template/TemplateEdit/index.vue
+++ b/frontend/src/views/template/TemplateEdit/index.vue
@@ -131,7 +131,6 @@
           @modifyTemplateData="modifyTemplateData"
           @createSnapshoot="onCreateSnapshoot"
           @useSnapshoot="onUseSnapshoot"
-          @updateTemplateLabelList="getTemplateLabelList"
           @updateSnapshoot="onUpdateSnapshoot" />
         <!-- :is-show="isShowVersionList" -->
         <version-list
@@ -712,9 +711,6 @@
             common: this.common,
           };
           const templateData = await this.loadTemplateData(data);
-          await this.checkoutSpace(templateData.space_id);
-          this.lastedPipelineTree = tools.deepClone(templateData.pipeline_tree);
-          // 保存最新版本的流程树数据
           this.tplActions = templateData.auth;
           if (this.type === 'clone') {
             templateData.name = `${templateData.name.slice(0, STRING_LENGTH.TEMPLATE_NAME_MAX_LENGTH - 6)}_clone`;
@@ -834,17 +830,17 @@
       /**
        * 加载模板标签列表
        */
-      async getTemplateLabelList() {
-        try {
-          this.templateLabelLoading = true;
-          const res = await this.getProjectLabelsWithDefault(this.projectId);
-          this.templateLabels = res.data;
-        } catch (e) {
-          console.log(e);
-        } finally {
-          this.templateLabelLoading = false;
-        }
-      },
+    //   async getTemplateLabelList() {
+    //     try {
+    //       this.templateLabelLoading = true;
+    //       const res = await this.getProjectLabelsWithDefault(this.projectId);
+    //       this.templateLabels = res.data;
+    //     } catch (e) {
+    //       console.log(e);
+    //     } finally {
+    //       this.templateLabelLoading = false;
+    //     }
+    //   },
       checkDirtyData() {
         const ins = new DealVarDirtyData(this.constants);
         const illegalKeys = ins.checkKeys();
diff --git a/module_settings.py b/module_settings.py
index 1392cf067a..e5b2f94d4f 100644
--- a/module_settings.py
+++ b/module_settings.py
@@ -243,6 +243,7 @@ def check_engine_admin_permission(request, *args, **kwargs):
         "bk_notice_sdk",
         "bkflow.bk_plugin",
         "bkflow.pipeline_web",
+        "bkflow.label",
     )
 
     VARIABLE_KEY_BLACKLIST = (
diff --git a/scripts/run_all_unit_test.sh b/scripts/run_all_unit_test.sh
index 0102243849..bc111aeb84 100644
--- a/scripts/run_all_unit_test.sh
+++ b/scripts/run_all_unit_test.sh
@@ -4,7 +4,7 @@ source /root/.envs/bkflow/bin/activate
 set -e
 export $(cat tests/interface.env | xargs)
 echo "开始运行${BKFLOW_MODULE_TYPE}测试"
-pytest tests/interface tests/plugins tests/project_settings tests/contrib tests/decision_table
+pytest tests/interface tests/plugins tests/project_settings tests/contrib tests/decision_table tests/label
 set +e
 
 set -e
diff --git a/scripts/run_interface_unit_test.sh b/scripts/run_interface_unit_test.sh
index 08094496d6..6b0f4b79ea 100644
--- a/scripts/run_interface_unit_test.sh
+++ b/scripts/run_interface_unit_test.sh
@@ -2,4 +2,4 @@
 set -e
 export $(cat tests/interface.env | xargs)
 echo $BKFLOW_MODULE_TYPE
-pytest tests/interface tests/plugins tests/project_settings tests/contrib tests/decision_table
+pytest tests/interface tests/plugins tests/project_settings tests/contrib tests/decision_table tests/label
diff --git a/tests/engine/task/test_models.py b/tests/engine/task/test_models.py
index af1a4db4a4..ec3f2b033a 100644
--- a/tests/engine/task/test_models.py
+++ b/tests/engine/task/test_models.py
@@ -16,13 +16,26 @@
 
 to the current version of the project delivered to anyone in the future.
 """
-import pytest
+import json
 
+import pytest
+from bamboo_engine import states
+from django.utils import timezone
+from django_celery_beat.models import CrontabSchedule as DjangoCeleryBeatCrontabSchedule
+from django_celery_beat.models import PeriodicTask as DjangoCeleryBeatPeriodicTask
+from pipeline.core.constants import PE
+
+from bkflow.constants import TaskTriggerMethod
+from bkflow.task import models as task_models
 from bkflow.task.models import (
     AutoRetryNodeStrategy,
     EngineSpaceConfig,
     EngineSpaceConfigValueType,
+    PeriodicTask,
+    TaskExecutionSnapshot,
+    TaskFlowRelation,
     TaskInstance,
+    TaskLabelRelation,
     TaskMockData,
     TaskOperationRecord,
     TimeoutNodeConfig,
@@ -96,6 +109,280 @@ def test_get_notify_info(self):
         assert "types" in notify_info
         assert "test_executor" in notify_info["receivers"]
 
+    def test_manager_set_finished_and_revoked(self):
+        """Test TaskInstanceManager.set_finished/set_revoked"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        TaskInstance.objects.set_finished(task_instance.instance_id)
+        task_instance.refresh_from_db()
+        assert task_instance.is_finished is True
+        assert task_instance.finish_time is not None
+
+        TaskInstance.objects.set_revoked(task_instance.instance_id)
+        task_instance.refresh_from_db()
+        assert task_instance.is_revoked is True
+        assert task_instance.finish_time is not None
+
+    def test_delete_instance_real_delete(self):
+        """Test TaskInstance.delete(real_delete=True)"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task_id = task_instance.id
+
+        task_instance.delete(real_delete=True)
+        assert not TaskInstance.objects.filter(id=task_id).exists()
+
+    def test_set_execution_data_creates_snapshot_when_missing(self):
+        """Cover TaskInstance.set_execution_data DoesNotExist branch"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=task_instance.id).update(execution_snapshot_id=99999999)
+        task_instance.refresh_from_db()
+
+        data = build_default_pipeline_tree()
+        task_instance.set_execution_data(data)
+        task_instance.refresh_from_db()
+
+        assert TaskExecutionSnapshot.objects.filter(id=task_instance.execution_snapshot_id).exists()
+
+    def test_calculate_tree_info_returns_when_execution_data_is_none(self):
+        """Cover TaskInstance.calculate_tree_info early return when execution_data is None"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=task_instance.id).update(execution_snapshot_id=None, tree_info_id=None)
+        task_instance.refresh_from_db()
+
+        task_instance.calculate_tree_info()
+        task_instance.refresh_from_db()
+        assert task_instance.tree_info_id is None
+
+    def test_calculate_tree_info_updates_when_tree_info_exists(self):
+        """Cover TaskInstance.calculate_tree_info update branch"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task_instance.calculate_tree_info()
+        tree_info_id = task_instance.tree_info_id
+
+        task_instance.calculate_tree_info()
+        task_instance.refresh_from_db()
+        assert task_instance.tree_info_id == tree_info_id
+
+    def test_create_instance_mock_creates_task_mock_data(self):
+        """Cover TaskInstanceManager.create_instance mock_data mapping branch"""
+        pipeline_tree = build_default_pipeline_tree()
+        node_id = list(pipeline_tree[PE.activities].keys())[0]
+        mock_data = {
+            "nodes": [node_id],
+            "outputs": {node_id: {"k": "v"}},
+            "mock_data_ids": {"foo": "bar"},
+        }
+        task_instance = TaskInstance.objects.create_instance(
+            space_id=1,
+            pipeline_tree=pipeline_tree,
+            create_method="MOCK",
+            mock_data=mock_data,
+        )
+
+        task_mock_data = TaskMockData.objects.get(taskflow_id=task_instance.id)
+        mapped_node_id = task_mock_data.data["nodes"][0]
+        assert mapped_node_id in task_instance.execution_data[PE.activities]
+        assert list(task_mock_data.data["outputs"].keys()) == [mapped_node_id]
+        assert task_mock_data.mock_data_ids == {"foo": "bar"}
+
+    def test_change_parent_task_node_state_to_running_without_relation(self):
+        """Cover TaskInstance.change_parent_task_node_state_to_running no relation branch"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=task_instance.id).update(trigger_method=TaskTriggerMethod.subprocess.name)
+        task_instance.refresh_from_db()
+
+        assert not TaskFlowRelation.objects.filter(task_id=task_instance.id).exists()
+        task_instance.change_parent_task_node_state_to_running()
+
+    def test_node_id_set_triggers_calculate_tree_info(self):
+        """Cover TaskInstance.node_id_set branch that triggers calculate_tree_info"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=task_instance.id).update(tree_info_id=None)
+        task_instance.refresh_from_db()
+
+        node_ids = task_instance.node_id_set
+        assert isinstance(node_ids, set)
+        task_instance.refresh_from_db()
+        assert task_instance.tree_info_id is not None
+
+    def test_get_notify_info_with_more_receivers(self):
+        """Cover TaskInstance.get_notify_info more_receivers branch and executor filtering"""
+        task_instance = TaskInstance.objects.create_instance(
+            space_id=1,
+            pipeline_tree=build_default_pipeline_tree(),
+            executor="user_a",
+        )
+        TaskInstance.objects.filter(id=task_instance.id).update(
+            extra_info={
+                "notify_config": {
+                    "notify_receivers": {"more_receiver": "user_a,user_b,user_c"},
+                    "notify_type": {"success": ["weixin"], "fail": ["weixin"]},
+                    "notify_format": {"title": "t", "content": "c"},
+                }
+            }
+        )
+        task_instance.refresh_from_db()
+
+        notify_info = task_instance.get_notify_info()
+        assert notify_info["receivers"].count("user_a") == 1
+        assert set(notify_info["receivers"]) == {"user_a", "user_b", "user_c"}
+
+
+@pytest.mark.django_db(transaction=True)
+class TestTaskInstanceMoreCoverage:
+    def test_taskinstance_properties(self):
+        """
+        Cover TaskInstance snapshot/data/pipeline_tree/tree_info/
+        execution_snapshot/execution_data/node_id_set/elapsed_time
+        """
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        assert task_instance.snapshot is not None
+        assert isinstance(task_instance.data, dict)
+
+        assert task_instance.execution_snapshot is not None
+        assert isinstance(task_instance.execution_data, dict)
+        assert task_instance.pipeline_tree == task_instance.execution_data
+
+        task_instance.calculate_tree_info()
+        assert task_instance.tree_info is not None
+        assert isinstance(task_instance.node_id_set, set)
+
+        TaskInstance.objects.filter(id=task_instance.id).update(
+            start_time=timezone.now(),
+            finish_time=timezone.now(),
+        )
+        task_instance.refresh_from_db()
+        assert task_instance.elapsed_time is not None
+
+    def test_replace_id_with_subprocess_node(self, monkeypatch):
+        """Cover TaskInstance._replace_id subprocess recursion branch"""
+
+        def _noop_replace_all_id(_data):
+            return {}
+
+        monkeypatch.setattr(task_models, "replace_all_id", _noop_replace_all_id)
+
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        exec_data = {
+            PE.start_event: {"id": "s0"},
+            PE.end_event: {"id": "e0"},
+            PE.gateways: [],
+            PE.activities: {
+                "sub1": {
+                    PE.type: PE.SubProcess,
+                    "pipeline": {
+                        PE.start_event: {"id": "s1"},
+                        PE.end_event: {"id": "e1"},
+                        PE.gateways: [],
+                        PE.activities: {},
+                    },
+                },
+                "act2": {PE.type: "ServiceActivity"},
+            },
+        }
+
+        task_instance._replace_id(exec_data)
+        assert exec_data[PE.activities]["sub1"]["pipeline"]["id"] == "sub1"
+
+    def test_get_node_id_set_with_subprocess_node(self):
+        """Cover TaskInstance._get_node_id_set subprocess recursion branch"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        data = {
+            PE.start_event: {"id": "s0"},
+            PE.end_event: {"id": "e0"},
+            PE.gateways: ["g1"],
+            PE.activities: {
+                "sub1": {
+                    PE.type: PE.SubProcess,
+                    "pipeline": {
+                        PE.start_event: {"id": "s1"},
+                        PE.end_event: {"id": "e1"},
+                        PE.gateways: [],
+                        PE.activities: {"a1": {PE.type: "ServiceActivity"}},
+                    },
+                }
+            },
+        }
+
+        node_ids = set()
+        task_instance._get_node_id_set(node_ids, data)
+        assert {"s0", "e0", "g1", "sub1", "s1", "e1", "a1"}.issubset(node_ids)
+
+    def test_change_parent_task_node_state_to_running_not_subprocess(self):
+        """Cover change_parent_task_node_state_to_running early return when not child task"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task_instance.change_parent_task_node_state_to_running()
+
+    def test_change_parent_task_node_state_to_running_success_path(self, monkeypatch):
+        """Cover deeper branches in change_parent_task_node_state_to_running with runtime mocks"""
+        parent_task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        child_task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=child_task.id).update(trigger_method=TaskTriggerMethod.subprocess.name)
+        child_task.refresh_from_db()
+
+        TaskFlowRelation.objects.create(
+            task_id=child_task.id,
+            parent_task_id=parent_task.id,
+            root_task_id=parent_task.id,
+            extra_info={"node_id": "node_1", "node_version": 1},
+        )
+
+        class DummySchedule:
+            id = 123
+
+        class DummyQS:
+            def update(self, **kwargs):
+                return 1
+
+        class DummyRuntime:
+            def get_state(self, node_id):
+                return type("S", (), {"name": states.FAILED, "version": 1})()
+
+            def get_schedule_with_node_and_version(self, node_id, version):
+                return DummySchedule()
+
+            def set_state(self, **kwargs):
+                return None
+
+            def get_execution_data_outputs(self, node_id):
+                return {"ex_data": "x", "k": "v"}
+
+            def set_execution_data_outputs(self, node_id, data_outputs):
+                assert "ex_data" not in data_outputs
+                return None
+
+        monkeypatch.setattr(task_models, "BambooDjangoRuntime", lambda: DummyRuntime())
+        monkeypatch.setattr(task_models.DBSchedule.objects, "filter", lambda **kwargs: DummyQS())
+
+        child_task.change_parent_task_node_state_to_running()
+
+    def test_change_parent_task_node_state_to_running_state_mismatch_returns(self, monkeypatch):
+        """Cover change_parent_task_node_state_to_running early return when node state/version mismatch"""
+        parent_task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        child_task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskInstance.objects.filter(id=child_task.id).update(trigger_method=TaskTriggerMethod.subprocess.name)
+        child_task.refresh_from_db()
+
+        TaskFlowRelation.objects.create(
+            task_id=child_task.id,
+            parent_task_id=parent_task.id,
+            root_task_id=parent_task.id,
+            extra_info={"node_id": "node_1", "node_version": 1},
+        )
+
+        class DummyRuntime:
+            def get_state(self, node_id):
+                return type("S", (), {"name": states.RUNNING, "version": 1})()
+
+            def get_schedule_with_node_and_version(self, node_id, version):
+                raise AssertionError("should not reach schedule branch")
+
+        monkeypatch.setattr(task_models, "BambooDjangoRuntime", lambda: DummyRuntime())
+
+        child_task.change_parent_task_node_state_to_running()
+
 
 @pytest.mark.django_db(transaction=True)
 class TestTaskMockData:
@@ -159,6 +446,177 @@ def test_create_timeout_config(self):
         assert config.timeout == 300
 
 
+@pytest.mark.django_db(transaction=True)
+class TestTimeoutNodeConfigManager:
+    def test_batch_create_node_timeout_config_parse_fail(self, monkeypatch):
+        """Cover TimeoutNodeConfigManager.batch_create_node_timeout_config parse fail branch"""
+
+        def _fake_parse(_pipeline_tree):
+            return {"result": False, "data": []}
+
+        monkeypatch.setattr(task_models, "parse_node_timeout_configs", _fake_parse)
+
+        TimeoutNodeConfig.objects.batch_create_node_timeout_config(
+            taskflow_id=1,
+            root_pipeline_id="root_123",
+            pipeline_tree={},
+        )
+        assert TimeoutNodeConfig.objects.count() == 0
+
+
+@pytest.mark.django_db(transaction=True)
+class TestPeriodicTask:
+    def test_create_task_and_enabled_property(self):
+        """Test PeriodicTaskManager.create_task and PeriodicTask.enabled"""
+        cron = {"minute": "0", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
+        periodic_task = PeriodicTask.objects.create_task(
+            name="pt",
+            template_id=1,
+            trigger_id=1,
+            cron=cron,
+            config={"template_id": 1},
+            creator="tester",
+            extra_info={"k": "v"},
+            is_enabled=False,
+        )
+
+        assert periodic_task.celery_task_id is not None
+        assert periodic_task.enabled is False
+
+    def test_modify_cron_must_disabled_branch(self):
+        """Cover PeriodicTask.modify_cron must_disabled and enabled branch"""
+        schedule = DjangoCeleryBeatCrontabSchedule.objects.create(
+            minute="0",
+            hour="*",
+            day_of_week="*",
+            day_of_month="*",
+            month_of_year="*",
+        )
+        celery_task = DjangoCeleryBeatPeriodicTask.objects.create(
+            crontab=schedule,
+            name="celery_pt_1",
+            task="bkflow.task.celery.tasks.bkflow_periodic_task_start",
+            enabled=True,
+            kwargs=json.dumps({"periodic_task_id": 1}),
+        )
+        periodic_task = PeriodicTask.objects.create(
+            name="pt",
+            template_id=1,
+            trigger_id=1,
+            cron={"minute": "0"},
+            celery_task=celery_task,
+            config={},
+            creator="tester",
+        )
+
+        new_cron = {"minute": "5", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
+        periodic_task.modify_cron(new_cron, must_disabled=True)
+
+        periodic_task.celery_task.refresh_from_db()
+        assert periodic_task.celery_task.crontab.minute == "5"
+        assert periodic_task.celery_task.enabled is True
+
+    def test_modify_cron_else_branch(self):
+        """Cover PeriodicTask.modify_cron else branch"""
+        schedule = DjangoCeleryBeatCrontabSchedule.objects.create(
+            minute="0",
+            hour="*",
+            day_of_week="*",
+            day_of_month="*",
+            month_of_year="*",
+        )
+        celery_task = DjangoCeleryBeatPeriodicTask.objects.create(
+            crontab=schedule,
+            name="celery_pt_2",
+            task="bkflow.task.celery.tasks.bkflow_periodic_task_start",
+            enabled=False,
+            kwargs=json.dumps({"periodic_task_id": 1}),
+        )
+        periodic_task = PeriodicTask.objects.create(
+            name="pt",
+            template_id=1,
+            trigger_id=1,
+            cron={"minute": "0"},
+            celery_task=celery_task,
+            config={},
+            creator="tester",
+        )
+
+        new_cron = {"minute": "10", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
+        periodic_task.modify_cron(new_cron, must_disabled=True)
+
+        periodic_task.celery_task.refresh_from_db()
+        assert periodic_task.celery_task.crontab.minute == "10"
+
+    def test_delete_periodic_task_deletes_celery_task(self):
+        """Cover PeriodicTask.delete"""
+        cron = {"minute": "0", "hour": "*", "day_of_week": "*", "day_of_month": "*", "month_of_year": "*"}
+        periodic_task = PeriodicTask.objects.create_task(
+            name="pt_delete",
+            template_id=1,
+            trigger_id=1,
+            cron=cron,
+            config={},
+            creator="tester",
+        )
+        celery_task_id = periodic_task.celery_task_id
+        periodic_task_id = periodic_task.id
+
+        periodic_task.delete()
+        assert not PeriodicTask.objects.filter(id=periodic_task_id).exists()
+        assert not DjangoCeleryBeatPeriodicTask.objects.filter(id=celery_task_id).exists()
+
+
+@pytest.mark.django_db(transaction=True)
+class TestPeriodicTaskMoreCoverage:
+    def test_default_cron_and_unicode(self):
+        """Cover default_cron and PeriodicTask.__unicode__"""
+        cron = task_models.default_cron()
+        assert cron["minute"] == "0"
+        assert cron["hour"] == "*"
+
+        periodic_task = PeriodicTask.objects.create(
+            name="pt_unicode",
+            template_id=1,
+            trigger_id=1,
+            cron=cron,
+            config={},
+            creator="tester",
+        )
+        assert "pt_unicode" in periodic_task.__unicode__()
+        assert str(periodic_task.id) in periodic_task.__unicode__()
+
+
+@pytest.mark.django_db(transaction=True)
+class TestTaskLabelRelationManager:
+    def test_set_labels_add_and_remove(self):
+        """Cover BaseLabelRelationManager.set_labels add/remove branches"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskLabelRelation.objects.create(task_id=task_instance.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task_instance.id, label_id=2)
+
+        TaskLabelRelation.objects.set_labels(task_instance.id, [2, 3])
+
+        label_ids = list(TaskLabelRelation.objects.filter(task_id=task_instance.id).values_list("label_id", flat=True))
+        assert sorted(label_ids) == [2, 3]
+
+    def test_fetch_tasks_labels(self):
+        """Cover BaseLabelRelationManager.fetch_tasks_labels branches"""
+        task1 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task2 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        # empty
+        assert TaskLabelRelation.objects.fetch_tasks_labels([task1.id, task2.id]) == {}
+
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=2)
+        TaskLabelRelation.objects.create(task_id=task2.id, label_id=3)
+
+        result = TaskLabelRelation.objects.fetch_tasks_labels([task1.id, task2.id])
+        assert sorted(result[task1.id]) == [1, 2]
+        assert result[task2.id] == [3]
+
+
 @pytest.mark.django_db(transaction=True)
 class TestEngineSpaceConfig:
     """测试 EngineSpaceConfig 模型"""
@@ -203,3 +661,24 @@ def test_get_space_var(self):
         # Not exist
         space_var = EngineSpaceConfig.get_space_var(space_id=999)
         assert space_var == {}
+
+
+@pytest.mark.django_db(transaction=True)
+class TestEngineSpaceConfigMoreCoverage:
+    def test_to_json(self):
+        """Cover EngineSpaceConfig.to_json"""
+        config = EngineSpaceConfig.objects.create(
+            interface_config_id=100,
+            space_id=1,
+            name="cfg",
+            value_type=EngineSpaceConfigValueType.TEXT.value,
+            text_value="v",
+            json_value={"k": "v"},
+        )
+        data = config.to_json()
+        assert data["id"] == config.id
+        assert data["name"] == "cfg"
+        assert data["value_type"] == EngineSpaceConfigValueType.TEXT.value
+        assert data["value"] == "v"
+        assert data["json_value"] == {"k": "v"}
+        assert data["interface_config_id"] == 100
diff --git a/tests/engine/task/test_task_views.py b/tests/engine/task/test_task_views.py
index 457e670c24..20713fc028 100644
--- a/tests/engine/task/test_task_views.py
+++ b/tests/engine/task/test_task_views.py
@@ -28,10 +28,15 @@
     EngineSpaceConfigValueType,
     PeriodicTask,
     TaskInstance,
+    TaskLabelRelation,
     TaskMockData,
     TaskOperationRecord,
 )
-from bkflow.task.views import PeriodicTaskViewSet, TaskInstanceViewSet
+from bkflow.task.views import (
+    PeriodicTaskViewSet,
+    TaskInstanceFilterSet,
+    TaskInstanceViewSet,
+)
 from bkflow.utils.pipeline import build_default_pipeline_tree
 
 
@@ -993,6 +998,358 @@ def test_validate_task_info_invalid_node_id_in_data(self):
         assert response.data["result"] is False
         assert "node_id should be in task" in response.data["message"]
 
+    def test_list_injects_labels(self):
+        """测试 list 会补充 labels 字段"""
+        task1 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task2 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=2)
+        TaskLabelRelation.objects.create(task_id=task2.id, label_id=3)
+
+        view = TaskInstanceViewSet.as_view({"get": "list"})
+        request = self._create_request_with_auth("get", "/task/", {"limit": 10, "offset": 0})
+        response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        results = response.data["data"]["results"]
+        assert len(results) >= 2
+        for item in results:
+            assert "labels" in item
+
+        task1_item = next(i for i in results if i["id"] == task1.id)
+        task2_item = next(i for i in results if i["id"] == task2.id)
+        assert sorted(task1_item["labels"]) == [1, 2]
+        assert sorted(task2_item["labels"]) == [3]
+
+    def test_list_filter_by_labels_invalid_value(self):
+        """测试 label 过滤参数非法时返回空结果"""
+        TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        view = TaskInstanceViewSet.as_view({"get": "list"})
+        request = self._create_request_with_auth(
+            "get",
+            "/task/",
+            {"label": "not_int", "limit": 10, "offset": 0},
+        )
+        response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["data"]["count"] == 0
+        assert response.data["data"]["results"] == []
+
+    def test_list_filter_by_labels_success(self):
+        """测试 label 过滤参数合法时能正确筛选任务"""
+        task1 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task2 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task2.id, label_id=2)
+
+        view = TaskInstanceViewSet.as_view({"get": "list"})
+        request = self._create_request_with_auth(
+            "get",
+            "/task/",
+            {"label": "1", "limit": 10, "offset": 0},
+        )
+        response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        results = response.data["data"]["results"]
+        assert len(results) == 1
+        assert results[0]["id"] == task1.id
+
+    def test_update_labels_action(self):
+        """测试 update_labels action 会更新 TaskLabelRelation"""
+        task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        view = TaskInstanceViewSet.as_view({"post": "update_labels"})
+        request = self._create_request_with_auth(
+            "post",
+            f"/task/{task.id}/update_labels/",
+            {"label_ids": [11, 12]},
+        )
+        response = view(request, pk=task.id)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert sorted(response.data["data"]) == [11, 12]
+        assert set(TaskLabelRelation.objects.filter(task_id=task.id).values_list("label_id", flat=True)) == {11, 12}
+
+    def test_get_task_label_ref_count(self):
+        """测试 get_task_label_ref_count action"""
+        task1 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        task2 = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        TaskLabelRelation.objects.create(task_id=task1.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task2.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task2.id, label_id=2)
+
+        view = TaskInstanceViewSet.as_view({"get": "get_task_label_ref_count"})
+        request = self._create_request_with_auth(
+            "get",
+            "/task/get_task_label_ref_count/",
+            {"label_ids": "1,2,3", "space_id": 1},
+        )
+        response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["result"] is True
+        assert response.data["data"]["1"] == 2
+        assert response.data["data"]["2"] == 1
+        assert response.data["data"]["3"] == 0
+
+    def test_delete_task_label_relation(self):
+        """测试 delete_task_label_relation action"""
+        task = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        TaskLabelRelation.objects.create(task_id=task.id, label_id=1)
+        TaskLabelRelation.objects.create(task_id=task.id, label_id=2)
+
+        view = TaskInstanceViewSet.as_view({"post": "delete_task_label_relation"})
+        request = self._create_request_with_auth(
+            "post",
+            "/task/delete_task_label_relation/",
+            {"label_ids": [1]},
+        )
+        response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["data"]["label_ids"] == [1]
+        assert set(TaskLabelRelation.objects.filter(task_id=task.id).values_list("label_id", flat=True)) == {2}
+
+    @patch("bkflow.task.views.start_trace")
+    @patch("bkflow.task.views.TaskOperation")
+    def test_operate_task_operation_method_not_found(self, mock_task_operation, mock_start_trace):
+        """测试任务操作 - operation 存在但方法缺失"""
+
+        class _NoOp:
+            pass
+
+        mock_start_trace.return_value.__enter__ = MagicMock()
+        mock_start_trace.return_value.__exit__ = MagicMock()
+        mock_task_operation.return_value = _NoOp()
+
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        view = TaskInstanceViewSet.as_view({"post": "operate"})
+        request = self._create_request_with_auth("post", f"/task/{task_instance.id}/operate/start/", {})
+
+        with pytest.raises(Exception):
+            view(request, pk=task_instance.id, operation="start")
+
+    @patch("bkflow.task.views.start_trace")
+    @patch("bkflow.task.views.TaskNodeOperation")
+    def test_node_operate_method_not_found(self, mock_node_operation, mock_start_trace):
+        """测试节点操作 - operation 存在但方法缺失"""
+
+        class _NoOp:
+            pass
+
+        mock_start_trace.return_value.__enter__ = MagicMock()
+        mock_start_trace.return_value.__exit__ = MagicMock()
+        mock_node_operation.return_value = _NoOp()
+
+        pipeline_tree = build_default_pipeline_tree()
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=pipeline_tree)
+        self._start_task_instance(task_instance)
+        node_id = list(pipeline_tree["activities"].keys())[0]
+
+        view = TaskInstanceViewSet.as_view({"post": "node_operate"})
+        request = self._create_request_with_auth("post", f"/task/{task_instance.id}/node_operate/{node_id}/retry/", {})
+
+        with pytest.raises(Exception):
+            view(request, pk=task_instance.id, node_id=node_id, operation="retry")
+
+    def test_get_node_detail_include_data_true_success(self):
+        """测试 get_node_detail include_data=True 且获取数据成功"""
+
+        class _Result(dict):
+            def __init__(self, result=True, data=None, message="success"):
+                super().__init__({"result": result, "data": data, "message": message})
+                self.result = result
+                self.data = data
+                self.message = message
+
+        pipeline_tree = build_default_pipeline_tree()
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=pipeline_tree)
+        node_id = list(pipeline_tree["activities"].keys())[0]
+
+        node_data = {"x": 1}
+        node_detail = {"y": 2}
+
+        with patch("bkflow.task.views.TaskNodeOperation") as mock_node_operation:
+            mock_node_op = MagicMock()
+            mock_node_op.get_node_data.return_value = _Result(result=True, data=node_data)
+            mock_node_op.get_node_detail.return_value = _Result(result=True, data=node_detail)
+            mock_node_operation.return_value = mock_node_op
+
+            view = TaskInstanceViewSet.as_view({"get": "get_node_detail"})
+            request = self._create_request_with_auth(
+                "get",
+                f"/task/{task_instance.id}/get_task_node_detail/{node_id}/",
+                {"include_data": True},
+            )
+
+            response = view(request, pk=task_instance.id, node_id=node_id)
+            assert response.status_code == status.HTTP_200_OK
+            assert response.data["result"] is True
+            assert response.data["data"]["x"] == 1
+            assert response.data["data"]["y"] == 2
+
+    def test_get_node_detail_get_node_data_fail(self):
+        """测试 get_node_detail include_data=True 但 get_node_data 失败会提前返回"""
+
+        class _Result(dict):
+            def __init__(self, result=True, data=None, message="success"):
+                super().__init__({"result": result, "data": data, "message": message})
+                self.result = result
+                self.data = data
+                self.message = message
+
+        pipeline_tree = build_default_pipeline_tree()
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=pipeline_tree)
+        node_id = list(pipeline_tree["activities"].keys())[0]
+
+        with patch("bkflow.task.views.TaskNodeOperation") as mock_node_operation:
+            mock_node_op = MagicMock()
+            mock_node_op.get_node_data.return_value = _Result(result=False, data=None, message="failed")
+            mock_node_operation.return_value = mock_node_op
+
+            view = TaskInstanceViewSet.as_view({"get": "get_node_detail"})
+            request = self._create_request_with_auth(
+                "get",
+                f"/task/{task_instance.id}/get_task_node_detail/{node_id}/",
+                {"include_data": True},
+            )
+            response = view(request, pk=task_instance.id, node_id=node_id)
+
+            assert response.status_code == status.HTTP_200_OK
+            assert response.data["result"] is False
+            assert response.data["message"] == "failed"
+
+    def test_get_node_detail_get_node_detail_fail(self):
+        """测试 get_node_detail get_node_detail 失败会提前返回"""
+
+        class _Result(dict):
+            def __init__(self, result=True, data=None, message="success"):
+                super().__init__({"result": result, "data": data, "message": message})
+                self.result = result
+                self.data = data
+                self.message = message
+
+        pipeline_tree = build_default_pipeline_tree()
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=pipeline_tree)
+        node_id = list(pipeline_tree["activities"].keys())[0]
+
+        with patch("bkflow.task.views.TaskNodeOperation") as mock_node_operation:
+            mock_node_op = MagicMock()
+            mock_node_op.get_node_data.return_value = _Result(result=True, data={"x": 1})
+            mock_node_op.get_node_detail.return_value = _Result(result=False, data=None, message="detail_failed")
+            mock_node_operation.return_value = mock_node_op
+
+            view = TaskInstanceViewSet.as_view({"get": "get_node_detail"})
+            request = self._create_request_with_auth(
+                "get",
+                f"/task/{task_instance.id}/get_task_node_detail/{node_id}/",
+                {"include_data": True},
+            )
+            response = view(request, pk=task_instance.id, node_id=node_id)
+
+            assert response.status_code == status.HTTP_200_OK
+            assert response.data["result"] is False
+            assert response.data["message"] == "detail_failed"
+
+    def test_get_node_snapshot_config_template_node_id_not_found(self):
+        """测试 get_node_snapshot_config - template_node_id 未找到"""
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+
+        # create_instance may replace node ids, so take node_id from persisted execution_data.
+        pipeline_tree = task_instance.execution_data
+        node_id = list(pipeline_tree["activities"].keys())[0]
+        pipeline_tree["activities"][node_id].pop("template_node_id", None)
+
+        # set_execution_data won't overwrite existing snapshot data, so update snapshot directly.
+        from bkflow.task.models import TaskExecutionSnapshot
+
+        TaskExecutionSnapshot.objects.filter(id=task_instance.execution_snapshot_id).update(data=pipeline_tree)
+        task_instance.calculate_tree_info()
+
+        view = TaskInstanceViewSet.as_view({"get": "get_node_snapshot_config"})
+        request = self._create_request_with_auth(
+            "get",
+            f"/task/{task_instance.id}/get_node_snapshot_config/",
+            {"node_id": node_id},
+        )
+        response = view(request, pk=task_instance.id)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["result"] is False
+        assert response.data["message"] == "template_node_id 未找到"
+
+    def test_get_engine_config_raises_does_not_exist(self):
+        """测试 get_engine_config - 触发 DoesNotExist 异常分支"""
+        view = TaskInstanceViewSet.as_view({"get": "get_engine_config"})
+        request = self._create_request_with_auth(
+            "get",
+            "/task/get_engine_config/",
+            {"interface_config_ids": [999], "simplified": False},
+        )
+
+        with patch("bkflow.task.views.EngineSpaceConfig.objects.filter") as mock_filter:
+            mock_filter.side_effect = EngineSpaceConfig.DoesNotExist("not found")
+            response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["result"] is False
+
+    def test_delete_engine_config_raises_does_not_exist(self):
+        """测试 delete_engine_config - 触发 DoesNotExist 异常分支"""
+        view = TaskInstanceViewSet.as_view({"delete": "delete_engine_config"})
+        request = self._create_request_with_auth(
+            "delete",
+            "/task/delete_engine_config/",
+            {"interface_config_ids": [999], "simplified": False},
+        )
+
+        with patch("bkflow.task.views.EngineSpaceConfig.objects.filter") as mock_filter:
+            mock_filter.side_effect = EngineSpaceConfig.DoesNotExist()
+            response = view(request)
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["result"] is False
+
+    def test_filter_by_labels_with_empty_label_ids_returns_queryset(self):
+        """覆盖 TaskInstanceFilterSet.filter_by_labels 的 label_ids 为空分支"""
+
+        class _Value:
+            def split(self, _sep):
+                return []
+
+        TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        qs = TaskInstance.objects.filter(space_id=1)
+        f = TaskInstanceFilterSet()
+        new_qs = f.filter_by_labels(qs, "label", _Value())
+
+        assert list(new_qs) == list(qs)
+
+    def test_get_node_detail_raises_when_node_not_found(self):
+        """覆盖 get_node_detail 内部的 node not found 分支（绕过 validate_task_info）"""
+        from rest_framework.request import Request
+
+        from bkflow.exceptions import ValidationError
+
+        task_instance = TaskInstance.objects.create_instance(space_id=1, pipeline_tree=build_default_pipeline_tree())
+        invalid_node_id = "invalid_node_id_999"
+
+        view = TaskInstanceViewSet()
+        view.action = "get_node_detail"
+        view.kwargs = {"pk": task_instance.id}
+
+        # DRF Request has query_params attribute (WSGIRequest doesn't).
+        raw_request = self._create_request_with_auth("get", "/", {"include_data": True})
+        request = Request(raw_request)
+        view.request = request
+
+        with pytest.raises(ValidationError):
+            TaskInstanceViewSet.get_node_detail.__wrapped__(view, request, node_id=invalid_node_id)
+
 
 @pytest.mark.django_db(transaction=True)
 class TestPeriodicTaskViewSet:
@@ -1084,6 +1441,28 @@ def test_update_periodic_task_success(self):
         assert response.status_code == status.HTTP_200_OK
         assert response.data["data"]["name"] == "updated_name"
 
+    def test_update_periodic_task_not_found(self):
+        """测试更新周期任务 - trigger_id 不存在"""
+        update_view = PeriodicTaskViewSet.as_view({"post": "update_task"})
+        update_data = {
+            "trigger_id": 999999,
+            "name": "updated_name",
+            "cron": {
+                "minute": "30",
+                "hour": "12",
+                "day_of_week": "*",
+                "day_of_month": "*",
+                "month_of_year": "*",
+            },
+            "config": {},
+        }
+        request = self._create_request("post", "/periodic_task/update/", update_data)
+        response = update_view(request)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert response.data["data"]["result"] is False
+        assert "not exist" in response.data["data"]["message"]
+
     def test_batch_delete_periodic_tasks(self):
         """测试批量删除周期任务"""
         # 创建两个周期任务
diff --git a/tests/engine/utils/test_client.py b/tests/engine/utils/test_client.py
index e8625fe993..6a6f6042bc 100644
--- a/tests/engine/utils/test_client.py
+++ b/tests/engine/utils/test_client.py
@@ -1,9 +1,31 @@
 """Test API client"""
+import importlib
+import sys
+import types
 from unittest import mock
 
 from bkflow.contrib.api.client import BaseComponentClient, BKComponentClient
 
 
+def _import_task_component_client(monkeypatch, module_info_cls):
+    """Import TaskComponentClient with a stubbed bkflow.admin.models.ModuleInfo.
+
+    Engine test settings may not include `bkflow.admin` in INSTALLED_APPS, so importing
+    the real Django model will raise at collection time.
+    """
+
+    if "bkflow.admin" not in sys.modules:
+        monkeypatch.setitem(sys.modules, "bkflow.admin", types.ModuleType("bkflow.admin"))
+
+    models_mod = types.ModuleType("bkflow.admin.models")
+    models_mod.ModuleInfo = module_info_cls
+    monkeypatch.setitem(sys.modules, "bkflow.admin.models", models_mod)
+
+    sys.modules.pop("bkflow.contrib.api.collections.task", None)
+    task_mod = importlib.import_module("bkflow.contrib.api.collections.task")
+    return task_mod.TaskComponentClient, task_mod
+
+
 class TestBKComponentClient:
     """Test BKComponentClient"""
 
@@ -126,3 +148,226 @@ def test_base_request(self, mock_http_post):
 
         assert result["result"] is True
         mock_http_post.assert_called_once()
+
+
+class TestTaskComponentClient:
+    def test_get_module_info_fallback(self, monkeypatch):
+        class FakeModuleInfo:
+            class DoesNotExist(Exception):
+                pass
+
+        default_module = types.SimpleNamespace(token="default_token", url="http://task.service", space_id=0)
+
+        def _get_side_effect(**kwargs):
+            if kwargs.get("space_id") == 999:
+                raise FakeModuleInfo.DoesNotExist
+            if kwargs.get("space_id") == 0:
+                return default_module
+            raise AssertionError(f"unexpected kwargs: {kwargs}")
+
+        FakeModuleInfo.objects = mock.Mock()
+        FakeModuleInfo.objects.get.side_effect = _get_side_effect
+
+        TaskComponentClient, _ = _import_task_component_client(monkeypatch, FakeModuleInfo)
+        client = TaskComponentClient(space_id=999)
+
+        assert client.module_info is default_module
+        assert FakeModuleInfo.objects.get.call_args_list == [
+            mock.call(type="TASK", space_id=999),
+            mock.call(type="TASK", space_id=0),
+        ]
+
+    def test_get_module_info_space_specific(self, monkeypatch):
+        class FakeModuleInfo:
+            class DoesNotExist(Exception):
+                pass
+
+        space_module = types.SimpleNamespace(token="space_token", url="http://task.space1", space_id=1)
+        FakeModuleInfo.objects = mock.Mock()
+        FakeModuleInfo.objects.get.return_value = space_module
+
+        TaskComponentClient, _ = _import_task_component_client(monkeypatch, FakeModuleInfo)
+        client = TaskComponentClient(space_id=1)
+
+        assert client.module_info is space_module
+        FakeModuleInfo.objects.get.assert_called_once_with(type="TASK", space_id=1)
+
+    def test_pre_process_headers(self, monkeypatch):
+        class FakeModuleInfo:
+            class DoesNotExist(Exception):
+                pass
+
+        space_module = types.SimpleNamespace(token="space_token", url="http://task.space1", space_id=1)
+        FakeModuleInfo.objects = mock.Mock()
+        FakeModuleInfo.objects.get.return_value = space_module
+
+        TaskComponentClient, task_mod = _import_task_component_client(monkeypatch, FakeModuleInfo)
+
+        monkeypatch.setattr(task_mod.settings, "APP_INTERNAL_TOKEN_HEADER_KEY", "X-Internal-Token", raising=False)
+        monkeypatch.setattr(task_mod.settings, "APP_INTERNAL_SPACE_ID_HEADER_KEY", "X-Space-Id", raising=False)
+        monkeypatch.setattr(
+            task_mod.settings, "APP_INTERNAL_FROM_SUPERUSER_HEADER_KEY", "X-From-Superuser", raising=False
+        )
+
+        client = TaskComponentClient(space_id=1, from_superuser=True)
+
+        headers = client._pre_process_headers(None)
+        assert headers["Content-Type"] == "application/json"
+        assert headers["X-Internal-Token"] == "space_token"
+        assert headers["X-Space-Id"] == "1"
+        assert headers["X-From-Superuser"] == "1"
+
+        existing = {"Authorization": "Bearer token"}
+        result = client._pre_process_headers(existing)
+        assert result["Authorization"] == "Bearer token"
+        assert result["X-Internal-Token"] == "space_token"
+        assert result["X-Space-Id"] == "1"
+        assert result["X-From-Superuser"] == "1"
+
+        # cover: space_id is None branch
+        client.space_id = None
+        headers = client._pre_process_headers(None)
+        assert headers["X-From-Superuser"] == "1"
+        assert "X-Space-Id" not in headers
+
+        # cover: from_superuser False branch
+        client.from_superuser = False
+        headers = client._pre_process_headers(None)
+        assert headers["X-From-Superuser"] == "0"
+
+    def test_request_wrappers_build_url_and_method(self, monkeypatch):
+        class FakeModuleInfo:
+            class DoesNotExist(Exception):
+                pass
+
+        space_module = types.SimpleNamespace(token="space_token", url="http://task.space1", space_id=1)
+        FakeModuleInfo.objects = mock.Mock()
+        FakeModuleInfo.objects.get.return_value = space_module
+
+        TaskComponentClient, _ = _import_task_component_client(monkeypatch, FakeModuleInfo)
+        client = TaskComponentClient(space_id=1)
+        client._request = mock.Mock(return_value={"result": True})
+
+        client.task_list({"a": 1})
+        client._request.assert_called_with(method="get", url="http://task.space1/task/", data={"a": 1})
+
+        client.update_labels(2, {"label_ids": [1]})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/2/update_labels/", data={"label_ids": [1]}
+        )
+
+        client.get_task_label_ref_count(1, "1,2")
+        client._request.assert_called_with(
+            method="get",
+            url="http://task.space1/task/get_task_label_ref_count/?space_id=1&label_ids=1,2",
+            data=None,
+        )
+
+        client.delete_task_label_relation({"task_id": 1, "label_ids": [1]})
+        client._request.assert_called_with(
+            method="post",
+            url="http://task.space1/task/delete_task_label_relation/",
+            data={"task_id": 1, "label_ids": [1]},
+        )
+
+        client.create_task({"name": "t"})
+        client._request.assert_called_with(method="post", url="http://task.space1/task/", data={"name": "t"})
+
+        client.get_task_detail(3)
+        client._request.assert_called_with(method="get", url="http://task.space1/task/3/", data=None)
+
+        client.delete_task(3)
+        client._request.assert_called_with(method="delete", url="http://task.space1/task/3/", data=None)
+
+        client.get_task_states(3, {"x": 1})
+        client._request.assert_called_with(method="get", url="http://task.space1/task/3/get_states/", data={"x": 1})
+
+        client.get_task_mock_data(3)
+        client._request.assert_called_with(method="get", url="http://task.space1/task/3/get_task_mock_data/", data=None)
+
+        client.operate_task(3, "pause", {"y": 2})
+        client._request.assert_called_with(method="post", url="http://task.space1/task/3/operate/pause/", data={"y": 2})
+
+        client.get_task_node_detail(3, "node", username="admin")
+        client._request.assert_called_with(
+            method="get",
+            url="http://task.space1/task/3/get_task_node_detail/node/?username=admin",
+            data=None,
+        )
+
+        client.node_operate(3, "node", "retry", {"z": 3})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/3/node_operate/node/retry/", data={"z": 3}
+        )
+
+        client.get_task_node_log(3, "node", 1)
+        client._request.assert_called_with(
+            method="get", url="http://task.space1/task/3/get_task_node_log/node/1/", data=None
+        )
+
+        client.render_current_constants(3)
+        client._request.assert_called_with(
+            method="get", url="http://task.space1/task/3/render_current_constants/", data=None
+        )
+
+        client.render_context_with_node_outputs(3, {"a": 1})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/3/render_context_with_node_outputs/", data={"a": 1}
+        )
+
+        client.get_task_operation_record(3)
+        client._request.assert_called_with(
+            method="get", url="http://task.space1/task/3/get_task_operation_record/", data=None
+        )
+
+        client.get_node_snapshot_config(3)
+        client._request.assert_called_with(
+            method="get", url="http://task.space1/task/3/get_node_snapshot_config/", data=None
+        )
+
+        client.get_tasks_states({"task_ids": [1]})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/get_tasks_states/", data={"task_ids": [1]}
+        )
+
+        client.trigger_engine_admin_action("inst", "pause")
+        client._request.assert_called_with(
+            method="post",
+            url="http://task.space1/task_engine_admin/api/v1/bamboo_engine/pause/inst/",
+            data=None,
+        )
+
+        client.batch_delete_tasks({"task_ids": [1]})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/batch_delete_tasks/", data={"task_ids": [1]}
+        )
+
+        client.create_periodic_task({"name": "p"})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/periodic_task/", data={"name": "p"}
+        )
+
+        client.update_periodic_task({"id": 1})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/periodic_task/update/", data={"id": 1}
+        )
+
+        client.batch_delete_periodic_task({"ids": [1]})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/periodic_task/batch_delete/", data={"ids": [1]}
+        )
+
+        client.get_engine_config({"a": 1})
+        client._request.assert_called_with(
+            method="get", url="http://task.space1/task/get_engine_config/", data={"a": 1}
+        )
+
+        client.upsert_engine_config({"a": 1})
+        client._request.assert_called_with(
+            method="post", url="http://task.space1/task/upsert_engine_config/", data={"a": 1}
+        )
+
+        client.delete_engine_config({"a": 1})
+        client._request.assert_called_with(
+            method="delete", url="http://task.space1/task/delete_engine_config/", data={"a": 1}
+        )
diff --git a/tests/interface/apigw/test_update_template.py b/tests/interface/apigw/test_update_template.py
index f587b8d49c..83f2f52ab7 100644
--- a/tests/interface/apigw/test_update_template.py
+++ b/tests/interface/apigw/test_update_template.py
@@ -164,3 +164,232 @@ def test_create_trigger_success(self, mock_create, mock_update):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.data["result"], True)
         self.assertEqual(response.data["data"]["triggers"][0]["name"], "old trigger new name")
+
+
+class TestTemplateSerializerLabelSync(TestCase):
+    def test_sync_template_labels_invalid_ids_raises_validation_error(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.template.serializers.template import TemplateSerializer
+
+        serializer = TemplateSerializer()
+
+        with patch("bkflow.template.serializers.template.Label.objects.check_label_ids") as mock_check:
+            mock_check.return_value = False
+
+            with self.assertRaises(ValidationError) as cm:
+                serializer._sync_template_lables(template_id=1, label_ids=[1, 2])
+
+        self.assertIn("标签不存在", str(cm.exception))
+
+    def test_sync_template_labels_set_labels_exception_raises_validation_error(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.template.serializers.template import TemplateSerializer
+
+        serializer = TemplateSerializer()
+
+        with patch("bkflow.template.serializers.template.Label.objects.check_label_ids") as mock_check:
+            mock_check.return_value = True
+
+            with patch("bkflow.template.serializers.template.TemplateLabelRelation.objects.set_labels") as mock_set:
+                mock_set.side_effect = Exception("db error")
+
+                with self.assertRaises(ValidationError) as cm:
+                    serializer._sync_template_lables(template_id=1, label_ids=[1, 2])
+
+        self.assertIn("标签设置失败", str(cm.exception))
+
+
+class TestApigwTemplateSerializers(TestCase):
+    def setUp(self):
+        self.factory = APIRequestFactory()
+        self.user = User.objects.create_user(username="test_user", password="password")
+
+    def build_pipeline_tree(self):
+        start = EmptyStartEvent()
+        act_1 = ServiceActivity(component_code="example_component")
+        end = EmptyEndEvent()
+
+        start.extend(act_1).extend(end)
+        pipeline = build_tree(start, data={"test": "test"})
+        return pipeline
+
+    def create_space(self):
+        return Space.objects.create(app_code="test", platform_url="http://test.com", name="space")
+
+    def make_request(self, username="test_user"):
+        request = self.factory.post("/apigw/")
+        if username:
+            request.user = self.user
+            request.user.username = username
+        else:
+            # serializer only relies on request.user.username
+            request.user = type("DummyUser", (), {"username": ""})()
+        return request
+
+    def test_create_template_serializer_maps_bind_app_code_to_bk_app_code(self):
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+
+        space = self.create_space()
+        request = self.make_request(username="test_user")
+
+        serializer = CreateTemplateSerializer(
+            data={"name": "test", "bind_app_code": "app_code"},
+            context={"request": request, "space_id": space.id},
+        )
+        serializer.is_valid(raise_exception=True)
+        self.assertEqual(serializer.validated_data["bk_app_code"], "app_code")
+        self.assertNotIn("bind_app_code", serializer.validated_data)
+
+    def test_create_template_serializer_scope_type_and_value_must_both_present(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+
+        space = self.create_space()
+        request = self.make_request(username="test_user")
+
+        serializer = CreateTemplateSerializer(
+            data={"name": "test", "scope_type": "biz"},
+            context={"request": request, "space_id": space.id},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_create_template_serializer_source_template_not_exists_raises(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+
+        space = self.create_space()
+        request = self.make_request(username="test_user")
+
+        serializer = CreateTemplateSerializer(
+            data={"name": "test", "source_template_id": 99999999},
+            context={"request": request, "space_id": space.id},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_create_template_serializer_only_copy_template_in_same_space(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+        from bkflow.template.models import TemplateSnapshot
+
+        space_1 = self.create_space()
+        space_2 = Space.objects.create(app_code="test2", platform_url="http://test.com", name="space2")
+        pipeline_tree = self.build_pipeline_tree()
+        snapshot = TemplateSnapshot.create_snapshot(pipeline_tree=pipeline_tree, username="test_user", version="1.0.0")
+        template = Template.objects.create(name="src", space_id=space_1.id, snapshot_id=snapshot.id)
+
+        request = self.make_request(username="test_user")
+        serializer = CreateTemplateSerializer(
+            data={"name": "test", "source_template_id": template.id},
+            context={"request": request, "space_id": space_2.id},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    @patch("bkflow.apigw.serializers.template.validate_pipeline_tree")
+    def test_create_template_serializer_pipeline_validate_error_raises(self, mock_validate):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+
+        mock_validate.side_effect = Exception("invalid pipeline")
+
+        space = self.create_space()
+        request = self.make_request(username="test_user")
+        serializer = CreateTemplateSerializer(
+            data={"name": "test", "pipeline_tree": {"invalid": True}},
+            context={"request": request, "space_id": space.id},
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            serializer.is_valid(raise_exception=True)
+        self.assertIn("pipeline校验不通过", str(cm.exception))
+
+    def test_create_template_serializer_creator_and_apigw_user_both_empty_raises(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import CreateTemplateSerializer
+
+        space = self.create_space()
+        request = self.make_request(username="")
+
+        serializer = CreateTemplateSerializer(
+            data={"name": "test"},
+            context={"request": request, "space_id": space.id},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_delete_template_serializer_validate_space_id_invalid_raises(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import DeleteTemplateSerializer
+
+        serializer = DeleteTemplateSerializer(data={"template_id": 1, "space_id": 99999999})
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_delete_template_serializer_validate_space_id_valid(self):
+        from bkflow.apigw.serializers.template import DeleteTemplateSerializer
+
+        space = self.create_space()
+        serializer = DeleteTemplateSerializer(data={"template_id": 1, "space_id": space.id})
+        serializer.is_valid(raise_exception=True)
+        self.assertEqual(serializer.validated_data["space_id"], space.id)
+
+    def test_update_template_serializer_scope_type_and_value_must_both_present(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import UpdateTemplateSerializer
+
+        request = self.make_request(username="test_user")
+        serializer = UpdateTemplateSerializer(
+            data={"scope_type": "biz"},
+            context={"request": request},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    def test_update_template_serializer_operator_and_apigw_user_both_empty_raises(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import UpdateTemplateSerializer
+
+        request = self.make_request(username="")
+        serializer = UpdateTemplateSerializer(
+            data={"name": "test"},
+            context={"request": request},
+        )
+
+        with self.assertRaises(ValidationError):
+            serializer.is_valid(raise_exception=True)
+
+    @patch("bkflow.apigw.serializers.template.validate_pipeline_tree")
+    def test_update_template_serializer_pipeline_validate_error_raises(self, mock_validate):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.apigw.serializers.template import UpdateTemplateSerializer
+
+        mock_validate.side_effect = Exception("invalid pipeline")
+
+        request = self.make_request(username="test_user")
+        serializer = UpdateTemplateSerializer(
+            data={"pipeline_tree": {"invalid": True}},
+            context={"request": request},
+        )
+
+        with self.assertRaises(ValidationError) as cm:
+            serializer.is_valid(raise_exception=True)
+        self.assertIn("pipeline校验不通过", str(cm.exception))
diff --git a/tests/interface/task/test_task_views.py b/tests/interface/task/test_task_views.py
index 0f43cd7023..ca3ca20443 100644
--- a/tests/interface/task/test_task_views.py
+++ b/tests/interface/task/test_task_views.py
@@ -54,7 +54,10 @@ def setup_method(self):
     def test_get_task_list(self, mock_client_class):
         """Test get_task_list method"""
         mock_client = mock.Mock()
-        mock_client.task_list.return_value = {"result": True, "data": [{"id": 1, "name": "Task 1"}]}
+        mock_client.task_list.return_value = {
+            "result": True,
+            "data": {"results": [{"id": 1, "name": "Task 1", "labels": []}]},
+        }
         mock_client_class.return_value = mock_client
 
         view = TaskInterfaceAdminViewSet.as_view({"get": "get_task_list"})
@@ -65,7 +68,57 @@ def test_get_task_list(self, mock_client_class):
 
         assert response.status_code == 200
         mock_client.task_list.assert_called_once()
-        assert mock_client_class.called_with(space_id=self.space.id)
+        mock_client_class.assert_called_once_with(space_id=self.space.id)
+
+    @mock.patch("bkflow.interface.task.view.Label.objects.get_labels_map")
+    @mock.patch("bkflow.interface.task.view.Label.get_label_ids_by_names")
+    @mock.patch("bkflow.interface.task.view.TaskComponentClient")
+    def test_get_task_list_with_labels(self, mock_client_class, mock_get_label_ids, mock_get_labels_map):
+        """Test get_task_list method with label query param, should convert name to ids and then map ids to names"""
+        mock_get_label_ids.return_value = [1, 2]
+        mock_get_labels_map.return_value = {1: "label_1", 2: "label_2"}
+
+        mock_client = mock.Mock()
+        mock_client.task_list.return_value = {
+            "result": True,
+            "data": {"results": [{"id": 1, "name": "Task 1", "labels": [1, 2]}]},
+        }
+        mock_client_class.return_value = mock_client
+
+        view = TaskInterfaceAdminViewSet.as_view({"get": "get_task_list"})
+        request = self.factory.get(f"/admin/tasks/get_task_list/{self.space.id}/?label=label_1,label_2")
+        force_authenticate(request, user=self.admin_user)
+
+        response = view(request, space_id=self.space.id)
+
+        assert response.status_code == 200
+        # Should convert label names to ids for query
+        call_data = mock_client.task_list.call_args[1]["data"]
+        assert call_data["label"] == ["1,2"]
+        # Should map ids back to label names in response
+        assert response.data["data"]["results"][0]["labels"] == ["label_1", "label_2"]
+
+    @mock.patch("bkflow.interface.task.view.Label.objects.get_labels_map")
+    @mock.patch("bkflow.interface.task.view.TaskComponentClient")
+    def test_update_labels(self, mock_client_class, mock_get_labels_map):
+        """Test update_labels method, should map returned label ids to label names"""
+        mock_get_labels_map.return_value = {1: "label_1", 2: "label_2"}
+
+        mock_client = mock.Mock()
+        mock_client.update_labels.return_value = {"result": True, "data": [1, 2]}
+        mock_client_class.return_value = mock_client
+
+        view = TaskInterfaceAdminViewSet.as_view({"post": "update_labels"})
+        request = self.factory.post(
+            f"/admin/tasks/update_labels/{self.space.id}/1/", {"label_ids": [1, 2]}, format="json"
+        )
+        force_authenticate(request, user=self.admin_user)
+
+        response = view(request, space_id=self.space.id, pk=1)
+
+        assert response.status_code == 200
+        mock_client.update_labels.assert_called_once()
+        assert response.data["data"] == ["label_1", "label_2"]
 
     @mock.patch("bkflow.interface.task.view.TaskComponentClient")
     def test_get_tasks_states(self, mock_client_class):
@@ -277,6 +330,39 @@ def test_inject_user_task_auth_with_scope_permissions(self):
         assert "auth" in data["data"]
         assert PermissionType.VIEW.value in data["data"]["auth"]
 
+    def test_inject_user_task_auth_mock_task_with_template_permission(self):
+        """Test _inject_user_task_auth for MOCK task, should include TEMPLATE permission query"""
+        Token.objects.create(
+            token="token_template_mock",
+            space_id=self.space.id,
+            user="normaluser",
+            resource_type=ResourceType.TEMPLATE.value,
+            resource_id="456",
+            permission_type=PermissionType.MOCK.value,
+            expired_time=timezone.now() + timezone.timedelta(hours=1),
+        )
+
+        request = MagicMock()
+        request.user.is_superuser = False
+        request.user.username = "normaluser"
+        request.is_space_superuser = False
+
+        data = {
+            "result": True,
+            "data": {
+                "id": "123",
+                "space_id": self.space.id,
+                "scope_type": "project",
+                "scope_value": "456",
+                "create_method": "MOCK",
+                "template_id": "456",
+            },
+        }
+
+        TaskInterfaceViewSet._inject_user_task_auth(request, data)
+
+        assert PermissionType.MOCK.value in data["data"]["auth"]
+
     def test_inject_user_task_auth_result_false(self):
         """Test _inject_user_task_auth when result is False"""
         request = MagicMock()
diff --git a/tests/interface/template/test_template_views.py b/tests/interface/template/test_template_views.py
index 6e6a83b8fa..fd425bbb5b 100644
--- a/tests/interface/template/test_template_views.py
+++ b/tests/interface/template/test_template_views.py
@@ -24,6 +24,7 @@
 from rest_framework.test import APIRequestFactory, force_authenticate
 
 from bkflow.decision_table.models import DecisionTable
+from bkflow.label.models import Label, TemplateLabelRelation
 from bkflow.space.configs import FlowVersioning
 from bkflow.space.models import Space, SpaceConfig
 from bkflow.template.models import (
@@ -1581,3 +1582,670 @@ def test_create_mock_scheme_duplicate(self):
             assert response.status_code in [400, 200]
         except Exception:
             pass
+
+
+@pytest.mark.django_db
+class TestTemplateFilterAndBranches:
+    def setup_method(self):
+        self.factory = APIRequestFactory()
+        self.user = User.objects.create_superuser(username="test_user", password="password")
+        self.admin_user, _ = User.objects.get_or_create(
+            username="admin", defaults={"is_superuser": True, "is_staff": True}
+        )
+        self.space = Space.objects.create(name="Test Space", app_code="test_app")
+        self.pipeline_tree = build_pipeline_tree()
+
+    def _create_template(self, name="t1"):
+        snapshot = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.0")
+        template = Template.objects.create(
+            name=name,
+            space_id=self.space.id,
+            snapshot_id=snapshot.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snapshot.template_id = template.id
+        snapshot.save()
+        return template
+
+    def test_filter_by_labels_returns_queryset_when_no_match(self):
+        """Cover TemplateFilterSet.filter_by_labels empty label_ids branch (137-139)."""
+        template = self._create_template("t_no_label")
+
+        view = TemplateViewSet.as_view({"get": "list_template"})
+        request = self.factory.get(f"/templates/list_template/?space_id={self.space.id}&label=__not_exists__")
+        force_authenticate(request, user=self.user)
+        response = view(request)
+
+        assert response.status_code == 200
+        results = response.data.get("data", {}).get("results", [])
+        # should not error and should include created template
+        assert any(item.get("id") == template.id for item in results)
+
+    def test_filter_by_labels_filters_queryset(self):
+        """Cover TemplateFilterSet.filter_by_labels subquery filter branch (141-143)."""
+        label = Label.objects.create(
+            name="tag_1",
+            creator="test_user",
+            updated_by="test_user",
+            space_id=self.space.id,
+            label_scope=["template"],
+        )
+        template_hit = self._create_template("t_hit")
+        template_miss = self._create_template("t_miss")
+        TemplateLabelRelation.objects.create(template_id=template_hit.id, label_id=label.id)
+
+        view = TemplateViewSet.as_view({"get": "list_template"})
+        request = self.factory.get(f"/templates/list_template/?space_id={self.space.id}&label=tag_1")
+        force_authenticate(request, user=self.user)
+        response = view(request)
+
+        assert response.status_code == 200
+        results = response.data.get("data", {}).get("results", [])
+        ids = {item.get("id") for item in results}
+        assert template_hit.id in ids
+        assert template_miss.id not in ids
+
+    def test_admin_list_injects_labels_and_trigger_flag_false(self):
+        """Cover AdminTemplateViewSet.list label injection and trigger flag false branch."""
+        template = self._create_template("t_admin")
+        label = Label.objects.create(
+            name="tag_admin",
+            creator="test_user",
+            updated_by="test_user",
+            space_id=self.space.id,
+            label_scope=["template"],
+        )
+        TemplateLabelRelation.objects.create(template_id=template.id, label_id=label.id)
+
+        view = AdminTemplateViewSet.as_view({"get": "list"})
+        request = self.factory.get(f"/admin/templates/?space_id={self.space.id}")
+        force_authenticate(request, user=self.admin_user)
+        response = view(request)
+
+        assert response.status_code == 200
+        results = response.data.get("data", {}).get("results", [])
+        item = next((r for r in results if r.get("id") == template.id), None)
+        assert item is not None
+        assert item.get("has_interval_trigger") is False
+        assert any(_label.get("id") == label.id for _label in item.get("labels", []))
+
+    @mock.patch("bkflow.template.views.template.SpaceConfig.get_config")
+    @mock.patch("bkflow.template.views.template.build_default_pipeline_tree_with_space_id")
+    def test_create_template_flow_versioning_true_creates_draft_snapshot(self, mock_build_tree, mock_get_config):
+        """Cover create_template flow-versioning true branch (create_draft_snapshot)."""
+        mock_build_tree.return_value = self.pipeline_tree
+        mock_get_config.return_value = "true"
+
+        view = AdminTemplateViewSet.as_view({"post": "create_template"})
+        data = {"name": "New Template", "desc": "d", "label_ids": []}
+        request = self.factory.post(f"/admin/templates/create_default_template/{self.space.id}/", data, format="json")
+        force_authenticate(request, user=self.admin_user)
+        response = view(request, space_id=self.space.id)
+
+        assert response.status_code == 200
+        # NOTE: response payload is wrapped by SimpleGenericViewSet.finalize_response
+        template_id = response.data["data"]["data"]["id"]
+        template = Template.objects.get(id=template_id)
+        snapshot = TemplateSnapshot.objects.get(id=template.snapshot_id)
+        assert snapshot.draft is True
+
+
+@pytest.mark.django_db
+class TestTemplateViewSetMoreExceptionBranches:
+    def setup_method(self):
+        self.factory = APIRequestFactory()
+        self.user = User.objects.create_superuser(username="test_user", password="password")
+        self.space = Space.objects.create(name="Test Space", app_code="test_app")
+        self.pipeline_tree = build_pipeline_tree()
+        SpaceConfig.objects.create(
+            space_id=self.space.id, name=FlowVersioning.name, value_type="TEXT", text_value="true"
+        )
+
+        snapshot = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.0")
+        self.template = Template.objects.create(
+            name="Test Template",
+            space_id=self.space.id,
+            snapshot_id=snapshot.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snapshot.template_id = self.template.id
+        snapshot.save()
+
+    def test_preview_task_tree_get_pipeline_tree_error_wrapped(self, monkeypatch):
+        """Cover preview_task_tree internal exception catch (579-604)."""
+
+        def _boom(_version):
+            raise Exception("boom")
+
+        monkeypatch.setattr(Template, "get_pipeline_tree_by_version", lambda _self, _version: _boom(_version))
+
+        view = TemplateViewSet.as_view({"post": "preview_task_tree"})
+        data = {"appoint_node_ids": [], "is_all_nodes": True, "version": "1.0.0", "is_draft": False}
+        request = self.factory.post(f"/templates/{self.template.id}/preview_task_tree/", data, format="json")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
+
+    @mock.patch("bkflow.template.views.template.TaskComponentClient")
+    def test_create_mock_task_raises_api_response_error(self, mock_client_class):
+        """Cover create_mock_task API failure branch (619-622)."""
+        mock_client = mock.Mock()
+        mock_client.create_task.return_value = {"result": False, "message": "api error"}
+        mock_client_class.return_value = mock_client
+
+        view = TemplateViewSet.as_view({"post": "create_mock_task"})
+        data = {
+            "name": "Mock Task",
+            "creator": "test_user",
+            "pipeline_tree": self.pipeline_tree,
+            "mock_data": {"nodes": [], "outputs": {}, "mock_data_ids": {}},
+            "include_node_ids": [],
+        }
+        request = self.factory.post(f"/templates/{self.template.id}/create_mock_task/", data, format="json")
+        force_authenticate(request, user=self.user)
+
+        with pytest.raises(Exception):
+            view(request, pk=self.template.id)
+
+    def test_get_draft_template_versioning_disabled(self):
+        """Cover get_draft_template versioning disabled branch (657)."""
+        space2 = Space.objects.create(name="No Version Space", app_code="test_app2")
+        # explicit disable versioning
+        SpaceConfig.objects.create(space_id=space2.id, name=FlowVersioning.name, value_type="TEXT", text_value="false")
+
+        snapshot = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.0")
+        template = Template.objects.create(
+            name="t2",
+            space_id=space2.id,
+            snapshot_id=snapshot.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snapshot.template_id = template.id
+        snapshot.save()
+
+        view = TemplateViewSet.as_view({"get": "get_draft_template"})
+        request = self.factory.get(f"/templates/{template.id}/get_draft_template/")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
+
+    def test_calculate_version_invalid_version_returns_exception_response(self):
+        """Cover calculate_version ValueError branch (675-680)."""
+        # Template.version is a property derived from TemplateSnapshot.version when versioning is enabled,
+        # so only updating snapshot version is enough.
+        TemplateSnapshot.objects.filter(id=self.template.snapshot_id).update(version="invalid")
+
+        view = TemplateViewSet.as_view({"get": "calculate_version"})
+        request = self.factory.get(f"/templates/{self.template.id}/calculate_version/")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
+
+    def test_rollback_template_version_missing(self):
+        """Cover rollback_template missing version branch (723)."""
+        view = TemplateViewSet.as_view({"post": "rollback_template"})
+        request = self.factory.post(f"/templates/{self.template.id}/rollback_template/", {}, format="json")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert "version" in str(response.data)
+
+
+@pytest.mark.django_db
+class TestTemplateViewsMoreCoverage:
+    def setup_method(self):
+        self.factory = APIRequestFactory()
+        self.admin_user, _ = User.objects.get_or_create(
+            username="admin", defaults={"is_superuser": True, "is_staff": True}
+        )
+        self.user = User.objects.create_superuser(username="test_user", password="password")
+        self.space = Space.objects.create(name="Test Space", app_code="test_app")
+        self.pipeline_tree = build_pipeline_tree()
+
+        # enable flow versioning by default in this class
+        SpaceConfig.objects.create(
+            space_id=self.space.id, name=FlowVersioning.name, value_type="TEXT", text_value="true"
+        )
+
+        snapshot = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.0")
+        self.template = Template.objects.create(
+            name="Test Template",
+            space_id=self.space.id,
+            snapshot_id=snapshot.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snapshot.template_id = self.template.id
+        snapshot.save()
+
+    def test_admin_list_without_pagination_hits_return_response_183(self, monkeypatch):
+        """Cover AdminTemplateViewSet.list non-paginated return (183)."""
+        monkeypatch.setattr(AdminTemplateViewSet, "pagination_class", None)
+
+        view = AdminTemplateViewSet.as_view({"get": "list"})
+        request = self.factory.get(f"/admin/templates/?space_id={self.space.id}")
+        force_authenticate(request, user=self.admin_user)
+        response = view(request)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        assert isinstance(response.data.get("data"), list)
+
+    def test_admin_update_proxy_to_super_update_211(self):
+        """Cover AdminTemplateViewSet.update -> super().update (211) without touching serializer validation."""
+        from rest_framework.response import Response
+
+        with mock.patch("rest_framework.viewsets.ModelViewSet.update", return_value=Response({"ok": True})):
+            view = AdminTemplateViewSet.as_view({"put": "update"})
+            request = self.factory.put(f"/admin/templates/{self.template.id}/", {}, format="json")
+            force_authenticate(request, user=self.admin_user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+
+    @mock.patch("bkflow.template.views.template.event_broadcast_signal")
+    @mock.patch("bkflow.template.views.template.PipelineTemplateWebPreviewer.preview_pipeline_tree_exclude_task_nodes")
+    @mock.patch("bkflow.template.views.template.TaskComponentClient")
+    def test_admin_create_task_success_hits_event_broadcast_250_263(self, mock_client_cls, _mock_preview, mock_signal):
+        """Cover AdminTemplateViewSet.create_task success branch and event broadcast (250-263)."""
+        mock_client = mock.Mock()
+        mock_client.create_task.return_value = {
+            "result": True,
+            "data": {"id": 1, "name": "task", "template_id": self.template.id, "parameters": {}},
+        }
+        mock_client_cls.return_value = mock_client
+
+        view = AdminTemplateViewSet.as_view({"post": "create_task"})
+        data = {"template_id": self.template.id, "name": "task", "creator": "test_user", "constants": {}}
+        request = self.factory.post(f"/admin/templates/create_task/{self.space.id}/", data, format="json")
+        force_authenticate(request, user=self.admin_user)
+        response = view(request, space_id=self.space.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        mock_signal.send.assert_called_once()
+
+    def test_admin_batch_delete_continue_branch_311(self):
+        """Cover batch_delete 'continue' branch when root template is also in delete list (311)."""
+        snapshot2 = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.1")
+        root = Template.objects.create(
+            name="Root",
+            space_id=self.space.id,
+            snapshot_id=snapshot2.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snapshot2.template_id = root.id
+        snapshot2.save()
+
+        # Mock TemplateReference queryset to make sure the loop runs and hits the `continue` line (311)
+        mocked_ref_qs = mock.Mock()
+        mocked_ref_qs.values_list.return_value = [str(root.id)]
+        mocked_ref_qs.values.return_value = [
+            {"subprocess_template_id": str(self.template.id), "root_template_id": str(root.id)}
+        ]
+
+        view = AdminTemplateViewSet.as_view({"post": "batch_delete"})
+        data = {"space_id": self.space.id, "is_full": False, "template_ids": [root.id, self.template.id]}
+        request = self.factory.post("/admin/templates/batch_delete/", data, format="json")
+        force_authenticate(request, user=self.admin_user)
+
+        original_filter = Template.objects.filter
+
+        def _template_filter_side_effect(*args, **kwargs):
+            # Only affect the query that builds `templates_map` so that `root_id not in templates_map` is True
+            if "id__in" in kwargs and kwargs.get("is_deleted") is False and "space_id" not in kwargs:
+                return original_filter(id__in=[self.template.id], is_deleted=False)
+            return original_filter(*args, **kwargs)
+
+        with mock.patch(
+            "bkflow.template.views.template.TemplateReference.objects.filter", return_value=mocked_ref_qs
+        ), mock.patch(
+            "bkflow.template.views.template.Template.objects.filter", side_effect=_template_filter_side_effect
+        ), mock.patch(
+            "bkflow.template.views.template.Trigger.objects.batch_delete_by_ids"
+        ):
+            response = view(request)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+
+    def test_admin_batch_delete_is_full_hits_326(self):
+        """Cover batch_delete is_full=True update-all branch (326)."""
+        view = AdminTemplateViewSet.as_view({"post": "batch_delete"})
+        data = {"space_id": self.space.id, "is_full": True, "template_ids": [self.template.id]}
+        request = self.factory.post("/admin/templates/batch_delete/", data, format="json")
+        force_authenticate(request, user=self.admin_user)
+        with mock.patch("bkflow.template.views.template.Trigger.objects.batch_delete_by_ids"):
+            response = view(request)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        assert Template.objects.filter(space_id=self.space.id, is_deleted=True).exists()
+
+    def test_template_version_list_without_pagination_hits_390(self, monkeypatch):
+        """Cover TemplateVersionViewSet.list non-paginated return (390)."""
+        monkeypatch.setattr(TemplateVersionViewSet, "pagination_class", None)
+
+        view = TemplateVersionViewSet.as_view({"get": "list"})
+        request = self.factory.get(f"/template_versions/?template_id={self.template.id}")
+        force_authenticate(request, user=self.user)
+        response = view(request)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        assert isinstance(response.data.get("data"), list)
+
+    def test_template_version_delete_snapshot_template_missing_397_398(self):
+        """Cover delete_snapshot when snapshot's template does not exist (397-398)."""
+        snap = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "9.9.9")
+        snap.template_id = 999999
+        snap.save(update_fields=["template_id"])
+
+        view = TemplateVersionViewSet.as_view({"post": "delete_snapshot"})
+        request = self.factory.post(f"/template_versions/{snap.id}/delete_snapshot/", {}, format="json")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=snap.id)
+
+        assert response.status_code == 400
+
+    def test_list_template_versioning_filters_draft_and_hits_456(self, monkeypatch):
+        """Cover list_template versioning filter branch (443-448) and non-pagination return (456)."""
+        monkeypatch.setattr(TemplateViewSet, "pagination_class", None)
+
+        # draft snapshot template should be filtered out
+        draft_snapshot = TemplateSnapshot.create_draft_snapshot(self.pipeline_tree, "test_user")
+        t_draft = Template.objects.create(
+            name="Draft",
+            space_id=self.space.id,
+            snapshot_id=draft_snapshot.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        draft_snapshot.template_id = t_draft.id
+        draft_snapshot.save(update_fields=["template_id"])
+
+        view = TemplateViewSet.as_view({"get": "list_template"})
+        request = self.factory.get(f"/templates/list_template/?space_id={self.space.id}")
+        force_authenticate(request, user=self.user)
+        response = view(request)
+
+        assert response.status_code == 200
+        results = response.data.get("data", [])
+        ids = {item.get("id") for item in results}
+        assert t_draft.id not in ids
+        assert self.template.id in ids
+
+    def test_get_space_related_configs_raises_when_default_not_exists_546_548(self):
+        """Cover get_space_related_configs catch and re-raise (546-548)."""
+        from bkflow.space.exceptions import SpaceConfigDefaultValueNotExists
+
+        def _boom(*args, **kwargs):
+            raise SpaceConfigDefaultValueNotExists("no default")
+
+        with mock.patch("bkflow.template.views.template.SpaceConfig.get_config", side_effect=_boom):
+            view = TemplateViewSet.as_view({"get": "get_space_related_configs"})
+            request = self.factory.get(f"/templates/{self.template.id}/get_space_related_configs/")
+            force_authenticate(request, user=self.user)
+            with pytest.raises(SpaceConfigDefaultValueNotExists):
+                view(request, pk=self.template.id)
+
+    def test_get_space_related_configs_uniform_api_branch_552(self):
+        """Cover uniform api config handler branch (552)."""
+        from bkflow.space.configs import GatewayExpressionConfig, UniformApiConfig
+
+        def _get_config(space_id=None, config_name=None, *args, **kwargs):
+            if config_name == GatewayExpressionConfig.name:
+                return "{}"
+            if config_name == UniformApiConfig.name:
+                return '{"token": "x"}'
+            return "true"
+
+        handler_ret = mock.Mock()
+        handler_ret.dict.return_value = {"handled": True}
+        with mock.patch("bkflow.template.views.template.SpaceConfig.get_config", side_effect=_get_config), mock.patch(
+            "bkflow.template.views.template.UniformAPIConfigHandler"
+        ) as handler_cls:
+            handler_cls.return_value.handle.return_value = handler_ret
+
+            view = TemplateViewSet.as_view({"get": "get_space_related_configs"})
+            request = self.factory.get(f"/templates/{self.template.id}/get_space_related_configs/")
+            force_authenticate(request, user=self.user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        data = response.data.get("data", {})
+        assert UniformApiConfig.name in data
+        assert data[UniformApiConfig.name] == {"handled": True}
+
+    def test_template_update_injects_labels_460_468(self):
+        """Cover TemplateViewSet.update label injection (460-468) by stubbing serializer and perform_update."""
+        label = Label.objects.create(
+            name="tag_upd",
+            creator="test_user",
+            updated_by="test_user",
+            space_id=self.space.id,
+            label_scope=["template"],
+        )
+        TemplateLabelRelation.objects.set_labels(self.template.id, [label.id])
+
+        template_id = self.template.id
+
+        class _StubSerializer:
+            def __init__(self):
+                self.data = {"id": template_id, "name": "n"}
+
+            def is_valid(self, raise_exception=False):
+                return True
+
+        def _get_serializer(_self, *args, **kwargs):
+            return _StubSerializer()
+
+        with mock.patch.object(TemplateViewSet, "get_serializer", _get_serializer), mock.patch.object(
+            TemplateViewSet, "perform_update", lambda *_args, **_kwargs: None
+        ):
+            view = TemplateViewSet.as_view({"put": "update"})
+            request = self.factory.put(f"/templates/{self.template.id}/", {}, format="json")
+            force_authenticate(request, user=self.user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        assert any(_label.get("id") == label.id for _label in response.data.get("data", {}).get("labels", []))
+
+    def test_update_labels_action_473_477(self):
+        """Cover update_labels transaction block and return (473-477)."""
+        label = Label.objects.create(
+            name="tag2",
+            creator="test_user",
+            updated_by="test_user",
+            space_id=self.space.id,
+            label_scope=["template"],
+        )
+        view = TemplateViewSet.as_view({"post": "update_labels"})
+        request = self.factory.post(
+            f"/templates/{self.template.id}/update_labels/", {"label_ids": [label.id]}, format="json"
+        )
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("data") == [label.id]
+
+    def test_analysis_constants_ref_exception_489_491(self):
+        """Cover analysis_constants_ref exception branch (489-491)."""
+        from bkflow.template.exceptions import AnalysisConstantsRefException
+
+        with mock.patch(
+            "bkflow.template.views.template.analysis_pipeline_constants_ref", side_effect=Exception("boom")
+        ):
+            view = TemplateViewSet.as_view({"post": "analysis_constants_ref"})
+            request = self.factory.post("/templates/analysis_constants_ref/", {"constants": {}}, format="json")
+            force_authenticate(request, user=self.user)
+            with pytest.raises(AnalysisConstantsRefException):
+                view(request)
+
+    def test_analysis_constants_ref_nodefined_branch_500(self):
+        """Cover analysis_constants_ref nodefined assignment (500)."""
+        with mock.patch("bkflow.template.views.template.analysis_pipeline_constants_ref", return_value={"x": "y"}):
+            view = TemplateViewSet.as_view({"post": "analysis_constants_ref"})
+            request = self.factory.post("/templates/analysis_constants_ref/", {"constants": {}}, format="json")
+            force_authenticate(request, user=self.user)
+            response = view(request)
+
+        assert response.status_code == 200
+        assert response.data.get("data", {}).get("nodefined", {}).get("x") == "y"
+
+    def test_draw_pipeline_includes_position_kwargs_515(self):
+        """Cover draw_pipeline POSITION kwargs branch (515)."""
+        with mock.patch("bkflow.template.views.template.draw_pipeline_tree") as m:
+            view = TemplateViewSet.as_view({"post": "draw_pipeline"})
+            request = self.factory.post(
+                "/templates/draw_pipeline/",
+                {"pipeline_tree": self.pipeline_tree, "canvas_width": 1300, "activity_size": [150, 54]},
+                format="json",
+            )
+            force_authenticate(request, user=self.user)
+            response = view(request)
+
+        assert response.status_code == 200
+        m.assert_called_once()
+
+    @mock.patch("bkflow.template.views.template.preview_template_tree", return_value={"ok": True})
+    def test_preview_task_tree_draft_success_covers_569_604(self, _mock_preview):
+        """Cover preview_task_tree is_draft branch and success path (569, 579-604)."""
+        draft = TemplateSnapshot.create_draft_snapshot(self.pipeline_tree, "test_user")
+        draft.template_id = self.template.id
+        draft.save(update_fields=["template_id"])
+
+        with mock.patch.object(Template, "outputs", lambda *_args, **_kwargs: {}):
+            view = TemplateViewSet.as_view({"post": "preview_task_tree"})
+            data = {"appoint_node_ids": [], "is_all_nodes": True, "version": "1.0.0", "is_draft": True}
+            request = self.factory.post(f"/templates/{self.template.id}/preview_task_tree/", data, format="json")
+            force_authenticate(request, user=self.user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        assert response.data.get("data", {}).get("name") == self.template.name
+
+    def test_preview_task_tree_not_all_nodes_hits_exclude_task_nodes_585(self):
+        """Cover preview_task_tree not-all-nodes branch (585)."""
+        with mock.patch.object(
+            Template, "get_pipeline_tree_by_version", return_value=self.pipeline_tree
+        ), mock.patch.object(Template, "outputs", lambda *_args, **_kwargs: {}), mock.patch(
+            "bkflow.template.views.template.PipelineTemplateWebPreviewer."
+            "get_template_exclude_task_nodes_with_appoint_nodes",
+            return_value=["x"],
+        ) as m_get_exclude, mock.patch(
+            "bkflow.template.views.template.preview_template_tree", return_value={"ok": True}
+        ):
+            view = TemplateViewSet.as_view({"post": "preview_task_tree"})
+            data = {"appoint_node_ids": ["n1"], "is_all_nodes": False, "version": "1.0.0", "is_draft": False}
+            request = self.factory.post(f"/templates/{self.template.id}/preview_task_tree/", data, format="json")
+            force_authenticate(request, user=self.user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+        m_get_exclude.assert_called_once()
+
+    def test_preview_task_tree_outer_exception_logged_591_594(self):
+        """Cover preview_task_tree outer exception handler logging (591-594)."""
+        with mock.patch.object(Template, "get_pipeline_tree_by_version", return_value=self.pipeline_tree), mock.patch(
+            "bkflow.template.views.template.preview_template_tree", side_effect=Exception("boom")
+        ):
+            view = TemplateViewSet.as_view({"post": "preview_task_tree"})
+            data = {"appoint_node_ids": [], "is_all_nodes": True, "version": "1.0.0", "is_draft": False}
+            request = self.factory.post(f"/templates/{self.template.id}/preview_task_tree/", data, format="json")
+            force_authenticate(request, user=self.user)
+            with pytest.raises(Exception):
+                view(request, pk=self.template.id)
+
+    @mock.patch("bkflow.template.views.template.PipelineTemplateWebPreviewer.preview_pipeline_tree_exclude_task_nodes")
+    @mock.patch(
+        "bkflow.template.views.template.PipelineTemplateWebPreviewer.get_template_exclude_task_nodes_with_appoint_nodes"
+    )
+    @mock.patch("bkflow.template.views.template.TaskComponentClient")
+    def test_create_mock_task_include_node_ids_branch_619_622(self, mock_client_cls, mock_get_exclude, _mock_preview):
+        """Cover create_mock_task include_node_ids branch (619-622)."""
+        mock_get_exclude.return_value = []
+        mock_client = mock.Mock()
+        mock_client.create_task.return_value = {"result": True, "data": {"id": 11}}
+        mock_client_cls.return_value = mock_client
+
+        view = TemplateViewSet.as_view({"post": "create_mock_task"})
+        data = {
+            "name": "Mock Task",
+            "creator": "test_user",
+            "pipeline_tree": self.pipeline_tree,
+            "mock_data": {"nodes": [], "outputs": {}, "mock_data_ids": {}},
+            "include_node_ids": ["node1"],
+        }
+        request = self.factory.post(f"/templates/{self.template.id}/create_mock_task/", data, format="json")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is True
+
+    def test_release_template_duplicate_version_693(self):
+        """Cover release_template duplicate version early return (693)."""
+        view = TemplateViewSet.as_view({"post": "release_template"})
+        request = self.factory.post(
+            f"/templates/{self.template.id}/release_template/", {"version": "1.0.0", "desc": "d"}, format="json"
+        )
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
+
+    def test_release_template_invalid_version_bump_custom_696_698(self):
+        """Cover release_template bump_custom ValueError branch (696-698)."""
+        with mock.patch("bkflow.template.views.template.bump_custom", side_effect=ValueError("bad")):
+            view = TemplateViewSet.as_view({"post": "release_template"})
+            request = self.factory.post(
+                f"/templates/{self.template.id}/release_template/", {"version": "bad", "desc": "d"}, format="json"
+            )
+            force_authenticate(request, user=self.user)
+            response = view(request, pk=self.template.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
+        assert "版本号不符合规范" in str(response.data)
+
+    def test_rollback_template_versioning_disabled_720(self):
+        """Cover rollback_template when versioning disabled (720)."""
+        space2 = Space.objects.create(name="No Version", app_code="app2")
+        SpaceConfig.objects.create(space_id=space2.id, name=FlowVersioning.name, value_type="TEXT", text_value="false")
+
+        snap = TemplateSnapshot.create_snapshot(self.pipeline_tree, "test_user", "1.0.0")
+        tpl = Template.objects.create(
+            name="t",
+            space_id=space2.id,
+            snapshot_id=snap.id,
+            creator="test_user",
+            updated_by="test_user",
+        )
+        snap.template_id = tpl.id
+        snap.save(update_fields=["template_id"])
+
+        view = TemplateViewSet.as_view({"post": "rollback_template"})
+        request = self.factory.post(f"/templates/{tpl.id}/rollback_template/", {"version": "1.0.0"}, format="json")
+        force_authenticate(request, user=self.user)
+        response = view(request, pk=tpl.id)
+
+        assert response.status_code == 200
+        assert response.data.get("result") is False
diff --git a/tests/label/__init__.py b/tests/label/__init__.py
new file mode 100644
index 0000000000..732d2b8d52
--- /dev/null
+++ b/tests/label/__init__.py
@@ -0,0 +1,18 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
diff --git a/tests/label/test_label.py b/tests/label/test_label.py
new file mode 100644
index 0000000000..12936f23d7
--- /dev/null
+++ b/tests/label/test_label.py
@@ -0,0 +1,682 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+import pytest
+from django.core.exceptions import ValidationError as DjangoValidationError
+from rest_framework.exceptions import ValidationError as DRFValidationError
+
+from bkflow.label.models import Label, TemplateLabelRelation
+
+# Enable database access for all tests in this module
+pytestmark = pytest.mark.django_db
+
+
+def make_label(
+    name,
+    space_id=1,
+    parent_id=None,
+    label_scope=None,
+    creator="tester",
+    updated_by="tester",
+    color="#ffffff",
+    is_default=False,
+):
+    """
+    Helper factory for creating Label instances with sensible defaults.
+    """
+    if label_scope is None:
+        label_scope = ["task"]
+    return Label.objects.create(
+        name=name,
+        space_id=space_id,
+        parent_id=parent_id,
+        label_scope=label_scope,
+        creator=creator,
+        updated_by=updated_by,
+        color=color,
+        is_default=is_default,
+    )
+
+
+class TestLabelManager:
+    """
+    Tests for custom methods defined in LabelManager.
+    """
+
+    def test_check_label_ids_true_and_false(self):
+        """
+        check_label_ids should return True only when all ids exist.
+        """
+        l1 = make_label("label1")
+        l2 = make_label("label2")
+
+        assert Label.objects.check_label_ids([l1.id, l2.id]) is True
+        # add a non-existing id
+        assert Label.objects.check_label_ids([l1.id, l2.id, 999999]) is False
+
+    def test_get_root_labels_filters_by_space_and_scope(self):
+        """
+        get_root_labels should respect space_id and optional label_scope.
+        """
+        # space 1 roots
+        root_task = make_label("root_task", space_id=1, label_scope=["task"])
+        root_template = make_label("root_template", space_id=1, label_scope=["template"])
+        # different space root
+        root_other_space = make_label("root_other_space", space_id=2, label_scope=["task"])
+        # child in space 1
+        child = make_label("child", space_id=1, parent_id=root_task.id, label_scope=["task"])
+
+        roots_task = Label.objects.get_root_labels(space_id=1, label_scope="task")
+        roots_all_space1 = Label.objects.get_root_labels(space_id=1)
+
+        # only the task root should appear when label_scope="task"
+        assert list(roots_task.values_list("id", flat=True)) == [root_task.id]
+
+        # all roots in space 1 (both task and template), children must not appear
+        assert set(roots_all_space1.values_list("id", flat=True)) == {
+            root_task.id,
+            root_template.id,
+        }
+        assert child.id not in roots_all_space1.values_list("id", flat=True)
+        assert root_other_space.id not in roots_all_space1.values_list("id", flat=True)
+
+    def test_get_sub_labels_recursive_and_non_recursive(self):
+        """
+        get_sub_labels should support both direct and recursive queries.
+        """
+        root = make_label("root")
+        child1 = make_label("child1", parent_id=root.id)
+        child2 = make_label("child2", parent_id=root.id)
+        grandchild = make_label("grandchild", parent_id=child1.id)
+
+        # non-recursive: only direct children
+        direct_children = Label.objects.get_sub_labels(root.id, recursive=False)
+        names = list(direct_children.values_list("name", flat=True))
+        assert names == ["child1", "child2"]
+
+        # recursive: all descendants as list
+        all_descendants = Label.objects.get_sub_labels(root.id, recursive=True)
+        ids = {label.id for label in all_descendants}
+        assert ids == {child1.id, child2.id, grandchild.id}
+        assert isinstance(all_descendants, list)
+
+    def test_get_parent_label_and_is_root(self):
+        """
+        get_parent_label should return parent for children and None for roots.
+        is_root should be True only for roots.
+        """
+        root = make_label("root")
+        child = make_label("child", parent_id=root.id)
+
+        assert Label.objects.get_parent_label(child.id) == root
+        assert Label.objects.get_parent_label(root.id) is None
+        assert Label.objects.get_parent_label(999999) is None
+
+        assert root.is_root() is True
+        assert child.is_root() is False
+
+    def test_get_labels_map_returns_full_info(self):
+        """
+        get_labels_map should return label info including full_path.
+        """
+        root = make_label("root")
+        child = make_label("child", parent_id=root.id, color="#123456")
+
+        labels_map = Label.objects.get_labels_map([child.id])
+
+        assert set(labels_map.keys()) == {child.id}
+        info = labels_map[child.id]
+        assert info["id"] == child.id
+        assert info["name"] == "child"
+        assert info["color"] == "#123456"
+        assert info["full_path"] == child.full_path
+        # full_path should include both root and child names
+        assert info["full_path"].split("/") == ["root", "child"]
+
+
+class TestLabelModel:
+    """
+    Tests for Label model instance methods and validation logic.
+    """
+
+    def test_full_path_builds_hierarchy(self):
+        """
+        full_path should join names from root to current label with "/".
+        """
+        root = make_label("root")
+        child = make_label("child", parent_id=root.id)
+        grandchild = make_label("grandchild", parent_id=child.id)
+
+        assert root.full_path == "root"
+        assert child.full_path == "root/child"
+        assert grandchild.full_path == "root/child/grandchild"
+
+    def test_str_contains_parent_name_or_default(self):
+        """__str__ should include parent name when available, otherwise use default text."""
+        root = make_label("root_for_str")
+        child = make_label("child_for_str", parent_id=root.id)
+
+        assert "root_for_str" in str(child)
+        assert "child_for_str" in str(child)
+        assert "父标签：无" in str(root)
+
+    def test_label_clean_validates_parent_space(self):
+        """
+        save should fail when child's space_id does not match parent space_id.
+        """
+        parent = make_label("parent", space_id=1)
+        # do not save child yet; we expect validation error on save()
+        child = Label(
+            name="child_wrong_space",
+            space_id=2,  # different space from parent
+            parent_id=parent.id,
+            label_scope=["task"],
+            creator="tester",
+            updated_by="tester",
+        )
+
+        with pytest.raises(DjangoValidationError) as exc:
+            child.save()
+
+        msg = str(exc.value)
+        assert "子标签的空间ID必须与父标签一致" in msg
+
+    def test_label_clean_raises_for_missing_parent(self):
+        """
+        save should fail when parent_id points to a non-existing label.
+        """
+        child = Label(
+            name="child_missing_parent",
+            space_id=1,
+            parent_id=999999,  # non-existent
+            label_scope=["task"],
+            creator="tester",
+            updated_by="tester",
+        )
+
+        with pytest.raises(DjangoValidationError) as exc:
+            child.save()
+
+        msg = str(exc.value)
+        assert "父标签不存在" in msg
+
+    def test_label_clean_prevents_cycle_reference(self):
+        """
+        save should prevent cycles like A -> B -> A.
+        """
+        parent = make_label("parent")
+        child = make_label("child", parent_id=parent.id)
+
+        # introduce a cycle: parent -> child, child -> parent already exists
+        parent.parent_id = child.id
+
+        with pytest.raises(DjangoValidationError) as exc:
+            parent.save()
+
+        msg = str(exc.value)
+        assert "禁止循环引用" in msg
+
+    def test_label_clean_breaks_when_ancestor_missing(self):
+        """Cycle check should break gracefully when an ancestor record is missing."""
+        parent = make_label("parent_inconsistent")
+        # Create an inconsistent chain: parent.parent_id points to a missing label.
+        # Use queryset.update to bypass model clean/save.
+        Label.objects.filter(id=parent.id).update(parent_id=999999)
+
+        child = Label(
+            name="child_ok",
+            space_id=parent.space_id,
+            parent_id=parent.id,
+            label_scope=["task"],
+            creator="tester",
+            updated_by="tester",
+        )
+        # Should not raise, even though parent's parent is missing.
+        child.save()
+
+    def test_get_all_children_delegates_to_manager(self):
+        """
+        get_all_children should delegate to LabelManager.get_sub_labels.
+        """
+        root = make_label("root")
+        child1 = make_label("child1", parent_id=root.id)
+        child2 = make_label("child2", parent_id=root.id)
+        grandchild = make_label("grandchild", parent_id=child1.id)
+
+        # non-recursive: only direct children
+        direct_children = root.get_all_children(recursive=False)
+        assert set(direct_children.values_list("id", flat=True)) == {
+            child1.id,
+            child2.id,
+        }
+
+        # recursive: all descendants as list
+        all_descendants = root.get_all_children(recursive=True)
+        ids = {label.id for label in all_descendants}
+        assert ids == {child1.id, child2.id, grandchild.id}
+
+    def test_get_label_ids_by_names(self):
+        """get_label_ids_by_names should return label IDs matching given names."""
+        l1 = make_label("apple")
+        l2 = make_label("banana")
+
+        # Test exact name matching
+        ids = Label.get_label_ids_by_names("apple")
+        assert ids == [l1.id]
+
+        # Test multiple names separated by commas
+        ids = Label.get_label_ids_by_names("apple,banana")
+        assert set(ids) == {l1.id, l2.id}
+
+        # Test multiple names separated by spaces
+        ids = Label.get_label_ids_by_names("apple banana")
+        assert set(ids) == {l1.id, l2.id}
+
+        # Test case insensitive matching
+        ids = Label.get_label_ids_by_names("APPLE")
+        assert ids == [l1.id]
+
+        # Test partial matching
+        ids = Label.get_label_ids_by_names("app")
+        assert ids == [l1.id]
+
+        # Test no matches
+        ids = Label.get_label_ids_by_names("grape")
+        assert ids == []
+
+        # Test empty input
+        ids = Label.get_label_ids_by_names("")
+        assert ids == []
+
+        # Test with extra whitespace
+        ids = Label.get_label_ids_by_names("  apple  ,  banana  ")
+        assert set(ids) == {l1.id, l2.id}
+
+
+class TestTemplateLabelRelationManager:
+    """
+    Tests for BaseLabelRelationManager via TemplateLabelRelation.
+    """
+
+    def test_set_and_fetch_labels(self):
+        """
+        set_labels and fetch_labels should correctly manage template-label relations.
+        """
+        l1 = make_label("label1")
+        l2 = make_label("label2")
+        l3 = make_label("label3")
+
+        template_id = 100
+
+        # initial set: {l1, l2}
+        TemplateLabelRelation.objects.set_labels(template_id, [l1.id, l2.id])
+        current_ids = set(
+            TemplateLabelRelation.objects.filter(template_id=template_id).values_list("label_id", flat=True)
+        )
+        assert current_ids == {l1.id, l2.id}
+
+        # update set: {l2, l3} -> l1 removed, l3 added
+        TemplateLabelRelation.objects.set_labels(template_id, [l2.id, l3.id])
+        current_ids = set(
+            TemplateLabelRelation.objects.filter(template_id=template_id).values_list("label_id", flat=True)
+        )
+        assert current_ids == {l2.id, l3.id}
+
+        # fetch_labels should return label descriptions with full_path
+        labels = TemplateLabelRelation.objects.fetch_labels(template_id)
+        returned_ids = {item["id"] for item in labels}
+        assert returned_ids == {l2.id, l3.id}
+        for item in labels:
+            assert "name" in item
+            assert "color" in item
+            assert "full_path" in item
+
+    def test_fetch_objects_labels(self):
+        """
+        fetch_objects_labels should return a mapping {obj_id: [label_info, ...]}.
+        """
+        l1 = make_label("label1")
+        l2 = make_label("label2")
+        l3 = make_label("label3")
+
+        t1 = 101
+        t2 = 102
+
+        TemplateLabelRelation.objects.set_labels(t1, [l1.id, l2.id])
+        TemplateLabelRelation.objects.set_labels(t2, [l2.id, l3.id])
+
+        result = TemplateLabelRelation.objects.fetch_objects_labels([t1, t2], label_fields=("name", "color"))
+
+        assert set(result.keys()) == {t1, t2}
+        ids_t1 = {label["id"] for label in result[t1]}
+        ids_t2 = {label["id"] for label in result[t2]}
+        assert ids_t1 == {l1.id, l2.id}
+        assert ids_t2 == {l2.id, l3.id}
+
+        # each label dict should contain requested fields and full_path
+        for labels in result.values():
+            for item in labels:
+                assert set(item.keys()) >= {"id", "name", "color", "full_path"}
+
+    def test_fetch_objects_labels_returns_empty_when_no_relations(self):
+        """fetch_objects_labels should return {} when the provided objects have no relations."""
+        assert TemplateLabelRelation.objects.fetch_objects_labels([999999], label_fields=("name", "color")) == {}
+
+
+class TestLabelSerializer:
+    """Tests for LabelSerializer validation logic."""
+
+    def test_validate_color_valid_and_invalid_formats(self):
+        """validate_color should accept valid hex colors and reject invalid ones."""
+        from rest_framework.test import APIRequestFactory
+
+        from bkflow.label.serializers import LabelSerializer
+
+        factory = APIRequestFactory()
+        request = factory.post("/api/label/", data={"space_id": 1})
+
+        # Test individual validation method
+        serializer = LabelSerializer(context={"request": request})
+
+        # Valid hex colors should pass
+        assert serializer.validate_color("#ffffff") == "#ffffff"
+        assert serializer.validate_color("#000000") == "#000000"
+        assert serializer.validate_color("#FF00FF") == "#FF00FF"
+
+        # Invalid hex colors should raise ValidationError - this is CORRECT behavior
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.validate_color("ffffff")  # missing #
+        assert "颜色格式错误" == str(exc.value.detail[0])
+
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.validate_color("#fff")  # wrong length
+        assert "颜色格式错误" == str(exc.value.detail[0])
+
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.validate_color("#gggggg")  # invalid characters
+        assert "颜色格式错误" == str(exc.value.detail[0])
+
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.validate_color("#12345")  # wrong length
+        assert "颜色格式错误" == str(exc.value.detail[0])
+
+    def test_validate_name_duplicate_check(self):
+        """validate_name should prevent duplicate names within same space and parent."""
+        from rest_framework.test import APIRequestFactory
+
+        from bkflow.label.serializers import LabelSerializer
+
+        # Create initial label
+        existing_label = make_label("existing_label", space_id=1, color="#ffffff", label_scope=["task"])
+
+        factory = APIRequestFactory()
+
+        # Test duplicate detection on create
+        request = factory.post("/api/label/", data={"space_id": 1})
+
+        # Provide all required fields
+        serializer = LabelSerializer(
+            data={"space_id": 1, "name": "existing_label", "color": "#ffffff", "label_scope": ["task"]},
+            context={"request": request},
+        )
+
+        # Should raise validation error for duplicate name - this is CORRECT behavior
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+        assert "该空间下已存在名称为「existing_label」的标签" == exc.value.detail["name"][0]
+
+        # Test duplicate detection on update (should exclude self)
+        request = factory.put(f"/api/label/{existing_label.id}/", data={"space_id": 1})
+        serializer = LabelSerializer(
+            instance=existing_label,
+            data={"space_id": 1, "name": "existing_label", "color": "#ffffff", "label_scope": ["task"]},
+            context={"request": request},
+        )
+        # Should not raise for same name when updating self
+        assert serializer.is_valid() is True
+
+        # Should raise for duplicate with different label
+        existing_label2 = make_label("existing_label2", space_id=1, color="#ffffff", label_scope=["task"])
+        request = factory.put(f"/api/label/{existing_label2.id}/", data={"space_id": 1})
+        serializer = LabelSerializer(
+            instance=existing_label2,
+            data={"space_id": 1, "name": "existing_label", "color": "#ffffff", "label_scope": ["task"]},
+            context={"request": request},
+        )
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+        error_message = str(exc.value)
+        assert "该空间下已存在名称为「existing_label」的标签" in error_message
+
+    def test_validate_label_scope_parent_validation(self):
+        """validate_label_scope should enforce parent-child scope consistency."""
+        from rest_framework.test import APIRequestFactory
+
+        from bkflow.label.serializers import LabelSerializer
+
+        # Create parent with specific scope
+        parent = make_label("parent", label_scope=["task", "template"], color="#ffffff", space_id=1)
+
+        factory = APIRequestFactory()
+
+        # Valid child scope (subset of parent)
+        request = factory.post("/api/label/", data={"parent_id": parent.id})
+
+        # Valid: child scope is subset of parent scope
+        serializer = LabelSerializer(
+            data={"parent_id": parent.id, "name": "child", "color": "#ffffff", "label_scope": ["task"], "space_id": 1},
+            context={"request": request},
+        )
+
+        # The validation should pass for valid subset
+        assert serializer.is_valid() is True
+
+        # Invalid: child scope not subset of parent scope
+        serializer = LabelSerializer(
+            data={
+                "parent_id": parent.id,
+                "name": "child",
+                "color": "#ffffff",
+                "label_scope": ["common"],
+                "space_id": 1,
+            },
+            context={"request": request},
+        )
+
+        # Should raise ValidationError for invalid scope - this is CORRECT behavior
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+        assert "子标签的范围必须是父标签的子集" == exc.value.detail["label_scope"][0]
+
+        # Invalid: parent doesn't exist
+        request = factory.post("/api/label/", data={"parent_id": 999999})
+        serializer = LabelSerializer(
+            data={"parent_id": 999999, "name": "child", "color": "#ffffff", "label_scope": ["task"], "space_id": 1},
+            context={"request": request},
+        )
+
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+        assert "父标签不存在" in str(exc.value)
+
+    def test_validate_name_empty_and_whitespace(self):
+        """validate_name should reject empty and whitespace-only names."""
+        from rest_framework.test import APIRequestFactory
+
+        from bkflow.label.serializers import LabelSerializer
+
+        factory = APIRequestFactory()
+        request = factory.post("/api/label/", data={"space_id": 1})
+
+        # Test with empty name
+        serializer = LabelSerializer(
+            data={"space_id": 1, "name": "", "color": "#ffffff", "label_scope": ["task"]}, context={"request": request}
+        )
+
+        # Should raise validation error for empty name - this is CORRECT behavior
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+        assert "该字段不能为空。" == exc.value.detail["name"][0]
+
+        # Test with whitespace-only name
+        serializer = LabelSerializer(
+            data={"space_id": 1, "name": "   ", "color": "#ffffff", "label_scope": ["task"]},
+            context={"request": request},
+        )
+
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.is_valid(raise_exception=True)
+
+        # Valid name with surrounding whitespace should be trimmed
+        serializer = LabelSerializer(
+            data={"space_id": 1, "name": "  valid_name  ", "color": "#ffffff", "label_scope": ["task"]},
+            context={"request": request},
+        )
+
+        assert serializer.is_valid() is True
+        assert serializer.validated_data["name"] == "valid_name"
+
+    def test_validate_name_custom_error_when_blank_after_strip(self):
+        """Direct validate_name should raise the custom error when value becomes blank after strip."""
+        from bkflow.label.serializers import LabelSerializer
+
+        serializer = LabelSerializer()
+        with pytest.raises(DRFValidationError) as exc:
+            serializer.validate_name("   ")
+        assert "标签名称不能为空" == str(exc.value.detail[0])
+
+
+class TestLabelPermission:
+    """Tests for bkflow.label.permissions.LabelPermission."""
+
+    def test_get_resource_type(self):
+        from bkflow.label.permissions import LabelPermission
+
+        assert LabelPermission().get_resource_type() == "LABEL"
+
+    def test_has_object_permission_edit_actions_use_edit_permission_only(self, monkeypatch):
+        """When action is in EDIT_ABOVE_ACTIONS, only edit permission matters."""
+        from types import SimpleNamespace
+
+        from bkflow.label.permissions import LabelPermission
+
+        perm = LabelPermission()
+
+        monkeypatch.setattr(perm, "has_edit_permission", lambda *args, **kwargs: True)
+        monkeypatch.setattr(perm, "has_view_permission", lambda *args, **kwargs: False)
+
+        request = SimpleNamespace(user=SimpleNamespace(username="tester"), token="t")
+        view = SimpleNamespace(action="create", EDIT_ABOVE_ACTIONS=["create", "update", "partial_update", "destroy"])
+        obj = SimpleNamespace(space_id=1, id=123)
+
+        assert perm.has_object_permission(request, view, obj) is True
+
+        monkeypatch.setattr(perm, "has_edit_permission", lambda *args, **kwargs: False)
+        assert perm.has_object_permission(request, view, obj) is False
+
+    def test_has_object_permission_view_actions_allow_view_or_edit(self, monkeypatch):
+        """When action is not edit-type, view permission OR edit permission passes."""
+        from types import SimpleNamespace
+
+        from bkflow.label.permissions import LabelPermission
+
+        perm = LabelPermission()
+        request = SimpleNamespace(user=SimpleNamespace(username="tester"), token="t")
+        view = SimpleNamespace(action="list", EDIT_ABOVE_ACTIONS=["create", "update", "partial_update", "destroy"])
+        obj = SimpleNamespace(space_id=1, id=123)
+
+        # view=True, edit=False -> True
+        monkeypatch.setattr(perm, "has_edit_permission", lambda *args, **kwargs: False)
+        monkeypatch.setattr(perm, "has_view_permission", lambda *args, **kwargs: True)
+        assert perm.has_object_permission(request, view, obj) is True
+
+        # view=False, edit=True -> True
+        monkeypatch.setattr(perm, "has_edit_permission", lambda *args, **kwargs: True)
+        monkeypatch.setattr(perm, "has_view_permission", lambda *args, **kwargs: False)
+        assert perm.has_object_permission(request, view, obj) is True
+
+        # view=False, edit=False -> False
+        monkeypatch.setattr(perm, "has_edit_permission", lambda *args, **kwargs: False)
+        monkeypatch.setattr(perm, "has_view_permission", lambda *args, **kwargs: False)
+        assert perm.has_object_permission(request, view, obj) is False
+
+
+class TestLabelAdminHelpers:
+    """Cover admin helper methods in bkflow.label.admin."""
+
+    def test_label_admin_parent_label(self):
+        from django.contrib import admin
+
+        from bkflow.label.admin import LabelAdmin
+        from bkflow.label.models import Label
+
+        root = make_label("root_admin")
+        child = make_label("child_admin", parent_id=root.id)
+
+        admin_obj = LabelAdmin(Label, admin.site)
+
+        assert admin_obj.parent_label(root) == "-"
+        assert admin_obj.parent_label(child) == "root_admin"
+
+    def test_template_label_relation_admin_label_name(self):
+        from django.contrib import admin
+
+        from bkflow.label.admin import TemplateLabelRelationAdmin
+        from bkflow.label.models import TemplateLabelRelation
+
+        label = make_label("label_for_relation")
+        rel_ok = TemplateLabelRelation.objects.create(template_id=1, label_id=label.id)
+        rel_missing = TemplateLabelRelation.objects.create(template_id=1, label_id=999999999)
+
+        admin_obj = TemplateLabelRelationAdmin(TemplateLabelRelation, admin.site)
+
+        assert admin_obj.label_name(rel_ok) == "label_for_relation"
+        assert admin_obj.label_name(rel_missing) == "-"
+
+
+class TestLabelRefSerializer:
+    def test_validate_label_ids_accepts_list_and_sorts_dedup(self):
+        from bkflow.label.serializers import LabelRefSerializer
+
+        ser = LabelRefSerializer()
+        assert ser.validate_label_ids([3, "2", 2]) == "2,3"
+
+    def test_validate_label_ids_rejects_invalid_list_item(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.label.serializers import LabelRefSerializer
+
+        ser = LabelRefSerializer()
+        with pytest.raises(ValidationError):
+            ser.validate_label_ids(["x"])
+
+    def test_validate_label_ids_rejects_empty_and_bad_format(self):
+        from rest_framework.exceptions import ValidationError
+
+        from bkflow.label.serializers import LabelRefSerializer
+
+        ser = LabelRefSerializer()
+
+        # empty
+        with pytest.raises(ValidationError):
+            ser.validate_label_ids("")
+
+        # leading/trailing commas / illegal chars
+        for v in [",1,2", "1,2,", "1,a"]:
+            with pytest.raises(ValidationError):
+                ser.validate_label_ids(v)
diff --git a/tests/label/test_label_viewset.py b/tests/label/test_label_viewset.py
new file mode 100644
index 0000000000..9b018e5af8
--- /dev/null
+++ b/tests/label/test_label_viewset.py
@@ -0,0 +1,490 @@
+"""
+TencentBlueKing is pleased to support the open source community by making
+蓝鲸流程引擎服务 (BlueKing Flow Engine Service) available.
+Copyright (C) 2024 THL A29 Limited,
+a Tencent company. All rights reserved.
+Licensed under the MIT License (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at http://opensource.org/licenses/MIT
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on
+an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+We undertake not to change the open source license (MIT license) applicable
+
+to the current version of the project delivered to anyone in the future.
+"""
+from unittest.mock import patch
+
+import pytest
+from blueapps.account.models import User
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+
+from bkflow.admin.models import IsolationLevel, ModuleInfo, ModuleType
+from bkflow.label.models import Label, TemplateLabelRelation
+from bkflow.label.views import LabelViewSet
+
+from .test_label import make_label
+
+# Enable database access for all tests in this module
+pytestmark = pytest.mark.django_db
+
+
+class TestLabelViewSet:
+    """Tests for LabelViewSet API behavior."""
+
+    def setup_method(self):
+        """Prepare APIRequestFactory and an admin user for each test."""
+        self.factory = APIRequestFactory()
+        # Admin user to pass AdminPermission and provide username for CustomViewSetMixin
+        self.admin_user, created = User.objects.get_or_create(
+            username="label_admin",
+            defaults={
+                "is_superuser": True,
+                "is_staff": True,
+            },
+        )
+
+        # Create ModuleInfo for space_id=1 to avoid DoesNotExist error in TaskComponentClient
+        ModuleInfo.objects.get_or_create(
+            space_id=1,
+            defaults={
+                "code": "test_task",
+                "url": "http://test.example.com",
+                "token": "test_token",
+                "type": ModuleType.TASK.value,
+                "isolation_level": IsolationLevel.ONLY_CALCULATION.value,
+            },
+        )
+
+        self.list_view = LabelViewSet.as_view({"get": "list"})
+        self.create_view = LabelViewSet.as_view({"post": "create"})
+        self.destroy_view = LabelViewSet.as_view({"delete": "destroy"})
+        self.get_label_ref_count_view = LabelViewSet.as_view({"get": "get_label_ref_count"})
+
+    def test_list_returns_root_labels_with_has_children_flag(self):
+        """list should return only root labels when parent_id is not provided."""
+        root = make_label("root", space_id=1)
+        child = make_label("child", space_id=1, parent_id=root.id)
+        other_space_root = make_label("other_space_root", space_id=2)
+
+        url = "/api/label/"
+        request = self.factory.get(
+            url,
+            {"space_id": 1, "label_scope": "task", "limit": -1},
+        )
+        request.user = self.admin_user
+
+        response = self.list_view(request)
+        assert response.status_code == status.HTTP_200_OK
+
+        # SimpleGenericViewSet wraps DRF response data into {"result": True, "data": ..., "code": "0", "message": ""}
+        data = response.data["data"]
+        results = data["results"]
+        returned_ids = {item["id"] for item in results}
+
+        # Only root labels in space 1 should be returned
+        assert root.id in returned_ids
+        assert other_space_root.id not in returned_ids
+        assert child.id not in returned_ids
+
+        # All returned labels should be roots; root with children should have has_children=True
+        for item in results:
+            label_obj = Label.objects.get(id=item["id"])
+            assert label_obj.parent_id is None
+            if item["id"] == root.id:
+                assert item["has_children"] is True
+
+    def test_create_nested_name_creates_parent_and_child(self):
+        """create should support 'parent/child' name format and auto-create parent label."""
+        url = "/api/label/"
+        payload = {
+            "name": "ParentLabel/ChildLabel",
+            "space_id": 1,
+            "color": "#123456",
+            "label_scope": ["task"],
+        }
+        request = self.factory.post(url, payload, format="json")
+        request.user = self.admin_user
+
+        response = self.create_view(request)
+        assert response.status_code == status.HTTP_201_CREATED
+
+        # SimpleGenericViewSet wraps data under "data"
+        resp_data = response.data["data"]
+        assert resp_data["name"] == "ChildLabel"
+
+        # Parent should be auto-created as a root label
+        parent = Label.objects.get(name="ParentLabel", parent_id__isnull=True)
+        child = Label.objects.get(id=resp_data["id"])
+
+        assert child.parent_id == parent.id
+        assert child.full_path == "ParentLabel/ChildLabel"
+
+    def test_create_with_hierarchical_name_format(self):
+        """create should auto-create parent labels when name contains '/' separator."""
+        # Test creating hierarchical label: "parent/child"
+        data = {
+            "name": "一级标签/二级标签",
+            "space_id": 1,
+            "color": "#ffffff",
+            "label_scope": ["task"],
+            "creator": "test_user",
+            "updated_by": "test_user",
+        }
+
+        request = self.factory.post("/api/label/", data=data)
+        request.user = self.admin_user
+
+        response = self.create_view(request)
+        assert response.status_code == status.HTTP_201_CREATED
+
+        # Verify parent label was created
+        parent_label = Label.objects.get(name="一级标签", parent_id__isnull=True)
+        assert parent_label is not None
+
+        # Verify child label was created with correct parent reference
+        child_label = Label.objects.get(name="二级标签", parent_id=parent_label.id)
+        assert child_label is not None
+        assert child_label.parent_id == parent_label.id
+
+        # Verify response contains child label data
+        response_data = response.data
+        # Adapt to actual API response format
+        assert "data" in response_data
+        assert response_data["data"]["name"] == "二级标签"
+        assert response_data["data"]["parent_id"] == parent_label.id
+
+    def test_create_with_existing_parent_label(self):
+        """create should use existing parent label when available."""
+        # Create parent label first
+        existing_parent = make_label("existing_parent", space_id=1)
+
+        # Test creating child with existing parent
+        data = {
+            "name": "existing_parent/child_label",
+            "space_id": 1,
+            "color": "#ffffff",
+            "label_scope": ["task"],
+            "creator": "test_user",
+            "updated_by": "test_user",
+        }
+
+        request = self.factory.post("/api/label/", data=data)
+        request.user = self.admin_user
+
+        response = self.create_view(request)
+        assert response.status_code == status.HTTP_201_CREATED
+
+        # Verify child was created with existing parent
+        child_label = Label.objects.get(name="child_label", parent_id=existing_parent.id)
+        assert child_label is not None
+        assert child_label.parent_id == existing_parent.id
+
+        # Verify no duplicate parent was created
+        parent_count = Label.objects.filter(name="existing_parent", parent_id__isnull=True).count()
+        assert parent_count == 1
+
+    def test_destroy_root_label_cascades_children(self):
+        """destroy should delete root label and all of its direct children."""
+        root = make_label("root_to_delete", space_id=1)
+        child1 = make_label("child1", space_id=1, parent_id=root.id)
+        child2 = make_label("child2", space_id=1, parent_id=root.id)
+
+        url = f"/api/label/{root.id}/"
+        request = self.factory.delete(url)
+        request.user = self.admin_user
+
+        # Mock TaskComponentClient.delete_task_label_relation to avoid external API call
+        with patch("bkflow.label.views.TaskComponentClient") as mock_client:
+            mock_instance = mock_client.return_value
+            mock_instance.delete_task_label_relation.return_value = {"result": True}
+
+            response = self.destroy_view(request, pk=root.id)
+            assert response.status_code == status.HTTP_204_NO_CONTENT
+
+        assert not Label.objects.filter(id=root.id).exists()
+        assert not Label.objects.filter(id__in=[child1.id, child2.id]).exists()
+
+    def test_get_label_ref_count_success(self):
+        """get_label_ref_count should return template and task reference counts."""
+        # Create test labels
+        l1 = make_label("label1", space_id=1)
+        l2 = make_label("label2", space_id=1)
+
+        # Create template label relations
+        TemplateLabelRelation.objects.create(template_id=100, label_id=l1.id)
+        TemplateLabelRelation.objects.create(template_id=100, label_id=l2.id)
+        TemplateLabelRelation.objects.create(template_id=101, label_id=l1.id)
+
+        # Mock TaskComponentClient to return task reference counts
+        with patch("bkflow.label.views.TaskComponentClient") as mock_client:
+            mock_instance = mock_client.return_value
+            mock_instance.get_task_label_ref_count.return_value = {
+                "result": True,
+                "data": {str(l1.id): 3, str(l2.id): 1},  # l1 has 3 task references  # l2 has 1 task reference
+            }
+
+            # Make API request
+            request = self.factory.get(f"/api/label/get_label_ref_count/?space_id=1&label_ids={l1.id},{l2.id}")
+            request.user = self.admin_user
+
+            response = self.get_label_ref_count_view(request)
+            assert response.status_code == status.HTTP_200_OK
+
+            # Verify response structure - adapt to actual API format
+            data = response.data
+            assert data["result"] is True
+            assert "data" in data
+
+            # Verify reference counts in response data
+            ref_data = data["data"]
+            assert str(l1.id) in ref_data
+            assert str(l2.id) in ref_data
+
+            # Verify template reference counts
+            assert ref_data[str(l1.id)]["template_count"] == 2  # l1 has 2 template references
+            assert ref_data[str(l2.id)]["template_count"] == 1  # l2 has 1 template reference
+
+            # Verify task reference counts from mock
+            assert ref_data[str(l1.id)]["task_count"] == 3
+            assert ref_data[str(l2.id)]["task_count"] == 1
+
+    def test_get_label_ref_count_client_error(self):
+        """get_label_ref_count should handle TaskComponentClient errors gracefully."""
+        l1 = make_label("label1", space_id=1)
+
+        with patch("bkflow.label.views.TaskComponentClient") as mock_client:
+            mock_instance = mock_client.return_value
+            mock_instance.get_task_label_ref_count.return_value = {
+                "result": False,
+                "message": "Task service unavailable",
+            }
+
+            request = self.factory.get(f"/api/label/get_label_ref_count/?space_id=1&label_ids={l1.id}")
+            request.user = self.admin_user
+
+            response = self.get_label_ref_count_view(request)
+            # The API returns 200 even when task service fails
+            assert response.status_code == status.HTTP_200_OK
+
+            # Check the actual response structure
+            response_data = response.data
+
+            # The API might return the error message directly
+            # or handle it differently. Let's check the structure
+            if "result" in response_data:
+                # If result is False, that's expected for service errors
+                if response_data["result"] is False:
+                    assert "message" in response_data
+                    assert "Task service unavailable" in str(response_data["message"])
+                else:
+                    # If result is True, check that data structure is present
+                    assert "data" in response_data
+                    assert isinstance(response_data["data"], dict)
+            else:
+                # Alternative response format
+                assert "message" in response_data
+                assert "Task service unavailable" in str(response_data["message"])
+
+            # The important thing is that the API doesn't crash
+            # and returns a consistent response structure
+
+
+class TestLabelFilter:
+    """Tests for LabelFilter filtering logic."""
+
+    def test_filter_space_id_includes_default_and_specific_space(self):
+        """filter_space_id should include both default (-1) and specific space labels."""
+        from bkflow.label.views import LabelFilter
+
+        # Create labels in different spaces
+        default_label = make_label("default", space_id=-1)
+        space1_label = make_label("space1", space_id=1)
+        space2_label = make_label("space2", space_id=2)
+
+        # Filter for space_id=1 should include default (-1) and space1 labels
+        filter_instance = LabelFilter()
+        queryset = Label.objects.all()
+        filtered = filter_instance.filter_space_id(queryset, "space_id", 1)
+
+        filtered_ids = list(filtered.values_list("id", flat=True))
+        assert default_label.id in filtered_ids
+        assert space1_label.id in filtered_ids
+        assert space2_label.id not in filtered_ids
+
+    def test_filter_label_scope_includes_common_and_specific_scope(self):
+        """filter_label_scope should include both common and specific scope labels."""
+        from bkflow.label.views import LabelFilter
+
+        # Create labels with different scopes
+        task_label = make_label("task", label_scope=["task"])
+        template_label = make_label("template", label_scope=["template"])
+        common_label = make_label("common", label_scope=["common"])
+        multi_label = make_label("multi", label_scope=["task", "common"])
+
+        filter_instance = LabelFilter()
+        queryset = Label.objects.all()
+
+        # Filter for "task" scope should include task and common labels
+        filtered = filter_instance.filter_label_scope(queryset, "label_scope", "task")
+        filtered_ids = list(filtered.values_list("id", flat=True))
+
+        assert task_label.id in filtered_ids
+        assert common_label.id in filtered_ids
+        assert multi_label.id in filtered_ids
+        assert template_label.id not in filtered_ids
+
+    def test_filter_parent_id_direct_match(self):
+        """filter_parent_id should filter by exact parent_id match."""
+        from bkflow.label.views import LabelFilter
+
+        parent = make_label("parent")
+        child1 = make_label("child1", parent_id=parent.id)
+        child2 = make_label("child2", parent_id=parent.id)
+
+        # Create another valid parent for testing
+        other_parent = make_label("other_parent")
+        other_child = make_label("other_child", parent_id=other_parent.id)
+
+        filter_instance = LabelFilter()
+        queryset = Label.objects.all()
+
+        # Filter by parent_id
+        filtered = filter_instance.filter_parent_id(queryset, "parent_id", parent.id)
+        filtered_ids = list(filtered.values_list("id", flat=True))
+
+        # Verify only children of the specified parent are returned
+        assert child1.id in filtered_ids
+        assert child2.id in filtered_ids
+        assert parent.id not in filtered_ids  # parent itself should not be included
+        assert other_child.id not in filtered_ids  # children of other parent should not be included
+
+    def test_filter_name_case_insensitive_search(self):
+        """filter_name should perform case-insensitive partial matching."""
+        from bkflow.label.views import LabelFilter
+
+        apple_label = make_label("Apple")
+        banana_label = make_label("Banana")
+        pineapple_label = make_label("Pineapple")
+
+        filter_instance = LabelFilter()
+        queryset = Label.objects.all()
+
+        # Search for "apple" should match both Apple and Pineapple
+        filtered = filter_instance.filter_name(queryset, "name", "apple")
+        filtered_ids = list(filtered.values_list("id", flat=True))
+
+        assert apple_label.id in filtered_ids
+        assert pineapple_label.id in filtered_ids
+        assert banana_label.id not in filtered_ids
+
+    def test_filter_is_default_boolean_filter(self):
+        """filter_is_default should filter by boolean is_default field."""
+        from bkflow.label.views import LabelFilter
+
+        default_label = make_label("default", is_default=True)
+        non_default_label = make_label("non_default", is_default=False)
+
+        filter_instance = LabelFilter()
+        queryset = Label.objects.all()
+
+        # Filter for default labels
+        filtered = filter_instance.filter_is_default(queryset, "is_default", True)
+        filtered_ids = list(filtered.values_list("id", flat=True))
+        assert default_label.id in filtered_ids
+        assert non_default_label.id not in filtered_ids
+
+        # Filter for non-default labels
+        filtered = filter_instance.filter_is_default(queryset, "is_default", False)
+        filtered_ids = list(filtered.values_list("id", flat=True))
+        assert non_default_label.id in filtered_ids
+        assert default_label.id not in filtered_ids
+
+
+class TestLabelViewSetExtraCoverage:
+    """Extra tests to cover remaining branches in bkflow.label.views."""
+
+    pytestmark = pytest.mark.django_db
+
+    def setup_method(self):
+        self.factory = APIRequestFactory()
+        self.admin_user, created = User.objects.get_or_create(
+            username="label_admin_extra",
+            defaults={
+                "is_superuser": True,
+                "is_staff": True,
+            },
+        )
+
+        ModuleInfo.objects.get_or_create(
+            space_id=1,
+            defaults={
+                "code": "test_task",
+                "url": "http://test.example.com",
+                "token": "test_token",
+                "type": ModuleType.TASK.value,
+                "isolation_level": IsolationLevel.ONLY_CALCULATION.value,
+            },
+        )
+
+        self.list_view = LabelViewSet.as_view({"get": "list"})
+        self.destroy_view = LabelViewSet.as_view({"delete": "destroy"})
+
+    def test_list_without_required_space_id_returns_empty(self):
+        """Missing required filter should make filterset invalid and return empty queryset."""
+        make_label("root", space_id=1)
+
+        request = self.factory.get("/api/label/")
+        request.user = self.admin_user
+
+        response = self.list_view(request)
+        assert response.status_code == status.HTTP_200_OK
+
+        # For SimpleGenericViewSet response format
+        data = response.data.get("data", {})
+        results = data.get("results", [])
+        assert results == []
+
+    def test_destroy_when_task_component_client_returns_error(self):
+        """destroy should return 400 and not delete objects when task component rejects."""
+        root = make_label("root_fail_delete", space_id=1)
+        child = make_label("child_fail_delete", space_id=1, parent_id=root.id)
+
+        request = self.factory.delete(f"/api/label/{root.id}/")
+        request.user = self.admin_user
+
+        with patch("bkflow.label.views.TaskComponentClient") as mock_client:
+            mock_instance = mock_client.return_value
+            mock_instance.delete_task_label_relation.return_value = {"result": False, "message": "fail"}
+
+            response = self.destroy_view(request, pk=root.id)
+            assert response.status_code == status.HTTP_400_BAD_REQUEST
+
+        assert Label.objects.filter(id=root.id).exists() is True
+        assert Label.objects.filter(id=child.id).exists() is True
+
+
+class TestLabelFilterQuerysetBranches:
+    """Cover LabelFilter.filter_queryset has_parent_id=True branch."""
+
+    pytestmark = pytest.mark.django_db
+
+    def test_filter_queryset_with_parent_id_keeps_queryset(self):
+        from bkflow.label.views import LabelFilter
+
+        parent = make_label("parent_for_filter", space_id=1)
+        child = make_label("child_for_filter", space_id=1, parent_id=parent.id)
+
+        # provide required space_id + parent_id so has_parent_id=True
+        data = {"space_id": 1, "parent_id": parent.id}
+        f = LabelFilter(data=data, queryset=Label.objects.all())
+
+        assert f.is_valid() is True
+        qs = f.qs
+
+        returned_ids = set(qs.values_list("id", flat=True))
+        assert returned_ids == {child.id}