From 49fec29029715473cc1ad36266c5b4a253a8bddc Mon Sep 17 00:00:00 2001
From: hhhhsc <1710496817@qq.com>
Date: Thu, 23 Apr 2026 10:07:05 +0800
Subject: [PATCH 1/3] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=A0=87=E6=B3=A8?=
 =?UTF-8?q?=E7=AE=97=E5=AD=90=EF=BC=8C=E5=B1=8F=E8=94=BD=E8=87=AA=E5=8A=A8?=
 =?UTF-8?q?=E6=A0=87=E6=B3=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../components/CreateAnnotationTaskDialog.tsx | 194 +++--
 .../DataAnnotation/Home/DataAnnotation.tsx    | 233 ++---
 runtime/ops/annotation/__init__.py            |   3 +-
 .../__init__.py                               |   9 -
 .../metadata.yml                              |   3 -
 .../process.py                                | 208 -----
 .../image_semantic_segmentation/process.py    | 166 ----
 runtime/ops/pyproject.toml                    |   2 -
 .../datamate/auto_annotation_worker.py        | 819 ------------------
 .../datamate/operator_runtime.py              |  14 +-
 scripts/db/data-operator-init.sql             |  14 +-
 11 files changed, 225 insertions(+), 1440 deletions(-)
 delete mode 100644 runtime/ops/annotation/image_object_detection_bounding_box/__init__.py
 delete mode 100644 runtime/ops/annotation/image_object_detection_bounding_box/metadata.yml
 delete mode 100644 runtime/ops/annotation/image_object_detection_bounding_box/process.py
 delete mode 100644 runtime/ops/annotation/image_semantic_segmentation/process.py
 delete mode 100644 runtime/python-executor/datamate/auto_annotation_worker.py

diff --git a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
index abb265a23..49aa0a55b 100644
--- a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
@@ -417,6 +417,7 @@ export default function CreateAnnotationTask({
       }
       width={800}
     >
+      {/* 自动标注功能已屏蔽 - Tabs 结构保留但仅显示手动标注 */}
       <Tabs
         activeKey={activeMode}
         onChange={(key) => setActiveMode(key as "manual" | "auto")}
@@ -548,102 +549,103 @@ export default function CreateAnnotationTask({
               </Form>
             ),
           },
-          {
-            key: "auto",
-            label: t('dataAnnotation.create.auto'),
-            children: (
-              <Form form={autoForm} layout="vertical" preserve={false}>
-                {/* 自动标注：任务名称仍然放在第一行，必填 */}
-                <Form.Item
-                  name="name"
-                  label={t('dataAnnotation.create.form.name')}
-                  rules={[
-                    { required: true, message: t('dataAnnotation.create.form.nameRequired') },
-                    { max: 100, message: t('dataAnnotation.create.form.nameMaxLength') },
-                  ]}
-                >
-                  <Input placeholder={t('dataAnnotation.create.form.namePlaceholder')} />
-                </Form.Item>
-
-                <Form.Item label={t('dataAnnotation.create.form.selectDatasetAndFiles')} required>
-                  <DatasetFileTransfer
-                    open
-                    selectedFilesMap={selectedFilesMap}
-                    onSelectedFilesChange={setSelectedFilesMap}
-                    onDatasetSelect={(dataset) => {
-                      setSelectedDataset(dataset as Dataset | null);
-                      autoForm.setFieldsValue({ datasetId: dataset?.id ?? "" });
-                    }}
-                    datasetTypeFilter={DatasetType.IMAGE}
-                    allowedFileExtensions={IMAGE_EXTENSIONS}
-                    singleDatasetOnly
-                  />
-                  {selectedDataset && (
-                    <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
-                      {t('dataAnnotation.create.form.currentDataset', { name: selectedDataset.name, count: imageFileCount })}
-                    </div>
-                  )}
-                </Form.Item>
-
-                <Form.Item
-                  hidden
-                  name="datasetId"
-                  rules={[{ required: true, message: t('dataAnnotation.create.form.datasetRequired') }]}
-                >
-                  <Input type="hidden" />
-                </Form.Item>
-
-                <Form.Item
-                  name="modelSize"
-                  label={t('dataAnnotation.create.form.modelSize')}
-                  rules={[{ required: true, message: t('dataAnnotation.create.form.modelSizeRequired') }]}
-                  initialValue="l"
-                >
-                  <Select>
-                    <Option value="n">{t('dataAnnotation.home.autoModelSizeLabels.n')}</Option>
-                    <Option value="s">{t('dataAnnotation.home.autoModelSizeLabels.s')}</Option>
-                    <Option value="m">{t('dataAnnotation.home.autoModelSizeLabels.m')}</Option>
-                    <Option value="l">{t('dataAnnotation.home.autoModelSizeLabels.l')}</Option>
-                    <Option value="x">{t('dataAnnotation.home.autoModelSizeLabels.x')}</Option>
-                  </Select>
-                </Form.Item>
-
-                <Form.Item
-                  name="confThreshold"
-                  label={t('dataAnnotation.create.form.confThreshold')}
-                  rules={[{ required: true, message: t('dataAnnotation.create.form.confThresholdRequired') }]}
-                  initialValue={0.7}
-                >
-                  <Slider
-                    min={0.1}
-                    max={0.9}
-                    step={0.05}
-                    tooltip={{ formatter: (v) => `${(v || 0) * 100}%` }}
-                  />
-                </Form.Item>
-
-                <Form.Item label={t('dataAnnotation.create.form.targetClasses')}>
-                  <Checkbox
-                    checked={selectAllClasses}
-                    onChange={(e) => handleClassSelectionChange(e.target.checked)}
-                  >
-                    {t('dataAnnotation.create.form.selectAllClasses')}
-                  </Checkbox>
-                  {!selectAllClasses && (
-                    <Form.Item name="targetClasses" noStyle>
-                      <Select mode="multiple" placeholder={t('dataAnnotation.create.form.selectTargetClasses')} style={{ marginTop: 8 }}>
-                        {COCO_CLASSES.map((cls) => (
-                          <Option key={cls.id} value={cls.id}>
-                            {cls.label} ({cls.name})
-                          </Option>
-                        ))}
-                      </Select>
-                    </Form.Item>
-                  )}
-                </Form.Item>
-              </Form>
-            ),
-          },
+          // 自动标注 Tab 已屏蔽（代码保留在下方注释中，需要恢复时可取消注释）
+          // {
+          //   key: "auto",
+          //   label: t('dataAnnotation.create.auto'),
+          //   children: (
+          //     <Form form={autoForm} layout="vertical" preserve={false}>
+          //       {/* 自动标注：任务名称仍然放在第一行，必填 */}
+          //       <Form.Item
+          //         name="name"
+          //         label={t('dataAnnotation.create.form.name')}
+          //         rules={[
+          //           { required: true, message: t('dataAnnotation.create.form.nameRequired') },
+          //           { max: 100, message: t('dataAnnotation.create.form.nameMaxLength') },
+          //         ]}
+          //       >
+          //         <Input placeholder={t('dataAnnotation.create.form.namePlaceholder')} />
+          //       </Form.Item>
+          // 
+          //       <Form.Item label={t('dataAnnotation.create.form.selectDatasetAndFiles')} required>
+          //         <DatasetFileTransfer
+          //           open
+          //           selectedFilesMap={selectedFilesMap}
+          //           onSelectedFilesChange={setSelectedFilesMap}
+          //           onDatasetSelect={(dataset) => {
+          //             setSelectedDataset(dataset as Dataset | null);
+          //             autoForm.setFieldsValue({ datasetId: dataset?.id ?? "" });
+          //           }}
+          //           datasetTypeFilter={DatasetType.IMAGE}
+          //           allowedFileExtensions={IMAGE_EXTENSIONS}
+          //           singleDatasetOnly
+          //         />
+          //         {selectedDataset && (
+          //           <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
+          //             {t('dataAnnotation.create.form.currentDataset', { name: selectedDataset.name, count: imageFileCount })}
+          //           </div>
+          //         )}
+          //       </Form.Item>
+          // 
+          //       <Form.Item
+          //         hidden
+          //         name="datasetId"
+          //         rules={[{ required: true, message: t('dataAnnotation.create.form.datasetRequired') }]}
+          //       >
+          //         <Input type="hidden" />
+          //       </Form.Item>
+          // 
+          //       <Form.Item
+          //         name="modelSize"
+          //         label={t('dataAnnotation.create.form.modelSize')}
+          //         rules={[{ required: true, message: t('dataAnnotation.create.form.modelSizeRequired') }]}
+          //         initialValue="l"
+          //       >
+          //         <Select>
+          //           <Option value="n">{t('dataAnnotation.home.autoModelSizeLabels.n')}</Option>
+          //           <Option value="s">{t('dataAnnotation.home.autoModelSizeLabels.s')}</Option>
+          //           <Option value="m">{t('dataAnnotation.home.autoModelSizeLabels.m')}</Option>
+          //           <Option value="l">{t('dataAnnotation.home.autoModelSizeLabels.l')}</Option>
+          //           <Option value="x">{t('dataAnnotation.home.autoModelSizeLabels.x')}</Option>
+          //         </Select>
+          //       </Form.Item>
+          // 
+          //       <Form.Item
+          //         name="confThreshold"
+          //         label={t('dataAnnotation.create.form.confThreshold')}
+          //         rules={[{ required: true, message: t('dataAnnotation.create.form.confThresholdRequired') }]}
+          //         initialValue={0.7}
+          //       >
+          //         <Slider
+          //           min={0.1}
+          //           max={0.9}
+          //           step={0.05}
+          //           tooltip={{ formatter: (v) => `${(v || 0) * 100}%` }}
+          //         />
+          //       </Form.Item>
+          // 
+          //       <Form.Item label={t('dataAnnotation.create.form.targetClasses')}>
+          //         <Checkbox
+          //           checked={selectAllClasses}
+          //           onChange={(e) => handleClassSelectionChange(e.target.checked)}
+          //         >
+          //           {t('dataAnnotation.create.form.selectAllClasses')}
+          //         </Checkbox>
+          //         {!selectAllClasses && (
+          //           <Form.Item name="targetClasses" noStyle>
+          //             <Select mode="multiple" placeholder={t('dataAnnotation.create.form.selectTargetClasses')} style={{ marginTop: 8 }}>
+          //               {COCO_CLASSES.map((cls) => (
+          //                 <Option key={cls.id} value={cls.id}>
+          //                   {cls.label} ({cls.name})
+          //                 </Option>
+          //               ))}
+          //             </Select>
+          //           </Form.Item>
+          //         )}
+          //       </Form.Item>
+          //     </Form>
+          //   ),
+          // },
         ]}
       />
     </Modal>
diff --git a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
index 2d5035925..02cdc4589 100644
--- a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
+++ b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
@@ -509,37 +509,38 @@ export default function DataAnnotation() {
     return !name.endsWith(" - 自动标注");
   });
 
+  // 自动标注功能已屏蔽：仅显示手动标注任务
   const mergedTableData = [
     // 手动标注任务（过滤掉自动生成的映射任务）
     ...manualVisibleTasks.map((task) => ({
       ...task,
       _kind: "manual" as const,
     })),
-    // 自动标注任务
-    ...autoTasks.map((task: any) => {
-      const sourceList = Array.isArray(task.sourceDatasets)
-        ? task.sourceDatasets
-        : task.datasetName
-        ? [task.datasetName]
-        : [];
-      const datasetName = sourceList.length > 0 ? sourceList.join("，") : "-";
-
-      return {
-        id: task.id,
-        name: task.name,
-        datasetId: task.datasetId || task.dataset_id,
-        datasetName,
-        createdAt: task.createdAt || "-",
-        updatedAt: task.updatedAt || "-",
-        _kind: "auto" as const,
-        autoStatus: task.status,
-        autoProgress: task.progress,
-        autoProcessedImages: task.processedImages,
-        autoTotalImages: task.totalImages,
-        autoDetectedObjects: task.detectedObjects,
-        autoConfig: task.config || {},
-      };
-    }),
+    // 自动标注任务已屏蔽（代码保留在下方注释中，需要恢复时可取消注释）
+    // ...autoTasks.map((task: any) => {
+    //   const sourceList = Array.isArray(task.sourceDatasets)
+    //     ? task.sourceDatasets
+    //     : task.datasetName
+    //     ? [task.datasetName]
+    //     : [];
+    //   const datasetName = sourceList.length > 0 ? sourceList.join("，") : "-";
+    // 
+    //   return {
+    //     id: task.id,
+    //     name: task.name,
+    //     datasetId: task.datasetId || task.dataset_id,
+    //     datasetName,
+    //     createdAt: task.createdAt || "-",
+    //     updatedAt: task.updatedAt || "-",
+    //     _kind: "auto" as const,
+    //     autoStatus: task.status,
+    //     autoProgress: task.progress,
+    //     autoProcessedImages: task.processedImages,
+    //     autoTotalImages: task.totalImages,
+    //     autoDetectedObjects: task.detectedObjects,
+    //     autoConfig: task.config || {},
+    //   };
+    // }),
   ];
 
   const columns: ColumnType<any>[] = [
@@ -585,88 +586,89 @@ export default function DataAnnotation() {
         );
       },
     },
-    {
-      title: t('dataAnnotation.home.columns.model'),
-      key: "modelSize",
-      width: 160,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const size = record.autoConfig?.modelSize;
-        return t(`dataAnnotation.home.autoModelSizeLabels.${size}`) || size || "-";
-      },
-    },
-    {
-      title: t('dataAnnotation.home.columns.confidence'),
-      key: "confThreshold",
-      width: 120,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const threshold = record.autoConfig?.confThreshold;
-        if (typeof threshold !== "number") return "-";
-        return `${(threshold * 100).toFixed(0)}%`;
-      },
-    },
-    {
-      title: t('dataAnnotation.home.columns.targetClasses'),
-      key: "targetClasses",
-      width: 160,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const classes: number[] = record.autoConfig?.targetClasses || [];
-        if (!classes.length) return t('dataAnnotation.home.allCategories');
-        const text = classes.join(", ");
-        return (
-          <Tooltip title={text}>
-            <span>{t('dataAnnotation.home.categoriesCount', { count: classes.length })}</span>
-          </Tooltip>
-        );
-      },
-    },
-    {
-      title: t('dataAnnotation.home.columns.autoStatus'),
-      key: "autoStatus",
-      width: 130,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const status = record.autoStatus as string;
-        const label = t(`dataAnnotation.home.autoStatusLabels.${status}`) || status || "-";
-        return <Tag>{label}</Tag>;
-      },
-    },
-    {
-      title: t('dataAnnotation.home.columns.autoProgress'),
-      key: "autoProgress",
-      width: 200,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const progress = typeof record.autoProgress === "number" ? record.autoProgress : 0;
-        const processed = record.autoProcessedImages ?? 0;
-        const total = record.autoTotalImages ?? 0;
-        return (
-          <div>
-            <Progress percent={progress} size="small" />
-            <div style={{ fontSize: 12, color: "#999" }}>
-              {processed} / {total}
-            </div>
-          </div>
-        );
-      },
-    },
-    {
-      title: t('dataAnnotation.home.columns.detectedObjects'),
-      key: "detectedObjects",
-      width: 120,
-      render: (_: any, record: any) => {
-        if (record._kind !== "auto") return "-";
-        const count = record.autoDetectedObjects;
-        if (typeof count !== "number") return "-";
-        try {
-          return count.toLocaleString();
-        } catch {
-          return String(count);
-        }
-      },
-    },
+    // 自动标注相关列已屏蔽（保留代码在注释中）
+    // {
+    //   title: t('dataAnnotation.home.columns.model'),
+    //   key: "modelSize",
+    //   width: 160,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const size = record.autoConfig?.modelSize;
+    //     return t(`dataAnnotation.home.autoModelSizeLabels.${size}`) || size || "-";
+    //   },
+    // },
+    // {
+    //   title: t('dataAnnotation.home.columns.confidence'),
+    //   key: "confThreshold",
+    //   width: 120,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const threshold = record.autoConfig?.confThreshold;
+    //     if (typeof threshold !== "number") return "-";
+    //     return `${(threshold * 100).toFixed(0)}%`;
+    //   },
+    // },
+    // {
+    //   title: t('dataAnnotation.home.columns.targetClasses'),
+    //   key: "targetClasses",
+    //   width: 160,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const classes: number[] = record.autoConfig?.targetClasses || [];
+    //     if (!classes.length) return t('dataAnnotation.home.allCategories');
+    //     const text = classes.join(", ");
+    //     return (
+    //       <Tooltip title={text}>
+    //         <span>{t('dataAnnotation.home.categoriesCount', { count: classes.length })}</span>
+    //       </Tooltip>
+    //     );
+    //   },
+    // },
+    // {
+    //   title: t('dataAnnotation.home.columns.autoStatus'),
+    //   key: "autoStatus",
+    //   width: 130,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const status = record.autoStatus as string;
+    //     const label = t(`dataAnnotation.home.autoStatusLabels.${status}`) || status || "-";
+    //     return <Tag>{label}</Tag>;
+    //   },
+    // },
+    // {
+    //   title: t('dataAnnotation.home.columns.autoProgress'),
+    //   key: "autoProgress",
+    //   width: 200,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const progress = typeof record.autoProgress === "number" ? record.autoProgress : 0;
+    //     const processed = record.autoProcessedImages ?? 0;
+    //     const total = record.autoTotalImages ?? 0;
+    //     return (
+    //       <div>
+    //         <Progress percent={progress} size="small" />
+    //         <div style={{ fontSize: 12, color: "#999" }}>
+    //           {processed} / {total}
+    //         </div>
+    //       </div>
+    //     );
+    //   },
+    // },
+    // {
+    //   title: t('dataAnnotation.home.columns.detectedObjects'),
+    //   key: "detectedObjects",
+    //   width: 120,
+    //   render: (_: any, record: any) => {
+    //     if (record._kind !== "auto") return "-";
+    //     const count = record.autoDetectedObjects;
+    //     if (typeof count !== "number") return "-";
+    //     try {
+    //       return count.toLocaleString();
+    //     } catch {
+    //       return String(count);
+    //     }
+    //   },
+    // },
     {
       title: t('dataAnnotation.home.columns.createdAt'),
       dataIndex: "createdAt",
@@ -736,7 +738,8 @@ export default function DataAnnotation() {
               </Dropdown>
             </>
           )}
-          {task._kind === "auto" && (
+          {/* 自动标注任务操作按钮已屏蔽（保留代码在注释中） */}
+          {/* {task._kind === "auto" && (
             <>
               <Button
                 type="text"
@@ -756,7 +759,6 @@ export default function DataAnnotation() {
                 {t('dataAnnotation.home.actions.syncToDb')}
               </Button>
 
-              {/* 二级功能：编辑任务数据集 + 删除任务（折叠菜单） */}
               <Dropdown
                 menu={{
                   items: [
@@ -790,7 +792,7 @@ export default function DataAnnotation() {
                 />
               </Dropdown>
             </>
-          )}
+          )} */}
         </div>
       ),
     },
@@ -906,7 +908,8 @@ export default function DataAnnotation() {
         ]}
       />
 
-      {editingAutoTask && (
+      {/* 自动标注对话框已屏蔽（保留代码在注释中） */}
+      {/* {editingAutoTask && (
         <EditAutoAnnotationDatasetDialog
           visible={showEditAutoDatasetDialog}
           task={editingAutoTask}
@@ -920,7 +923,7 @@ export default function DataAnnotation() {
             refreshAutoTasks();
           }}
         />
-      )}
+      )} */}
 
       {editingManualTask && (
         <EditManualAnnotationDatasetDialog
@@ -952,10 +955,10 @@ export default function DataAnnotation() {
         />
       )}
 
-      {importingAutoTask && (
+      {/* 自动标注导入对话框已屏蔽（保留代码在注释中） */}
+      {/* {importingAutoTask && (
         <ImportFromLabelStudioDialog
           visible={showImportAutoDialog}
-          // 这里直接透传自动标注任务结构（与 AutoAnnotation 页面保持一致字段）
           task={importingAutoTask as any}
           onCancel={() => {
             setShowImportAutoDialog(false);
@@ -966,7 +969,7 @@ export default function DataAnnotation() {
             setImportingAutoTask(null);
           }}
         />
-      )}
+      )} */}
     </div>
   );
 }
diff --git a/runtime/ops/annotation/__init__.py b/runtime/ops/annotation/__init__.py
index 9798f159e..16f0b4efc 100644
--- a/runtime/ops/annotation/__init__.py
+++ b/runtime/ops/annotation/__init__.py
@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
-"""Annotation-related operators (e.g. YOLO detection)."""
+"""Annotation-related operators"""
 
 __all__ = [
-    "image_object_detection_bounding_box",
 ]
diff --git a/runtime/ops/annotation/image_object_detection_bounding_box/__init__.py b/runtime/ops/annotation/image_object_detection_bounding_box/__init__.py
deleted file mode 100644
index 072e575b3..000000000
--- a/runtime/ops/annotation/image_object_detection_bounding_box/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-"""Image object detection (YOLOv8) operator package.
-
-This package exposes the ImageObjectDetectionBoundingBox annotator so that
-the auto-annotation worker can import it via different module paths.
-"""
-
-from .process import ImageObjectDetectionBoundingBox
-
-__all__ = ["ImageObjectDetectionBoundingBox"]
diff --git a/runtime/ops/annotation/image_object_detection_bounding_box/metadata.yml b/runtime/ops/annotation/image_object_detection_bounding_box/metadata.yml
deleted file mode 100644
index 1f160a0e0..000000000
--- a/runtime/ops/annotation/image_object_detection_bounding_box/metadata.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-name: image_object_detection_bounding_box
-version: 0.1.0
-description: "YOLOv8-based object detection operator for auto annotation"
diff --git a/runtime/ops/annotation/image_object_detection_bounding_box/process.py b/runtime/ops/annotation/image_object_detection_bounding_box/process.py
deleted file mode 100644
index a7b4f3e2b..000000000
--- a/runtime/ops/annotation/image_object_detection_bounding_box/process.py
+++ /dev/null
@@ -1,208 +0,0 @@
-#!/user/bin/python
-# -- encoding: utf-8 --
-
-"""
-Description: 图像目标检测算子
-Create: 2025/12/17
-"""
-import os
-import json
-import time
-from typing import Dict, Any
-import cv2
-import numpy as np
-from loguru import logger
-
-try:
-    from ultralytics import YOLO
-except ImportError:
-    logger.warning("ultralytics not installed. Please install it using: pip install ultralytics")
-    YOLO = None
-
-from datamate.core.base_op import Mapper
-
-
-# COCO 80 类别映射
-COCO_CLASS_MAP = {
-    0: "Person", 1: "Bicycle", 2: "Car", 3: "Motorcycle", 4: "Airplane",
-    5: "Bus", 6: "Train", 7: "Truck", 8: "Boat", 9: "Traffic Light",
-    10: "Fire Hydrant", 11: "Stop Sign", 12: "Parking Meter", 13: "Bench",
-    14: "Bird", 15: "Cat", 16: "Dog", 17: "Horse", 18: "Sheep", 19: "Cow",
-    20: "Elephant", 21: "Bear", 22: "Zebra", 23: "Giraffe", 24: "Backpack",
-    25: "Umbrella", 26: "Handbag", 27: "Tie", 28: "Suitcase", 29: "Frisbee",
-    30: "Skis", 31: "Snowboard", 32: "Sports Ball", 33: "Kite",
-    34: "Baseball Bat", 35: "Baseball Glove", 36: "Skateboard",
-    37: "Surfboard", 38: "Tennis Racket", 39: "Bottle",
-    40: "Wine Glass", 41: "Cup", 42: "Fork", 43: "Knife", 44: "Spoon",
-    45: "Bowl", 46: "Banana", 47: "Apple", 48: "Sandwich", 49: "Orange",
-    50: "Broccoli", 51: "Carrot", 52: "Hot Dog", 53: "Pizza",
-    54: "Donut", 55: "Cake", 56: "Chair", 57: "Couch",
-    58: "Potted Plant", 59: "Bed", 60: "Dining Table", 61: "Toilet",
-    62: "TV", 63: "Laptop", 64: "Mouse", 65: "Remote",
-    66: "Keyboard", 67: "Cell Phone", 68: "Microwave", 69: "Oven",
-    70: "Toaster", 71: "Sink", 72: "Refrigerator", 73: "Book",
-    74: "Clock", 75: "Vase", 76: "Scissors", 77: "Teddy Bear",
-    78: "Hair Drier", 79: "Toothbrush"
-}
-
-
-class ImageObjectDetectionBoundingBox(Mapper):
-    """图像目标检测算子"""
-
-    # 模型映射
-    MODEL_MAP = {
-        "n": "yolov8n.pt",
-        "s": "yolov8s.pt",
-        "m": "yolov8m.pt",
-        "l": "yolov8l.pt",
-        "x": "yolov8x.pt",
-    }
-
-    def __init__(self, *args, **kwargs):
-        super(ImageObjectDetectionBoundingBox, self).__init__(*args, **kwargs)
-        
-        # 获取参数
-        self._model_size = kwargs.get("modelSize", "l")
-        self._conf_threshold = kwargs.get("confThreshold", 0.7)
-        self._target_classes = kwargs.get("targetClasses", [])
-        self._output_dir = kwargs.get("outputDir", None)  # 输出目录
-        
-        # 如果目标类别为空列表，则检测所有类别
-        if not self._target_classes:
-            self._target_classes = None
-        else:
-            # 确保是整数列表
-            self._target_classes = [int(cls_id) for cls_id in self._target_classes]
-        
-        # 获取模型路径
-        model_filename = self.MODEL_MAP.get(self._model_size, "yolov8l.pt")
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        model_path = os.path.join(current_dir, model_filename)
-        
-        # 初始化模型
-        if YOLO is None:
-            raise ImportError("ultralytics is not installed. Please install it.")
-        
-        if not os.path.exists(model_path):
-            logger.warning(f"Model file {model_path} not found. Downloading from ultralytics...")
-            self.model = YOLO(model_filename)  # 自动下载
-        else:
-            self.model = YOLO(model_path)
-        
-        logger.info(f"Loaded YOLOv8 model: {model_filename}, "
-                   f"conf_threshold: {self._conf_threshold}, "
-                   f"target_classes: {self._target_classes}")
-
-    @staticmethod
-    def _get_color_by_class_id(class_id: int):
-        """根据 class_id 生成稳定颜色（BGR，OpenCV 用）"""
-        np.random.seed(class_id)
-        color = np.random.randint(0, 255, size=3).tolist()
-        return tuple(color)
-
-    def execute(self, sample: Dict[str, Any]) -> Dict[str, Any]:
-        """执行目标检测"""
-        start = time.time()
-        
-        # 读取图像文件
-        image_path = sample.get(self.image_key)
-        if not image_path or not os.path.exists(image_path):
-            logger.warning(f"Image file not found: {image_path}")
-            return sample
-        
-        # 读取图像
-        img = cv2.imread(image_path)
-        if img is None:
-            logger.warning(f"Failed to read image: {image_path}")
-            return sample
-        
-        # 执行目标检测
-        results = self.model(img, conf=self._conf_threshold)
-        r = results[0]
-        
-        # 准备标注数据
-        h, w = img.shape[:2]
-        annotations = {
-            "image": os.path.basename(image_path),
-            "width": w,
-            "height": h,
-            "model_size": self._model_size,
-            "conf_threshold": self._conf_threshold,
-            "selected_class_ids": self._target_classes,
-            "detections": []
-        }
-        
-        # 处理检测结果
-        if r.boxes is not None:
-            for box in r.boxes:
-                cls_id = int(box.cls[0])
-                
-                # 过滤目标类别
-                if self._target_classes is not None and cls_id not in self._target_classes:
-                    continue
-                
-                conf = float(box.conf[0])
-                x1, y1, x2, y2 = map(float, box.xyxy[0])
-                label = COCO_CLASS_MAP.get(cls_id, f"class_{cls_id}")
-                
-                # 记录检测结果
-                annotations["detections"].append({
-                    "label": label,
-                    "class_id": cls_id,
-                    "confidence": round(conf, 4),
-                    "bbox_xyxy": [x1, y1, x2, y2],
-                    "bbox_xywh": [x1, y1, x2 - x1, y2 - y1]
-                })
-                
-                # 在图像上绘制
-                color = self._get_color_by_class_id(cls_id)
-                cv2.rectangle(
-                    img,
-                    (int(x1), int(y1)),
-                    (int(x2), int(y2)),
-                    color,
-                    2
-                )
-                
-                cv2.putText(
-                    img,
-                    f"{label} {conf:.2f}",
-                    (int(x1), max(int(y1) - 5, 10)),
-                    cv2.FONT_HERSHEY_SIMPLEX,
-                    0.5,
-                    color,
-                    1
-                )
-        
-        # 确定输出目录
-        if self._output_dir and os.path.exists(self._output_dir):
-            output_dir = self._output_dir
-        else:
-            output_dir = os.path.dirname(image_path)
-        
-        # 创建 / 使用输出目录：直接在 output_dir 下保存 JSON，
-        # 约定最终路径为 <output_dir>/<image_stem>.json，避免 "annotations/annotations" 嵌套。
-        os.makedirs(output_dir, exist_ok=True)
-
-        # 保持原始文件名（不添加后缀），确保一一对应
-        base_name = os.path.basename(image_path)
-        name_without_ext = os.path.splitext(base_name)[0]
-
-        # 保存标注 JSON（文件名与图像对应）
-        json_filename = f"{name_without_ext}.json"
-        json_path = os.path.join(output_dir, json_filename)
-        with open(json_path, "w", encoding="utf-8") as f:
-            json.dump(annotations, f, indent=2, ensure_ascii=False)
-        
-        # 更新样本数据
-        sample["detection_count"] = len(annotations["detections"])
-        # 不再额外保存 output_image 副本，仅返回原始路径和注释信息
-        sample["output_image"] = image_path
-        sample["annotations_file"] = json_path
-        sample["annotations"] = annotations
-        
-        logger.info(f"Image: {os.path.basename(image_path)}, "
-                   f"Detections: {len(annotations['detections'])}, "
-                   f"Time: {(time.time() - start):.4f}s")
-        
-        return sample
diff --git a/runtime/ops/annotation/image_semantic_segmentation/process.py b/runtime/ops/annotation/image_semantic_segmentation/process.py
deleted file mode 100644
index c83387de0..000000000
--- a/runtime/ops/annotation/image_semantic_segmentation/process.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import os
-import json
-from pathlib import Path
-from ultralytics import YOLO
-import cv2
-import numpy as np
-
-
-def get_color_by_class_id(class_id: int):
-    """根据 class_id 生成稳定颜色（BGR）"""
-    np.random.seed(class_id)
-    color = np.random.randint(0, 255, size=3).tolist()
-    return tuple(color)
-
-
-def mask_to_polygons(mask: np.ndarray):
-    """将二值 mask 转换为 COCO 风格多边形列表"""
-    contours, _ = cv2.findContours(
-        mask,
-        cv2.RETR_EXTERNAL,
-        cv2.CHAIN_APPROX_SIMPLE
-    )
-
-    polygons = []
-    for contour in contours:
-        if contour.shape[0] < 3:
-            continue
-        polygon = contour.flatten().tolist()
-        polygons.append(polygon)
-
-    return polygons
-
-
-IMAGE_DIR = "C:/Users/meta/Desktop/Datamate/yolo/Photos"
-OUT_IMG_DIR = "outputs_seg/images"
-OUT_JSON_DIR = "outputs_seg/annotations"
-
-MODEL_MAP = {
-    "n": "yolov8n-seg.pt",
-    "s": "yolov8s-seg.pt",
-    "m": "yolov8m-seg.pt",
-    "l": "yolov8l-seg.pt",
-    "x": "yolov8x-seg.pt",
-}
-MODEL_KEY = "x"
-MODEL_PATH = MODEL_MAP[MODEL_KEY]
-
-CONF_THRES = 0.7
-DRAW_BBOX = True
-
-COCO_CLASS_MAP = {
-    0: "person", 1: "bicycle", 2: "car", 3: "motorcycle", 4: "airplane",
-    5: "bus", 6: "train", 7: "truck", 8: "boat", 9: "traffic light",
-    10: "fire hydrant", 11: "stop sign", 12: "parking meter", 13: "bench",
-    14: "bird", 15: "cat", 16: "dog", 17: "horse", 18: "sheep", 19: "cow",
-    20: "elephant", 21: "bear", 22: "zebra", 23: "giraffe", 24: "backpack",
-    25: "umbrella", 26: "handbag", 27: "tie", 28: "suitcase", 29: "frisbee",
-    30: "skis", 31: "snowboard", 32: "sports ball", 33: "kite",
-    34: "baseball bat", 35: "baseball glove", 36: "skateboard",
-    37: "surfboard", 38: "tennis racket", 39: "bottle",
-    40: "wine glass", 41: "cup", 42: "fork", 43: "knife", 44: "spoon",
-    45: "bowl", 46: "banana", 47: "apple", 48: "sandwich", 49: "orange",
-    50: "broccoli", 51: "carrot", 52: "hot dog", 53: "pizza",
-    54: "donut", 55: "cake", 56: "chair", 57: "couch",
-    58: "potted plant", 59: "bed", 60: "dining table", 61: "toilet",
-    62: "tv", 63: "laptop", 64: "mouse", 65: "remote",
-    66: "keyboard", 67: "cell phone", 68: "microwave", 69: "oven",
-    70: "toaster", 71: "sink", 72: "refrigerator", 73: "book",
-    74: "clock", 75: "vase", 76: "scissors", 77: "teddy bear",
-    78: "hair drier", 79: "toothbrush"
-}
-
-TARGET_CLASS_IDS = [0, 2, 5]
-
-os.makedirs(OUT_IMG_DIR, exist_ok=True)
-os.makedirs(OUT_JSON_DIR, exist_ok=True)
-
-if TARGET_CLASS_IDS is not None:
-    for cid in TARGET_CLASS_IDS:
-        if cid not in COCO_CLASS_MAP:
-            raise ValueError(f"Invalid class id: {cid}")
-
-model = YOLO(MODEL_PATH)
-
-image_paths = list(Path(IMAGE_DIR).glob("*.*"))
-
-for img_path in image_paths:
-    img = cv2.imread(str(img_path))
-    if img is None:
-        print(f"[WARN] Failed to read {img_path}")
-        continue
-
-    results = model(img, conf=CONF_THRES)
-    r = results[0]
-
-    h, w = img.shape[:2]
-    annotations = {
-        "image": img_path.name,
-        "width": w,
-        "height": h,
-        "model_key": MODEL_KEY,
-        "conf_threshold": CONF_THRES,
-        "supported_classes": COCO_CLASS_MAP,
-        "selected_class_ids": TARGET_CLASS_IDS,
-        "instances": []
-    }
-
-    if r.boxes is not None and r.masks is not None:
-        for i, box in enumerate(r.boxes):
-            cls_id = int(box.cls[0])
-            if TARGET_CLASS_IDS is not None and cls_id not in TARGET_CLASS_IDS:
-                continue
-
-            conf = float(box.conf[0])
-            x1, y1, x2, y2 = map(float, box.xyxy[0])
-            label = COCO_CLASS_MAP[cls_id]
-
-            mask = r.masks.data[i].cpu().numpy()
-            mask = (mask > 0.5).astype(np.uint8)
-            mask = cv2.resize(mask, (w, h), interpolation=cv2.INTER_NEAREST)
-
-            color = get_color_by_class_id(cls_id)
-            img[mask == 1] = (
-                img[mask == 1] * 0.5 + np.array(color) * 0.5
-            ).astype(np.uint8)
-
-            if True:
-                cv2.rectangle(
-                    img,
-                    (int(x1), int(y1)),
-                    (int(x2), int(y2)),
-                    color,
-                    2
-                )
-
-                cv2.putText(
-                    img,
-                    f"{label} {conf:.2f}",
-                    (int(x1), max(int(y1) - 5, 10)),
-                    cv2.FONT_HERSHEY_SIMPLEX,
-                    0.5,
-                    color,
-                    1
-                )
-
-            polygons = mask_to_polygons(mask)
-
-            annotations["instances"].append({
-                "label": label,
-                "class_id": cls_id,
-                "confidence": round(conf, 4),
-                "bbox_xyxy": [x1, y1, x2, y2],
-                "segmentation": polygons
-            })
-
-    out_img_path = os.path.join(OUT_IMG_DIR, img_path.name)
-    out_json_path = os.path.join(OUT_JSON_DIR, img_path.stem + ".json")
-
-    cv2.imwrite(out_img_path, img)
-
-    with open(out_json_path, "w", encoding="utf-8") as f:
-        json.dump(annotations, f, indent=2, ensure_ascii=False)
-
-    print(f"[OK] {img_path.name}")
-
-print("Segmentation batch finished.")
diff --git a/runtime/ops/pyproject.toml b/runtime/ops/pyproject.toml
index 11d6bb11b..a31594a47 100644
--- a/runtime/ops/pyproject.toml
+++ b/runtime/ops/pyproject.toml
@@ -16,7 +16,6 @@ dependencies = [
     "python-multipart>=0.0.20",
     "opencv-contrib-python-headless>=4.12.0.88",
     "opencv-python-headless>=4.12.0.88",
-    "openslide-python>=1.4.3",
     "paddleocr==3.3.0",
     "paddlepaddle==3.2.2",
     "pandas>=2.2.3,<3.0.0",
@@ -30,5 +29,4 @@ dependencies = [
     "sqlalchemy>=2.0.44",
     "xmltodict>=1.0.2",
     "zhconv>=1.4.3",
-    "ultralytics>=8.0.0",
 ]
diff --git a/runtime/python-executor/datamate/auto_annotation_worker.py b/runtime/python-executor/datamate/auto_annotation_worker.py
deleted file mode 100644
index 10162efe1..000000000
--- a/runtime/python-executor/datamate/auto_annotation_worker.py
+++ /dev/null
@@ -1,819 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Simple background worker for auto-annotation tasks.
-
-This module runs inside the datamate-runtime container (operator_runtime service).
-It polls `t_dm_auto_annotation_tasks` for pending tasks and performs YOLO
-inference using the ImageObjectDetectionBoundingBox operator, updating
-progress back to the same table so that the datamate-python backend and
-frontend can display real-time status.
-
-设计目标（最小可用版本）:
-- 单实例 worker，串行处理 `pending` 状态的任务。
-- 对指定数据集下的所有已完成文件逐张执行目标检测。
-- 按已处理图片数更新 `processed_images`、`progress`、`detected_objects`、`status` 等字段。
-- 失败时将任务标记为 `failed` 并记录 `error_message`。
-
-注意:
-- 为了保持简单，目前不处理 "running" 状态的恢复逻辑；容器重启时，
-  已处于 running 的任务不会被重新拉起，需要后续扩展。
-"""
-from __future__ import annotations
-
-import json
-import os
-import sys
-import threading
-import time
-import uuid
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Set
-import urllib.error
-import urllib.request
-
-from loguru import logger
-from sqlalchemy import text
-
-from datamate.sql_manager.sql_manager import SQLManager
-
-# 尝试多种导入路径，适配不同的打包/安装方式
-ImageObjectDetectionBoundingBox = None  # type: ignore
-try:
-    # 优先使用 datamate.ops 路径（源码 COPY 到 /opt/runtime/datamate/ops 情况）
-    from datamate.ops.annotation.image_object_detection_bounding_box.process import (  # type: ignore
-        ImageObjectDetectionBoundingBox,
-    )
-    logger.info(
-        "Imported ImageObjectDetectionBoundingBox from datamate.ops.annotation.image_object_detection_bounding_box",
-    )
-except Exception as e1:  # pragma: no cover - 导入失败时仅记录日志，避免整体崩溃
-    logger.error(
-        "Failed to import ImageObjectDetectionBoundingBox via datamate.ops: {}",
-        e1,
-    )
-    try:
-        # 兼容顶层 ops 包安装的情况（通过 ops.pth 暴露）
-        from ops.annotation.image_object_detection_bounding_box.process import (  # type: ignore
-            ImageObjectDetectionBoundingBox,
-        )
-        logger.info(
-            "Imported ImageObjectDetectionBoundingBox from top-level ops.annotation.image_object_detection_bounding_box",
-        )
-    except Exception as e2:
-        logger.error(
-            "Failed to import ImageObjectDetectionBoundingBox via top-level ops package: {}",
-            e2,
-        )
-        ImageObjectDetectionBoundingBox = None
-
-
-# 进一步兜底：直接从本地 runtime/ops 目录加载算子（开发环境常用场景）
-if ImageObjectDetectionBoundingBox is None:
-    try:
-        project_root = Path(__file__).resolve().parents[2]
-        ops_root = project_root / "ops"
-        if ops_root.is_dir():
-            # 确保 ops 的父目录在 sys.path 中，这样可以按 "ops.xxx" 导入
-            if str(project_root) not in sys.path:
-                sys.path.insert(0, str(project_root))
-
-            from ops.annotation.image_object_detection_bounding_box.process import (  # type: ignore
-                ImageObjectDetectionBoundingBox,
-            )
-
-            logger.info(
-                "Imported ImageObjectDetectionBoundingBox from local runtime/ops.annotation.image_object_detection_bounding_box",
-            )
-        else:
-            logger.warning(
-                "Local runtime/ops directory not found when trying to import ImageObjectDetectionBoundingBox: {}",
-                ops_root,
-            )
-    except Exception as e3:  # pragma: no cover - 兜底失败仅记录日志
-        logger.error(
-            "Failed to import ImageObjectDetectionBoundingBox from local runtime/ops: {}",
-            e3,
-        )
-        ImageObjectDetectionBoundingBox = None
-
-
-POLL_INTERVAL_SECONDS = float(os.getenv("AUTO_ANNOTATION_POLL_INTERVAL", "5"))
-
-DEFAULT_OUTPUT_ROOT = os.getenv(
-    "AUTO_ANNOTATION_OUTPUT_ROOT", "/dataset"
-)
-
-BACKEND_BASE_URL = os.getenv(
-    "AUTO_ANNOTATION_BACKEND_URL", "http://datamate-backend-python:18000"
-)
-
-AUTO_SYNC_ENABLED = os.getenv("AUTO_ANNOTATION_SYNC_ENABLED", "true").lower() == "true"
-AUTO_SYNC_TIMEOUT_SECONDS = float(os.getenv("AUTO_ANNOTATION_SYNC_TIMEOUT", "10"))
-
-
-def _fetch_pending_task() -> Optional[Dict[str, Any]]:
-    """从 t_dm_auto_annotation_tasks 中取出一个 pending 任务。"""
-
-    sql = text(
-        """
-        SELECT id, name, dataset_id, dataset_name, config, file_ids, status,
-               total_images, processed_images, detected_objects, output_path
-        FROM t_dm_auto_annotation_tasks
-        WHERE status = 'pending' AND deleted_at IS NULL
-        ORDER BY created_at ASC
-        LIMIT 1
-        """
-    )
-
-    with SQLManager.create_connect() as conn:
-        result = conn.execute(sql).fetchone()
-        if not result:
-            return None
-        row = dict(result._mapping)  # type: ignore[attr-defined]
-
-    # 兼容 config 字段为 JSONB（dict）或 text（str）的两种情况
-    raw_cfg = row.get("config")
-    if isinstance(raw_cfg, (dict, list)):
-        row["config"] = raw_cfg
-    elif isinstance(raw_cfg, str) and raw_cfg.strip():
-        try:
-            row["config"] = json.loads(raw_cfg)
-        except Exception:
-            row["config"] = {}
-    else:
-        row["config"] = {}
-
-    # file_ids 同样可能是 JSONB 或 text
-    try:
-        raw_ids = row.get("file_ids")
-        if not raw_ids:
-            row["file_ids"] = None
-        elif isinstance(raw_ids, str):
-            row["file_ids"] = json.loads(raw_ids)
-        else:
-            row["file_ids"] = raw_ids
-    except Exception:
-        row["file_ids"] = None
-
-    return row
-
-
-def _update_task_status(
-    task_id: str,
-    *,
-    status: str,
-    progress: Optional[int] = None,
-    processed_images: Optional[int] = None,
-    detected_objects: Optional[int] = None,
-    total_images: Optional[int] = None,
-    output_path: Optional[str] = None,
-    error_message: Optional[str] = None,
-    completed: bool = False,
-) -> None:
-    """更新任务的状态和统计字段。"""
-
-    fields: List[str] = ["status = :status", "updated_at = :updated_at"]
-    params: Dict[str, Any] = {
-        "task_id": task_id,
-        "status": status,
-        "updated_at": datetime.now(),
-    }
-
-    if progress is not None:
-        fields.append("progress = :progress")
-        params["progress"] = int(progress)
-    if processed_images is not None:
-        fields.append("processed_images = :processed_images")
-        params["processed_images"] = int(processed_images)
-    if detected_objects is not None:
-        fields.append("detected_objects = :detected_objects")
-        params["detected_objects"] = int(detected_objects)
-    if total_images is not None:
-        fields.append("total_images = :total_images")
-        params["total_images"] = int(total_images)
-    if output_path is not None:
-        fields.append("output_path = :output_path")
-        params["output_path"] = output_path
-    if error_message is not None:
-        fields.append("error_message = :error_message")
-        params["error_message"] = error_message[:2000]
-    if completed:
-        fields.append("completed_at = :completed_at")
-        params["completed_at"] = datetime.now()
-
-    sql = text(
-        f"""
-        UPDATE t_dm_auto_annotation_tasks
-        SET {', '.join(fields)}
-        WHERE id = :task_id
-        """
-    )
-
-    with SQLManager.create_connect() as conn:
-        conn.execute(sql, params)
-
-
-def _get_dataset_root(dataset_id: str) -> Optional[str]:
-    """根据数据集ID获取其根路径。
-
-    自动标注结果将写入该路径下的 annotations/<task_id>/annotations 目录中，
-    既复用原有卷，又避免为每次自动标注创建新的数据集。
-    """
-
-    sql = text(
-        """
-        SELECT path
-        FROM t_dm_datasets
-        WHERE id = :dataset_id
-          AND status = 'ACTIVE'
-        """
-    )
-
-    with SQLManager.create_connect() as conn:
-        row = conn.execute(sql, {"dataset_id": dataset_id}).fetchone()
-        if not row:
-            return None
-        return str(row[0]) if row[0] is not None else None
-
-
-def _load_dataset_files(dataset_id: str) -> List[Tuple[str, str, str]]:
-    """加载指定数据集下的所有已激活文件。
-
-    不再根据 tags 是否为空进行过滤，避免影响后续新任务或重复任务的执行。
-    """
-
-    sql = text(
-        """
-        SELECT id, file_path, file_name
-        FROM t_dm_dataset_files
-        WHERE dataset_id = :dataset_id
-          AND status = 'ACTIVE'
-        ORDER BY created_at ASC
-        """
-    )
-
-    with SQLManager.create_connect() as conn:
-        rows = conn.execute(sql, {"dataset_id": dataset_id}).fetchall()
-        return [(str(r[0]), str(r[1]), str(r[2])) for r in rows]
-
-
-def _load_files_by_ids(file_ids: List[str]) -> List[Tuple[str, str, str]]:
-    """根据文件ID列表加载文件记录，支持跨多个数据集。"""
-
-    if not file_ids:
-        return []
-
-    placeholders = ", ".join(f":id{i}" for i in range(len(file_ids)))
-    sql = text(
-        f"""
-        SELECT id, file_path, file_name
-        FROM t_dm_dataset_files
-        WHERE id IN ({placeholders})
-          AND status = 'ACTIVE'
-        ORDER BY created_at ASC
-        """
-    )
-    params = {f"id{i}": str(fid) for i, fid in enumerate(file_ids)}
-
-    with SQLManager.create_connect() as conn:
-        rows = conn.execute(sql, params).fetchall()
-        return [(str(r[0]), str(r[1]), str(r[2])) for r in rows]
-
-
-def _build_file_tags_from_detections(detections: List[Dict[str, Any]]) -> Optional[List[Dict[str, Any]]]:
-    """根据检测结果构建 FileTag JSON 结构。
-
-    tags 字段在 DM 服务中被当作 List[FileTag] 解析，结构需与
-    backend `FileTag`/runtime `DatasetFileTag` 保持兼容：
-
-    [{
-        "id": "...",               # 可选
-        "type": "labels",         # 类型键
-        "from_name": "auto_annotation",  # 来源
-        "values": {"labels": ["Person", "Car"]}
-    }]
-
-    重复类别只保留一个。
-    """
-
-    if not detections:
-        return None
-
-    label_set: Set[str] = set()
-    for det in detections:
-        label = det.get("label")
-        if isinstance(label, str) and label:
-            label_set.add(label)
-
-    if not label_set:
-        return None
-
-    # 排序以保证结果稳定
-    labels = sorted(label_set)
-    return [
-        {
-            "id": None,
-            "type": "labels",
-            "from_name": "auto_annotation",
-            "values": {"labels": labels},
-        }
-    ]
-
-
-def _update_dataset_file_tags(file_id: str, tags: List[Dict[str, Any]]) -> None:
-    """将标签写入 t_dm_dataset_files.tags 并更新 tags_updated_at。"""
-
-    if not file_id:
-        return
-
-    try:
-        now = datetime.utcnow()
-        sql = text(
-            """
-            UPDATE t_dm_dataset_files
-            SET tags = :tags,
-                tags_updated_at = :tags_updated_at
-            WHERE id = :file_id
-            """
-        )
-        params = {
-            "file_id": file_id,
-            "tags": json.dumps(tags, ensure_ascii=False),
-            "tags_updated_at": now,
-        }
-        with SQLManager.create_connect() as conn:
-            conn.execute(sql, params)
-    except Exception as e:  # pragma: no cover - 防御性日志
-        logger.error(
-            "Failed to update tags for dataset file {}: {}",
-            file_id,
-            e,
-        )
-
-
-def _register_annotation_output_file(dataset_id: str, annotations_path: str) -> None:
-    """确保自动标注生成的 JSON 结果文件在 t_dm_dataset_files 中有一条记录。
-
-    - 若同一 dataset_id + file_path 已存在，则仅更新文件大小和时间戳；
-    - 若不存在，则插入一条新的 ACTIVE 记录。
-    """
-
-    if not annotations_path:
-        return
-
-    try:
-        if not os.path.isfile(annotations_path):
-            logger.warning(
-                "Annotation JSON file not found when registering dataset file: {}",
-                annotations_path,
-            )
-            return
-
-        file_name = os.path.basename(annotations_path)
-        ext = os.path.splitext(file_name)[1].lstrip(".").lower() or "other"
-
-        try:
-            file_size = os.path.getsize(annotations_path)
-        except OSError:
-            file_size = 0
-
-        now = datetime.utcnow()
-
-        with SQLManager.create_connect() as conn:
-            # 先检查是否已经存在同一路径的文件记录
-            existing = conn.execute(
-                text(
-                    """
-                    SELECT id, file_size
-                    FROM t_dm_dataset_files
-                    WHERE dataset_id = :dataset_id
-                      AND file_path = :file_path
-                      AND status = 'ACTIVE'
-                    LIMIT 1
-                    """,
-                ),
-                {"dataset_id": dataset_id, "file_path": annotations_path},
-            ).fetchone()
-
-            if existing:
-                # 已存在：仅更新文件大小及时间戳，避免重复插入
-                conn.execute(
-                    text(
-                        """
-                        UPDATE t_dm_dataset_files
-                        SET file_size = :file_size,
-                            updated_at = :updated_at,
-                            last_access_time = :last_access_time
-                        WHERE id = :id
-                        """,
-                    ),
-                    {
-                        "id": existing[0],
-                        "file_size": int(file_size),
-                        "updated_at": now,
-                        "last_access_time": now,
-                    },
-                )
-            else:
-                # 新文件：插入记录，并尽量更新 t_dm_datasets 的统计字段
-                new_id = str(uuid.uuid4())
-                conn.execute(
-                    text(
-                        """
-                        INSERT INTO t_dm_dataset_files
-                            (id, dataset_id, file_name, file_path, file_type, file_size, status, upload_time, created_at, updated_at)
-                        VALUES
-                            (:id, :dataset_id, :file_name, :file_path, :file_type, :file_size, 'ACTIVE', :now, :now, :now)
-                        """,
-                    ),
-                    {
-                        "id": new_id,
-                        "dataset_id": dataset_id,
-                        "file_name": file_name,
-                        "file_path": annotations_path,
-                        "file_type": ext,
-                        "file_size": int(file_size),
-                        "now": now,
-                    },
-                )
-
-                # 轻量更新数据集的文件数量和总大小统计
-                try:
-                    conn.execute(
-                        text(
-                            """
-                            UPDATE t_dm_datasets
-                            SET file_count = COALESCE(file_count, 0) + 1,
-                                size_bytes = COALESCE(size_bytes, 0) + :delta,
-                                updated_at = :now,
-                                status = 'ACTIVE'
-                            WHERE id = :dataset_id
-                            """,
-                        ),
-                        {
-                            "dataset_id": dataset_id,
-                            "delta": int(file_size),
-                            "now": now,
-                        },
-                    )
-                except Exception as e_ds:  # pragma: no cover - 统计更新失败不影响主流程
-                    logger.warning(
-                        "Failed to update dataset stats for {} when registering annotation file {}: {}",
-                        dataset_id,
-                        annotations_path,
-                        e_ds,
-                    )
-    except Exception as e:  # pragma: no cover - 防御性日志
-        logger.error(
-            "Failed to register annotation output file for dataset {} at {}: {}",
-            dataset_id,
-            annotations_path,
-            e,
-        )
-
-
-def _ensure_output_dir(output_dir: str) -> str:
-    """确保输出目录存在。
-
-    annotations 子目录由算子本身负责创建；这里不再为 images 创建额外目录，
-    以符合“自动标注不再单独保存 images” 的新设计。
-    """
-
-    os.makedirs(output_dir, exist_ok=True)
-    return output_dir
-
-
-def _trigger_forward_sync_to_label_studio(task_id: str) -> None:
-    """在任务完成后，自动调用后端接口，将检测结果推送到 Label Studio。
-
-    该调用是“尽力而为”的：失败只记录日志，不影响任务本身的完成状态。
-    """
-
-    if not AUTO_SYNC_ENABLED:
-        logger.info(
-            "Auto sync to Label Studio is disabled by env AUTO_ANNOTATION_SYNC_ENABLED",
-        )
-        return
-
-    base_url = BACKEND_BASE_URL.rstrip("/")
-    url = f"{base_url}/api/annotation/auto/{task_id}/sync-label-studio"
-
-    try:
-        payload = json.dumps({}).encode("utf-8")
-        req = urllib.request.Request(
-            url,
-            data=payload,
-            method="POST",
-            headers={"Content-Type": "application/json"},
-        )
-        with urllib.request.urlopen(req, timeout=AUTO_SYNC_TIMEOUT_SECONDS) as resp:
-            status_code = resp.getcode()
-            body = resp.read().decode("utf-8", errors="ignore")
-        logger.info(
-            "Auto-annotation forward sync triggered for task {}: status={}, response={}",
-            task_id,
-            status_code,
-            body,
-        )
-    except urllib.error.HTTPError as e:
-        logger.error(
-            "HTTP error when syncing auto-annotation task {} to Label Studio: status={}, reason={}",
-            task_id,
-            e.code,
-            e.reason,
-        )
-    except Exception as e:  # pragma: no cover - 防御性日志
-        logger.error(
-            "Failed to sync auto-annotation task {} to Label Studio: {}",
-            task_id,
-            e,
-        )
-
-
-def _process_single_task(task: Dict[str, Any]) -> None:
-    """执行单个自动标注任务。"""
-
-    if ImageObjectDetectionBoundingBox is None:
-        logger.error(
-            "YOLO operator not available (import failed earlier), skip auto-annotation task: {}",
-            task["id"],
-        )
-        _update_task_status(
-            task["id"],
-            status="failed",
-            error_message="YOLO operator not available in runtime container",
-        )
-        return
-
-    task_id = str(task["id"])
-    dataset_id = str(task["dataset_id"])
-    task_name = str(task.get("name") or "")
-    source_dataset_name = str(task.get("dataset_name") or "")
-    cfg: Dict[str, Any] = task.get("config") or {}
-    selected_file_ids: Optional[List[str]] = task.get("file_ids") or None
-
-    model_size = cfg.get("modelSize", "l")
-    conf_threshold = float(cfg.get("confThreshold", 0.7))
-    target_classes = cfg.get("targetClasses", []) or []
-
-    # 优先使用前端传入的输出数据集名称；若未提供，则使用“源数据集名称+自动标注任务”
-    # 兼容历史/不同风格的字段名（如 output_dataset_name）
-    output_dataset_name = (
-        cfg.get("outputDatasetName")
-        or cfg.get("output_dataset_name")
-        or task.get("outputDatasetName")
-        or task.get("output_dataset_name")
-    )
-    if isinstance(output_dataset_name, str):
-        output_dataset_name = output_dataset_name.strip()
-
-    if not output_dataset_name:
-        base_name = source_dataset_name or task_name or f"dataset-{dataset_id[:8]}"
-        # 默认规则：源数据集名称 + "自动标注任务"
-        output_dataset_name = f"{base_name}自动标注任务"
-
-    logger.info(
-        "Start processing auto-annotation task: id={}, dataset_id={}, model_size={}, conf_threshold={}, target_classes={}, output_dataset_name={}",
-        task_id,
-        dataset_id,
-        model_size,
-        conf_threshold,
-        target_classes,
-        output_dataset_name,
-    )
-
-    _update_task_status(task_id, status="running", progress=0)
-
-    if selected_file_ids:
-        all_files = _load_files_by_ids(selected_file_ids)
-    else:
-        all_files = _load_dataset_files(dataset_id)
-
-    # 优先复用任务已有的输出目录，避免重复创建或切换路径
-    existing_output_path = (task.get("output_path") or "").strip() or None
-    output_dir: Optional[str] = None
-
-    if existing_output_path:
-        try:
-            # 确保目录存在
-            output_dir = _ensure_output_dir(existing_output_path)
-        except Exception as e:
-            logger.error(
-                "Failed to reuse existing output directory for task {}: {}",
-                task_id,
-                e,
-            )
-
-    # 如果没有可复用的输出目录，则基于“源数据集路径/annotations” 作为输出根目录
-    if not output_dir:
-        dataset_root = _get_dataset_root(dataset_id)
-        if not dataset_root:
-            logger.error(
-                "Failed to resolve dataset root for auto-annotation task {}: dataset_id={} not found or inactive",
-                task_id,
-                dataset_id,
-            )
-            _update_task_status(
-                task_id,
-                status="failed",
-                error_message="Dataset path not found for auto-annotation task",
-            )
-            return
-
-        # 直接使用源数据集下的 annotations 目录作为输出目录，
-        # YOLO 算子会在其中创建 JSON 文件。
-        base_annotations_dir = os.path.join(dataset_root, "annotations")
-        output_dir = _ensure_output_dir(base_annotations_dir)
-
-    # 仅对“新选的数据”执行自动标注：
-    # 已经在输出目录中存在对应 JSON 文件的，认为该任务已跑过，不再重复标注
-    existing_stems: Set[str] = set()
-    annotations_dir = output_dir
-    if os.path.isdir(annotations_dir):
-        try:
-            for name in os.listdir(annotations_dir):
-                file_path = os.path.join(annotations_dir, name)
-                if not os.path.isfile(file_path):
-                    continue
-                stem, _ = os.path.splitext(name)
-                existing_stems.add(stem)
-        except Exception as e:
-            logger.error(
-                "Failed to list existing annotations for auto-annotation task {}: {}",
-                task_id,
-                e,
-            )
-
-    # all_files: List[(file_id, file_path, file_name)]
-    files = [
-        (file_id, file_path, file_name)
-        for file_id, file_path, file_name in all_files
-        if os.path.splitext(os.path.basename(file_path))[0] not in existing_stems
-    ]
-
-    total_images = len(files)
-    if total_images == 0:
-        logger.info(
-            "No new files to process for auto-annotation task {}, reuse existing output at {}",
-            task_id,
-            output_dir,
-        )
-        _update_task_status(
-            task_id,
-            status="completed",
-            progress=100,
-            total_images=0,
-            processed_images=0,
-            detected_objects=0,
-            completed=True,
-            output_path=output_dir,
-        )
-        return
-
-    try:
-        detector = ImageObjectDetectionBoundingBox(
-            modelSize=model_size,
-            confThreshold=conf_threshold,
-            targetClasses=target_classes,
-            outputDir=output_dir,
-        )
-    except Exception as e:
-        logger.error("Failed to init YOLO detector for task {}: {}", task_id, e)
-        _update_task_status(
-            task_id,
-            status="failed",
-            total_images=total_images,
-            processed_images=0,
-            detected_objects=0,
-            error_message=f"Init YOLO detector failed: {e}",
-        )
-        return
-
-    processed = 0
-    detected_total = 0
-
-    # 记录：文件名 -> FileTag JSON，用于给新输出数据集的文件打标签
-    tags_by_filename: Dict[str, List[Dict[str, Any]]] = {}
-
-    for file_id, file_path, file_name in files:
-        try:
-            sample = {
-                "image": file_path,
-                "filename": file_name,
-            }
-            result = detector.execute(sample)
-
-            annotations = (result or {}).get("annotations", {})
-            detections = annotations.get("detections", [])
-            detected_total += len(detections)
-            processed += 1
-
-            # 根据算子返回的 annotations_file 或约定路径，注册 JSON 文件到 t_dm_dataset_files
-            annotations_file = None
-            try:
-                annotations_file = (result or {}).get("annotations_file")
-            except Exception:
-                annotations_file = None
-
-            if not annotations_file:
-                base_name = os.path.basename(file_path)
-                stem, _ = os.path.splitext(base_name)
-                # 兼容两种目录结构：<output_dir>/annotations/<name>.json 或 <output_dir>/<name>.json
-                candidate1 = os.path.join(output_dir, "annotations", f"{stem}.json")
-                candidate2 = os.path.join(output_dir, f"{stem}.json")
-                if os.path.isfile(candidate1):
-                    annotations_file = candidate1
-                elif os.path.isfile(candidate2):
-                    annotations_file = candidate2
-
-            if annotations_file:
-                _register_annotation_output_file(dataset_id, annotations_file)
-
-            # 基于检测结果生成标签（按类别去重），并写回源数据集文件
-            file_tags = _build_file_tags_from_detections(detections)
-            if file_tags:
-                try:
-                    _update_dataset_file_tags(file_id, file_tags)
-                    # 使用源文件名作为 key，供输出数据集复用
-                    base_name = os.path.basename(file_path)
-                    tags_by_filename[base_name] = file_tags
-                except Exception as e:
-                    logger.error(
-                        "Failed to persist tags for file {} in dataset {}: {}",
-                        file_id,
-                        dataset_id,
-                        e,
-                    )
-
-            progress = int(processed * 100 / total_images) if total_images > 0 else 100
-
-            _update_task_status(
-                task_id,
-                status="running",
-                progress=progress,
-                processed_images=processed,
-                detected_objects=detected_total,
-                total_images=total_images,
-                output_path=output_dir,
-            )
-        except Exception as e:
-            logger.error(
-                "Failed to process image for task {}: file_path={}, error={}",
-                task_id,
-                file_path,
-                e,
-            )
-            continue
-
-    _update_task_status(
-        task_id,
-        status="completed",
-        progress=100,
-        processed_images=processed,
-        detected_objects=detected_total,
-        total_images=total_images,
-        output_path=output_dir,
-        completed=True,
-    )
-
-    logger.info(
-        "Completed auto-annotation task: id={}, total_images={}, processed={}, detected_objects={}, output_path={}",
-        task_id,
-        total_images,
-        processed,
-        detected_total,
-        output_dir,
-    )
-
-    # 任务完成后，自动触发一次前向同步，将检测结果推送到 Label Studio
-    _trigger_forward_sync_to_label_studio(task_id)
-
-
-def _worker_loop() -> None:
-    """Worker 主循环，在独立线程中运行。"""
-
-    logger.info(
-        "Auto-annotation worker started with poll interval {} seconds, output root {}",
-        POLL_INTERVAL_SECONDS,
-        DEFAULT_OUTPUT_ROOT,
-    )
-
-    while True:
-        try:
-            task = _fetch_pending_task()
-            if not task:
-                time.sleep(POLL_INTERVAL_SECONDS)
-                continue
-
-            _process_single_task(task)
-        except Exception as e:  # pragma: no cover - 防御性日志
-            logger.error("Auto-annotation worker loop error: {}", e)
-            time.sleep(POLL_INTERVAL_SECONDS)
-
-
-def start_auto_annotation_worker() -> None:
-    """在后台线程中启动自动标注 worker。"""
-
-    thread = threading.Thread(target=_worker_loop, name="auto-annotation-worker", daemon=True)
-    thread.start()
-    logger.info("Auto-annotation worker thread started: {}", thread.name)
diff --git a/runtime/python-executor/datamate/operator_runtime.py b/runtime/python-executor/datamate/operator_runtime.py
index c7f67aed8..91da1c4d4 100644
--- a/runtime/python-executor/datamate/operator_runtime.py
+++ b/runtime/python-executor/datamate/operator_runtime.py
@@ -26,20 +26,8 @@
     enqueue=True
 )
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    try:
-        logger.info("Initializing background worker...")
-        start_auto_annotation_worker()
-        logger.info("Auto-annotation worker started successfully.")
-    except Exception as e:
-        logger.error("Failed to start auto-annotation worker: {}", e)
-
-    yield
-
-    logger.info("Shutting down background worker...")
 
-app = FastAPI(lifespan=lifespan)
+app = FastAPI()
 
 
 class APIException(Exception):
diff --git a/scripts/db/data-operator-init.sql b/scripts/db/data-operator-init.sql
index 8dff750c1..4609057f4 100644
--- a/scripts/db/data-operator-init.sql
+++ b/scripts/db/data-operator-init.sql
@@ -246,13 +246,13 @@ WHERE c.id IN ('de36b61c-9e8a-4422-8c31-d30585c7100f', '9eda9d5d-072b-499b-916c-
 ON CONFLICT DO NOTHING;
 
 -- 图像目标检测与预标注算子：功能归类为「标注」而非「清洗」
-INSERT INTO t_operator_category_relation(category_id, operator_id)
-SELECT c.id, o.id
-FROM t_operator_category c
-    CROSS JOIN t_operator o
-WHERE c.id IN ('de36b61c-9e8a-4422-8c31-d30585c7100f', 'cfa9d8e2-5b5f-4f1e-9f12-1234567890ab', '96a3b07a-3439-4557-a835-525faad60ca3', '431e7798-5426-4e1a-aae6-b9905a836b34','9eda9d5d-072b-499b-916c-797a0a8750e1')
-    AND o.id IN ('ObjectDetectionRectangle')
-ON CONFLICT DO NOTHING;
+-- INSERT INTO t_operator_category_relation(category_id, operator_id)
+-- SELECT c.id, o.id
+-- FROM t_operator_category c
+--     CROSS JOIN t_operator o
+-- WHERE c.id IN ('de36b61c-9e8a-4422-8c31-d30585c7100f', 'cfa9d8e2-5b5f-4f1e-9f12-1234567890ab', '96a3b07a-3439-4557-a835-525faad60ca3', '431e7798-5426-4e1a-aae6-b9905a836b34','9eda9d5d-072b-499b-916c-797a0a8750e1')
+--     AND o.id IN ('ObjectDetectionRectangle')
+-- ON CONFLICT DO NOTHING;
 
 
 INSERT INTO t_operator

From b297bda05c3c0981ad92f412282748ff96c0de9b Mon Sep 17 00:00:00 2001
From: hhhhsc <1710496817@qq.com>
Date: Thu, 23 Apr 2026 10:22:02 +0800
Subject: [PATCH 2/3] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=A0=87=E6=B3=A8?=
 =?UTF-8?q?=E7=AE=97=E5=AD=90=EF=BC=8C=E5=B1=8F=E8=94=BD=E8=87=AA=E5=8A=A8?=
 =?UTF-8?q?=E6=A0=87=E6=B3=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 runtime/python-executor/datamate/operator_runtime.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/runtime/python-executor/datamate/operator_runtime.py b/runtime/python-executor/datamate/operator_runtime.py
index 91da1c4d4..9963a1d5f 100644
--- a/runtime/python-executor/datamate/operator_runtime.py
+++ b/runtime/python-executor/datamate/operator_runtime.py
@@ -14,7 +14,6 @@
 from datamate.scheduler import cmd_scheduler
 from datamate.scheduler import func_scheduler
 from datamate.wrappers import WRAPPERS
-from datamate.auto_annotation_worker import start_auto_annotation_worker
 
 # 日志配置
 LOG_DIR = "/var/log/datamate/runtime"

From b0a6a63e385bbc1b7241bf7562f3e570890b9e34 Mon Sep 17 00:00:00 2001
From: hhhhsc <1710496817@qq.com>
Date: Thu, 23 Apr 2026 10:52:47 +0800
Subject: [PATCH 3/3] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=A0=87=E6=B3=A8?=
 =?UTF-8?q?=E7=AE=97=E5=AD=90=EF=BC=8C=E5=B1=8F=E8=94=BD=E8=87=AA=E5=8A=A8?=
 =?UTF-8?q?=E6=A0=87=E6=B3=A8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../components/CreateAnnotationTaskDialog.tsx | 112 +++--
 .../DataAnnotation/Home/DataAnnotation.tsx    | 399 +++++++++---------
 2 files changed, 247 insertions(+), 264 deletions(-)

diff --git a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
index 49aa0a55b..aa64a72fe 100644
--- a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
@@ -6,7 +6,8 @@ import { useEffect, useState, useRef } from "react";
 import {
   createAnnotationTaskUsingPost,
   queryAnnotationTemplatesUsingGet,
-  createAutoAnnotationTaskUsingPost,
+  // 自动标注创建API已屏蔽（保留代码在注释中）
+  // createAutoAnnotationTaskUsingPost,
 } from "../../annotation.api";
 import DatasetFileTransfer from "@/components/business/DatasetFileTransfer";
 import { DatasetType, type Dataset, type DatasetFile } from "@/pages/DataManagement/dataset.model";
@@ -329,65 +330,54 @@ export default function CreateAnnotationTask({
     }
   };
 
-  const handleAutoSubmit = async () => {
-    try {
-      const values = await autoForm.validateFields();
-
-      if (imageFileCount === 0) {
-        message.error(t('dataAnnotation.create.messages.selectAtLeastOneImageFile'));
-        return;
-      }
-
-      setSubmitting(true);
-
-      const selectedFiles = Object.values(selectedFilesMap) as any[];
-
-      // 对于自动标注，后端会根据 fileIds 自动按数据集分组并为每个数据集创建/复用 LS 项目，
-      // 这里不再强制限制只能选择单一数据集，只需保证至少有一个 datasetId，
-      // 否则退回到表单中的 datasetId。
-      const datasetIds = Array.from(
-        new Set(
-          selectedFiles
-            .map((file) => file?.datasetId)
-            .filter((id) => id !== undefined && id !== null && id !== ""),
-        ),
-      );
-
-      const effectiveDatasetId = values.datasetId || datasetIds[0];
-
-      const imageExtensions = [".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff", ".webp"];
-      const imageFileIds = Object.values(selectedFilesMap)
-        .filter((file) => {
-          const ext = file.fileName?.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
-          return imageExtensions.includes(ext);
-        })
-        .map((file) => file.id);
-
-      const payload = {
-        name: values.name,
-        datasetId: effectiveDatasetId,
-        fileIds: imageFileIds,
-        config: {
-          modelSize: values.modelSize,
-          confThreshold: values.confThreshold,
-          targetClasses: selectAllClasses ? [] : values.targetClasses || [],
-        },
-      };
-
-      await createAutoAnnotationTaskUsingPost(payload);
-      message.success(t('dataAnnotation.create.messages.autoCreateSuccess'));
-      setShouldResetOnOpen(true); // 标记下次打开时需要重置
-      // 触发上层刷新自动标注任务列表
-      (onRefresh as any)?.("auto");
-      onClose();
-    } catch (error: any) {
-      if (error.errorFields) return;
-      console.error("Failed to create auto annotation task:", error);
-      message.error(error.message || t('dataAnnotation.create.messages.autoCreateFailed'));
-    } finally {
-      setSubmitting(false);
-    }
-  };
+  // 自动标注提交函数已屏蔽（保留代码在注释中）
+  // const handleAutoSubmit = async () => {
+  //   try {
+  //     const values = await autoForm.validateFields();
+  //     if (imageFileCount === 0) {
+  //       message.error(t('dataAnnotation.create.messages.selectAtLeastOneImageFile'));
+  //       return;
+  //     }
+  //     setSubmitting(true);
+  //     const selectedFiles = Object.values(selectedFilesMap) as any[];
+  //     const datasetIds = Array.from(
+  //       new Set(
+  //         selectedFiles
+  //           .map((file) => file?.datasetId)
+  //           .filter((id) => id !== undefined && id !== null && id !== ""),
+  //       ),
+  //     );
+  //     const effectiveDatasetId = values.datasetId || datasetIds[0];
+  //     const imageExtensions = [".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff", ".webp"];
+  //     const imageFileIds = Object.values(selectedFilesMap)
+  //       .filter((file) => {
+  //         const ext = file.fileName?.toLowerCase().match(/\.[^.]+$/)?.[0] || "";
+  //         return imageExtensions.includes(ext);
+  //       })
+  //       .map((file) => file.id);
+  //     const payload = {
+  //       name: values.name,
+  //       datasetId: effectiveDatasetId,
+  //       fileIds: imageFileIds,
+  //       config: {
+  //         modelSize: values.modelSize,
+  //         confThreshold: values.confThreshold,
+  //         targetClasses: selectAllClasses ? [] : values.targetClasses || [],
+  //       },
+  //     };
+  //     await createAutoAnnotationTaskUsingPost(payload);
+  //     message.success(t('dataAnnotation.create.messages.autoCreateSuccess'));
+  //     setShouldResetOnOpen(true);
+  //     (onRefresh as any)?.("auto");
+  //     onClose();
+  //   } catch (error: any) {
+  //     if (error.errorFields) return;
+  //     console.error("Failed to create auto annotation task:", error);
+  //     message.error(error.message || t('dataAnnotation.create.messages.autoCreateFailed'));
+  //   } finally {
+  //     setSubmitting(false);
+  //   }
+  // };
 
   const handleClassSelectionChange = (checked: boolean) => {
     setSelectAllClasses(checked);
@@ -408,7 +398,7 @@ export default function CreateAnnotationTask({
           </Button>
           <Button
             type="primary"
-            onClick={activeMode === "manual" ? handleManualSubmit : handleAutoSubmit}
+            onClick={handleManualSubmit}
             loading={submitting}
           >
             {t('dataAnnotation.create.ok')}
diff --git a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
index 02cdc4589..3cc42da8c 100644
--- a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
+++ b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
@@ -19,19 +19,21 @@ import {
   deleteAnnotationTaskByIdUsingDelete,
   queryAnnotationTasksUsingGet,
   syncAnnotationTaskUsingPost,
-  queryAutoAnnotationTasksUsingGet,
-  deleteAutoAnnotationTaskByIdUsingDelete,
-  getAutoAnnotationLabelStudioProjectUsingGet,
+  // 自动标注API已屏蔽（保留代码在注释中）
+  // queryAutoAnnotationTasksUsingGet,
+  // deleteAutoAnnotationTaskByIdUsingDelete,
+  // getAutoAnnotationLabelStudioProjectUsingGet,
   loginAnnotationUsingGet,
   syncManualAnnotationToDatabaseUsingPost,
-  syncAutoAnnotationToDatabaseUsingPost,
+  // syncAutoAnnotationToDatabaseUsingPost,
 } from "../annotation.api";
 import { mapAnnotationTask } from "../annotation.const";
 import CreateAnnotationTask from "../Create/components/CreateAnnotationTaskDialog";
 import { ColumnType } from "antd/es/table";
 import { TemplateList } from "../Template";
-import EditAutoAnnotationDatasetDialog from "../AutoAnnotation/components/EditAutoAnnotationDatasetDialog";
-import ImportFromLabelStudioDialog from "../AutoAnnotation/components/ImportFromLabelStudioDialog";
+// 自动标注组件导入已屏蔽（保留代码在注释中）
+// import EditAutoAnnotationDatasetDialog from "../AutoAnnotation/components/EditAutoAnnotationDatasetDialog";
+// import ImportFromLabelStudioDialog from "../AutoAnnotation/components/ImportFromLabelStudioDialog";
 import ManualImportFromLabelStudioDialog from "../ManualImportFromLabelStudioDialog";
 import EditManualAnnotationDatasetDialog from "../EditManualAnnotationDatasetDialog";
 import { useTranslation } from "react-i18next";
@@ -44,7 +46,8 @@ export default function DataAnnotation() {
   const [activeTab, setActiveTab] = useState("tasks");
   const [viewMode, setViewMode] = useState<"list" | "card">("list");
   const [showCreateDialog, setShowCreateDialog] = useState(false);
-  const [autoTasks, setAutoTasks] = useState<any[]>([]);
+  // 自动标注任务state已屏蔽（保留代码在注释中）
+  // const [autoTasks, setAutoTasks] = useState<any[]>([]);
 
   const {
     loading,
@@ -60,30 +63,32 @@ export default function DataAnnotation() {
   const [selectedRowKeys, setSelectedRowKeys] = useState<(string | number)[]>([]);
   const [selectedRows, setSelectedRows] = useState<any[]>([]);
   const [datasetProjectMap, setDatasetProjectMap] = useState<Record<string, string>>({});
-  const [editingAutoTask, setEditingAutoTask] = useState<any | null>(null);
-  const [showEditAutoDatasetDialog, setShowEditAutoDatasetDialog] = useState(false);
+  // 自动标注相关state已屏蔽（保留代码在注释中）
+  // const [editingAutoTask, setEditingAutoTask] = useState<any | null>(null);
+  // const [showEditAutoDatasetDialog, setShowEditAutoDatasetDialog] = useState(false);
   const [editingManualTask, setEditingManualTask] = useState<AnnotationTask | null>(null);
   const [showEditManualDatasetDialog, setShowEditManualDatasetDialog] = useState(false);
-  const [importingAutoTask, setImportingAutoTask] = useState<any | null>(null);
-  const [showImportAutoDialog, setShowImportAutoDialog] = useState(false);
+  // 自动标注相关state已屏蔽（保留代码在注释中）
+  // const [importingAutoTask, setImportingAutoTask] = useState<any | null>(null);
+  // const [showImportAutoDialog, setShowImportAutoDialog] = useState(false);
   const [importingManualTask, setImportingManualTask] = useState<AnnotationTask | null>(null);
   const [showImportManualDialog, setShowImportManualDialog] = useState(false);
 
-  // 拉取自动标注任务（供轮询和创建成功后立即刷新复用）
-  const refreshAutoTasks = async (silent = false) => {
-    try {
-      const response = await queryAutoAnnotationTasksUsingGet();
-      const tasks = (response as any)?.data || response || [];
-      if (Array.isArray(tasks)) {
-        setAutoTasks(tasks);
-      }
-    } catch (error) {
-      console.error("Failed to fetch auto annotation tasks:", error);
-      if (!silent) {
-        message.error(t('dataAnnotation.home.messages.fetchAutoTasksFailed'));
-      }
-    }
-  };
+  // 自动标注任务拉取函数已屏蔽（保留代码在注释中）
+  // const refreshAutoTasks = async (silent = false) => {
+  //   try {
+  //     const response = await queryAutoAnnotationTasksUsingGet();
+  //     const tasks = (response as any)?.data || response || [];
+  //     if (Array.isArray(tasks)) {
+  //       setAutoTasks(tasks);
+  //     }
+  //   } catch (error) {
+  //     console.error("Failed to fetch auto annotation tasks:", error);
+  //     if (!silent) {
+  //       message.error(t('dataAnnotation.home.messages.fetchAutoTasksFailed'));
+  //     }
+  //   }
+  // };
 
   // prefetch config on mount so clicking annotate is fast and we know whether base URL exists
   // useEffect ensures this runs once
@@ -115,15 +120,14 @@ export default function DataAnnotation() {
     setDatasetProjectMap(map);
   }, [tableData]);
 
-  // 自动标注任务轮询（用于在同一表格中展示处理进度）
-  useEffect(() => {
-    refreshAutoTasks();
-    const timer = setInterval(() => refreshAutoTasks(true), 3000);
-
-    return () => {
-      clearInterval(timer);
-    };
-  }, []);
+  // 自动标注任务轮询已屏蔽（保留代码在注释中）
+  // useEffect(() => {
+  //   refreshAutoTasks();
+  //   const timer = setInterval(() => refreshAutoTasks(true), 3000);
+  //   return () => {
+  //     clearInterval(timer);
+  //   };
+  // }, []);
 
   const handleAnnotate = (task: AnnotationTask) => {
     // Open Label Studio project page in a new tab
@@ -192,45 +196,43 @@ export default function DataAnnotation() {
     });
   };
 
-  const handleDeleteAuto = (task: any) => {
-    Modal.confirm({
-      title: t('dataAnnotation.home.confirm.deleteAutoTaskTitle', { name: task.name }),
-      content: <div>{t('dataAnnotation.home.confirm.deleteAutoTaskContent')}</div>,
-      okText: t('dataAnnotation.home.confirm.deleteOkText'),
-      okType: "danger",
-      cancelText: t('dataAnnotation.home.confirm.deleteCancelText'),
-      onOk: async () => {
-        try {
-          await deleteAutoAnnotationTaskByIdUsingDelete(task.id);
-          message.success(t('dataAnnotation.home.messages.autoTaskDeleteSuccess'));
-          // 重新拉取自动标注任务
-          setAutoTasks((prev) => prev.filter((t: any) => t.id !== task.id));
-          // 清理选中
-          setSelectedRowKeys((keys) => keys.filter((k) => k !== task.id));
-          setSelectedRows((rows) => rows.filter((r) => r.id !== task.id));
-        } catch (e) {
-          console.error(e);
-          message.error(t('dataAnnotation.home.messages.deleteFailed'));
-        }
-      },
-    });
-  };
-
-  const handleEditAutoTaskDataset = (row: any) => {
-    if (!row?.id) {
-      message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
-      return;
-    }
-
-    const full = autoTasks.find((t: any) => t.id === row.id);
-    if (!full) {
-      message.error(t('dataAnnotation.home.messages.autoTaskNotFound') + t('dataAnnotation.home.messages.deleteFailed').split('，')[1]);
-      return;
-    }
-
-    setEditingAutoTask(full);
-    setShowEditAutoDatasetDialog(true);
-  };
+  // 自动标注删除函数已屏蔽（保留代码在注释中）
+  // const handleDeleteAuto = (task: any) => {
+  //   Modal.confirm({
+  //     title: t('dataAnnotation.home.confirm.deleteAutoTaskTitle', { name: task.name }),
+  //     content: <div>{t('dataAnnotation.home.confirm.deleteAutoTaskContent')}</div>,
+  //     okText: t('dataAnnotation.home.confirm.deleteOkText'),
+  //     okType: "danger",
+  //     cancelText: t('dataAnnotation.home.confirm.deleteCancelText'),
+  //     onOk: async () => {
+  //       try {
+  //         await deleteAutoAnnotationTaskByIdUsingDelete(task.id);
+  //         message.success(t('dataAnnotation.home.messages.autoTaskDeleteSuccess'));
+  //         setAutoTasks((prev) => prev.filter((t: any) => t.id !== task.id));
+  //         setSelectedRowKeys((keys) => keys.filter((k) => k !== task.id));
+  //         setSelectedRows((rows) => rows.filter((r) => r.id !== task.id));
+  //       } catch (e) {
+  //         console.error(e);
+  //         message.error(t('dataAnnotation.home.messages.deleteFailed'));
+  //       }
+  //     },
+  //   });
+  // };
+
+  // 自动标注编辑数据集函数已屏蔽（保留代码在注释中）
+  // const handleEditAutoTaskDataset = (row: any) => {
+  //   if (!row?.id) {
+  //     message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
+  //     return;
+  //   }
+  //   const full = autoTasks.find((t: any) => t.id === row.id);
+  //   if (!full) {
+  //     message.error(t('dataAnnotation.home.messages.autoTaskNotFound') + t('dataAnnotation.home.messages.deleteFailed').split('，')[1]);
+  //     return;
+  //   }
+  //   setEditingAutoTask(full);
+  //   setShowEditAutoDatasetDialog(true);
+  // };
 
   const handleEditManualTaskDataset = (task: AnnotationTask) => {
     if (!task?.id) {
@@ -282,95 +284,88 @@ export default function DataAnnotation() {
     });
   };
 
-  const handleImportAutoFromLabelStudio = (row: any) => {
-    if (!row?.id) {
-      message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
-      return;
-    }
-
-    const full = autoTasks.find((t: any) => t.id === row.id);
-    if (!full) {
-      message.error(t('dataAnnotation.home.messages.autoTaskNotFound') + t('dataAnnotation.home.messages.deleteFailed').split('，')[1]);
-      return;
-    }
-
-    setImportingAutoTask(full);
-    setShowImportAutoDialog(true);
-  };
-
-  const handleSyncAutoToDatabase = (row: any) => {
-    if (!row?.id) {
-      message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
-      return;
-    }
-
-    Modal.confirm({
-      title: t('dataAnnotation.home.messages.syncToDbTitle', { name: row.name }),
-      content: (
-        <div>
-          <div>{t('dataAnnotation.home.messages.syncToDbContent1')}</div>
-          <div>{t('dataAnnotation.home.messages.syncToDbContent2')}</div>
-        </div>
-      ),
-      okText: t('dataAnnotation.home.actions.syncToDb'),
-      cancelText: t('dataAnnotation.home.confirm.deleteCancelText'),
-      onOk: async () => {
-        const hide = message.loading(t('dataAnnotation.dialogs.syncToDb.loading'), 0);
-        try {
-          await syncAutoAnnotationToDatabaseUsingPost(row.id);
-          hide();
-          message.success(t('dataAnnotation.dialogs.syncToDb.success'));
-        } catch (e) {
-          console.error(e);
-          hide();
-          message.error(t('dataAnnotation.dialogs.syncToDb.fail'));
-        }
-      },
-    });
-  };
-
-  const handleAnnotateAuto = (task: any) => {
-    (async () => {
-      try {
-        if (!labelStudioBase) {
-          message.error(t('dataAnnotation.home.messages.cannotJumpNoBase'));
-          return;
-        }
-
-        let projId: string | undefined;
-
-        try {
-          const resp = await getAutoAnnotationLabelStudioProjectUsingGet(task.id);
-          const data = (resp as any)?.data ?? resp;
-          projId = data?.projectId || data?.labeling_project_id;
-        } catch (e) {
-          console.error("Failed to resolve LS project for auto task", e);
-        }
-
-        // 兼容旧逻辑：若后端未能找到专属项目，则回退到按数据集映射跳转
-        if (!projId) {
-          const datasetId = task.datasetId;
-          if (!datasetId) {
-            message.error(t('dataAnnotation.home.messages.cannotJumpAutoNoDataset'));
-            return;
-          }
-
-          projId = datasetProjectMap[String(datasetId)];
-        }
-
-        if (!projId) {
-          message.error(t('dataAnnotation.home.messages.cannotJumpAutoNoProject'));
-          return;
-        }
-
-        const target = `${labelStudioBase}/projects/${projId}/data`;
-        window.open(target, "_blank");
-      } catch (error) {
-        console.error(error);
-        message.error(t('dataAnnotation.home.messages.cannotJumpError'));
-      }
-    })();
-  };
+  // 自动标注导入函数已屏蔽（保留代码在注释中）
+  // const handleImportAutoFromLabelStudio = (row: any) => {
+  //   if (!row?.id) {
+  //     message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
+  //     return;
+  //   }
+  //   const full = autoTasks.find((t: any) => t.id === row.id);
+  //   if (!full) {
+  //     message.error(t('dataAnnotation.home.messages.autoTaskNotFound') + t('dataAnnotation.home.messages.deleteFailed').split('，')[1]);
+  //     return;
+  //   }
+  //   setImportingAutoTask(full);
+  //   setShowImportAutoDialog(true);
+  // };
+
+  // 自动标注同步到数据库函数已屏蔽（保留代码在注释中）
+  // const handleSyncAutoToDatabase = (row: any) => {
+  //   if (!row?.id) {
+  //     message.error(t('dataAnnotation.home.messages.autoTaskNotFound'));
+  //     return;
+  //   }
+  //   Modal.confirm({
+  //     title: t('dataAnnotation.home.messages.syncToDbTitle', { name: row.name }),
+  //     content: (
+  //       <div>
+  //         <div>{t('dataAnnotation.home.messages.syncToDbContent1')}</div>
+  //         <div>{t('dataAnnotation.home.messages.syncToDbContent2')}</div>
+  //       </div>
+  //     ),
+  //     okText: t('dataAnnotation.home.actions.syncToDb'),
+  //     cancelText: t('dataAnnotation.home.confirm.deleteCancelText'),
+  //     onOk: async () => {
+  //       const hide = message.loading(t('dataAnnotation.dialogs.syncToDb.loading'), 0);
+  //       try {
+  //         await syncAutoAnnotationToDatabaseUsingPost(row.id);
+  //         hide();
+  //         message.success(t('dataAnnotation.dialogs.syncToDb.success'));
+  //       } catch (e) {
+  //         console.error(e);
+  //         hide();
+  //         message.error(t('dataAnnotation.dialogs.syncToDb.fail'));
+  //       }
+  //     },
+  //   });
+  // };
+
+  // 自动标注跳转标注函数已屏蔽（保留代码在注释中）
+  // const handleAnnotateAuto = (task: any) => {
+  //   (async () => {
+  //     try {
+  //       if (!labelStudioBase) {
+  //         message.error(t('dataAnnotation.home.messages.cannotJumpNoBase'));
+  //         return;
+  //       }
+  //       let projId: string | undefined;
+  //       try {
+  //         const resp = await getAutoAnnotationLabelStudioProjectUsingGet(task.id);
+  //         const data = (resp as any)?.data ?? resp;
+  //         projId = data?.projectId || data?.labeling_project_id;
+  //       } catch (e) {
+  //         console.error("Failed to resolve LS project for auto task", e);
+  //       }
+  //       if (!projId) {
+  //         const datasetId = task.datasetId;
+  //         if (!datasetId) {
+  //           message.error(t('dataAnnotation.home.messages.cannotJumpAutoNoDataset'));
+  //           return;
+  //         }
+  //         projId = datasetProjectMap[String(datasetId)];
+  //       }
+  //       if (!projId) {
+  //         message.error(t('dataAnnotation.home.messages.cannotJumpAutoNoProject'));
+  //         return;
+  //       }
+  //       const target = `${labelStudioBase}/projects/${projId}/data`;
+  //       window.open(target, "_blank");
+  //     } catch (error) {
+  //       console.error(error);
+  //       message.error(t('dataAnnotation.home.messages.cannotJumpError'));
+  //     }
+  //   })();
+  // };
 
   const handleSync = (task: AnnotationTask, batchSize: number = 50) => {
     Modal.confirm({
@@ -437,7 +432,8 @@ export default function DataAnnotation() {
   const handleBatchDelete = () => {
     if (!selectedRows || selectedRows.length === 0) return;
     const manualRows = selectedRows.filter((r) => r._kind !== "auto");
-    const autoRows = selectedRows.filter((r) => r._kind === "auto");
+    // 自动标注批量删除已屏蔽
+    // const autoRows = selectedRows.filter((r) => r._kind === "auto");
     Modal.confirm({
       title: t('dataAnnotation.home.confirm.batchDeleteTitle', { count: selectedRows.length }),
       content: (
@@ -454,7 +450,8 @@ export default function DataAnnotation() {
           await Promise.all(
             [
               ...manualRows.map((r) => deleteAnnotationTaskByIdUsingDelete(r.id)),
-              ...autoRows.map((r) => deleteAutoAnnotationTaskByIdUsingDelete(r.id)),
+              // 自动标注批量删除已屏蔽
+              // ...autoRows.map((r) => deleteAutoAnnotationTaskByIdUsingDelete(r.id)),
             ]
           );
           message.success(t('dataAnnotation.home.messages.batchDeleteSuccess'));
@@ -510,38 +507,35 @@ export default function DataAnnotation() {
   });
 
   // 自动标注功能已屏蔽：仅显示手动标注任务
-  const mergedTableData = [
-    // 手动标注任务（过滤掉自动生成的映射任务）
-    ...manualVisibleTasks.map((task) => ({
+  // 自动标注任务合并逻辑已屏蔽（保留代码在注释中，需要恢复时可取消注释）
+  // ...autoTasks.map((task: any) => {
+  //   const sourceList = Array.isArray(task.sourceDatasets)
+  //     ? task.sourceDatasets
+  //     : task.datasetName
+  //     ? [task.datasetName]
+  //     : [];
+  //   const datasetName = sourceList.length > 0 ? sourceList.join("，") : "-";
+  //   return {
+  //     id: task.id,
+  //     name: task.name,
+  //     datasetId: task.datasetId || task.dataset_id,
+  //     datasetName,
+  //     createdAt: task.createdAt || "-",
+  //     updatedAt: task.updatedAt || "-",
+  //     _kind: "auto" as const,
+  //     autoStatus: task.status,
+  //     autoProgress: task.progress,
+  //     autoProcessedImages: task.processedImages,
+  //     autoTotalImages: task.totalImages,
+  //     autoDetectedObjects: task.detectedObjects,
+  //     autoConfig: task.config || {},
+  //   };
+  // }),
+
+  const mergedTableData: any[] = manualVisibleTasks.map((task: any) => ({
       ...task,
       _kind: "manual" as const,
-    })),
-    // 自动标注任务已屏蔽（代码保留在下方注释中，需要恢复时可取消注释）
-    // ...autoTasks.map((task: any) => {
-    //   const sourceList = Array.isArray(task.sourceDatasets)
-    //     ? task.sourceDatasets
-    //     : task.datasetName
-    //     ? [task.datasetName]
-    //     : [];
-    //   const datasetName = sourceList.length > 0 ? sourceList.join("，") : "-";
-    // 
-    //   return {
-    //     id: task.id,
-    //     name: task.name,
-    //     datasetId: task.datasetId || task.dataset_id,
-    //     datasetName,
-    //     createdAt: task.createdAt || "-",
-    //     updatedAt: task.updatedAt || "-",
-    //     _kind: "auto" as const,
-    //     autoStatus: task.status,
-    //     autoProgress: task.progress,
-    //     autoProcessedImages: task.processedImages,
-    //     autoTotalImages: task.totalImages,
-    //     autoDetectedObjects: task.detectedObjects,
-    //     autoConfig: task.config || {},
-    //   };
-    // }),
-  ];
+    }));
 
   const columns: ColumnType<any>[] = [
     {
@@ -878,7 +872,7 @@ export default function DataAnnotation() {
                   </Card>
                 ) : (
                   <CardView
-                    data={tableData}
+                    data={tableData as any[]}
                     operations={operations as any}
                     pagination={pagination}
                     loading={loading}
@@ -888,13 +882,13 @@ export default function DataAnnotation() {
                 <CreateAnnotationTask
                   open={showCreateDialog}
                   onClose={() => setShowCreateDialog(false)}
-                  onRefresh={(mode?: any) => {
+                  onRefresh={() => {
                     // 手动标注创建成功后刷新标注任务列表
                     fetchData();
-                    // 自动标注创建成功后立即刷新自动标注任务列表
-                    if (mode === "auto") {
-                      refreshAutoTasks(true);
-                    }
+                    // 自动标注创建成功后刷新已屏蔽
+                    // if (mode === "auto") {
+                    //   refreshAutoTasks(true);
+                    // }
                   }}
                 />
               </div>
@@ -908,7 +902,6 @@ export default function DataAnnotation() {
         ]}
       />
 
-      {/* 自动标注对话框已屏蔽（保留代码在注释中） */}
       {/* {editingAutoTask && (
         <EditAutoAnnotationDatasetDialog
           visible={showEditAutoDatasetDialog}
@@ -920,7 +913,7 @@ export default function DataAnnotation() {
           onSuccess={() => {
             setShowEditAutoDatasetDialog(false);
             setEditingAutoTask(null);
-            refreshAutoTasks();
+            // refreshAutoTasks();
           }}
         />
       )} */}