From 5b5e6373ad6da2e998e6729b446aeb5f8fd86b35 Mon Sep 17 00:00:00 2001
From: o0Shark0o <1191322051@qq.com>
Date: Tue, 27 Jan 2026 17:14:36 +0800
Subject: [PATCH] feat(annotation): simplify task creation and streamline sync
 workflow

---
 .../business/DatasetFileTransfer.tsx          | 171 ++++++-
 .../AutoAnnotation/AutoAnnotation.tsx         |  54 +-
 .../components/CreateAutoAnnotationDialog.tsx |   5 +-
 .../EditAutoAnnotationDatasetDialog.tsx       |   2 +
 .../ImportFromLabelStudioDialog.tsx           |  50 +-
 .../components/CreateAnnotationTaskDialog.tsx | 178 ++++---
 .../EditManualAnnotationDatasetDialog.tsx     |   4 +-
 .../DataAnnotation/Home/DataAnnotation.tsx    |  54 +-
 .../ManualImportFromLabelStudioDialog.tsx     |  50 +-
 .../pages/DataAnnotation/annotation.api.ts    |   4 +-
 .../app/module/annotation/interface/auto.py   |   7 +-
 .../module/annotation/interface/project.py    |   7 +-
 .../app/module/annotation/schema/auto.py      |  14 +-
 .../app/module/dataset/service/service.py     |  78 +++
 .../process.py                                |  13 +-
 .../datamate/auto_annotation_worker.py        | 478 +++++++++---------
 16 files changed, 638 insertions(+), 531 deletions(-)

diff --git a/frontend/src/components/business/DatasetFileTransfer.tsx b/frontend/src/components/business/DatasetFileTransfer.tsx
index 08aa64cbd..22bfce16b 100644
--- a/frontend/src/components/business/DatasetFileTransfer.tsx
+++ b/frontend/src/components/business/DatasetFileTransfer.tsx
@@ -21,6 +21,18 @@ interface DatasetFileTransferProps
   onSelectedFilesChange: (filesMap: { [key: string]: DatasetFile }) => void;
   onDatasetSelect?: (dataset: Dataset | null) => void;
   datasetTypeFilter?: DatasetType;
+  /**
+   * 是否强制“单数据集模式”：
+   * - 为 true 时，仅允许从同一个数据集选择文件；
+   * - 当已选文件来自某个数据集时，尝试从其他数据集勾选文件会被阻止并提示。
+   */
+  singleDatasetOnly?: boolean;
+  /**
+   * 固定可选数据集 ID：
+   * - 设置后，左侧数据集列表只展示该数据集；
+   * - 主要用于“编辑任务数据集”场景，锁定为任务创建时的数据集。
+   */
+  fixedDatasetId?: string | number;
   /**
    * 锁定的文件ID集合：
    * - 在左侧文件列表中，这些文件的勾选框会变成灰色且不可交互；
@@ -28,6 +40,12 @@ interface DatasetFileTransferProps
    * - 主要用于“编辑任务数据集”场景下锁死任务初始文件。
    */
   lockedFileIds?: string[];
+  /**
+   * 整体禁用开关：
+   * - 为 true 时，禁止切换数据集和选择文件，仅用于展示当前配置；
+   * - 可配合上层逻辑（如“需先选模板再选数据集”）使用。
+   */
+  disabled?: boolean;
 }
 
 const fileCols = [
@@ -59,7 +77,10 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
   onSelectedFilesChange,
   onDatasetSelect,
   datasetTypeFilter,
+  singleDatasetOnly,
+  fixedDatasetId,
   lockedFileIds,
+  disabled,
   ...props
 }) => {
   const [datasets, setDatasets] = React.useState<Dataset[]>([]);
@@ -91,19 +112,49 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
     return new Set((lockedFileIds || []).map((id) => String(id)));
   }, [lockedFileIds]);
 
+  // 在单数据集模式下，根据已选文件反推“当前锁定的数据集ID”
+  const lockedDatasetId = React.useMemo(() => {
+    if (!singleDatasetOnly) return undefined;
+    const ids = new Set(
+      Object.values(selectedFilesMap)
+        .map((file: any) => file?.datasetId)
+        .filter((id) => id !== undefined && id !== null && id !== "")
+        .map((id) => String(id))
+    );
+    if (ids.size === 1) {
+      return Array.from(ids)[0];
+    }
+    return undefined;
+  }, [singleDatasetOnly, selectedFilesMap]);
+
   const fetchDatasets = async () => {
     const { data } = await queryDatasetsUsingGet({
       // Ant Design Table pagination.current is 1-based; ensure backend also receives 1-based value
       page: datasetPagination.current,
       size: datasetPagination.pageSize,
       keyword: datasetSearch,
-      // 仅在显式传入过滤类型时才按类型过滤；否则后端返回所有类型
+      // 后端在大多数环境下支持按 type 过滤；若未生效，前端仍会基于 datasetTypeFilter 再做一次兜底筛选
       type: datasetTypeFilter,
     });
-    setDatasets(data.content.map(mapDataset) || []);
+
+    let mapped: any[] = (data.content || []).map(mapDataset);
+
+    // 兜底：在前端再按 datasetTypeFilter 过滤一次，确保只展示指定类型的数据集
+    if (datasetTypeFilter) {
+      mapped = mapped.filter(
+        (ds: any) => ds.datasetType === datasetTypeFilter
+      );
+    }
+
+    const filtered =
+      fixedDatasetId !== undefined && fixedDatasetId !== null
+        ? mapped.filter((ds: Dataset) => String(ds.id) === String(fixedDatasetId))
+        : mapped;
+
+    setDatasets(filtered);
     setDatasetPagination((prev) => ({
       ...prev,
-      total: data.totalElements,
+      total: filtered.length,
     }));
   };
 
@@ -111,7 +162,7 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
     () => {
       fetchDatasets();
     },
-    [datasetSearch, datasetPagination.pageSize, datasetPagination.current],
+    [datasetSearch, datasetPagination.pageSize, datasetPagination.current, datasetTypeFilter],
     300
   );
 
@@ -170,12 +221,40 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
     onDatasetSelect?.(selectedDataset);
   }, [selectedDataset, onDatasetSelect]);
 
+  // 在 fixedDatasetId 场景下，数据集列表加载完成后自动选中该数据集
+  useEffect(() => {
+    if (!open) return;
+    if (fixedDatasetId === undefined || fixedDatasetId === null) return;
+    if (selectedDataset) return;
+    if (!datasets.length) return;
+
+    const target = datasets.find((ds) => String(ds.id) === String(fixedDatasetId));
+    if (target) {
+      setSelectedDataset(target);
+    }
+  }, [open, fixedDatasetId, datasets, selectedDataset]);
+
   const handleSelectAllInDataset = useCallback(async () => {
     if (!selectedDataset) {
       message.warning("请先选择一个数据集");
       return;
     }
 
+    // 单数据集模式下，如果当前已选文件来自其他数据集，则阻止一键全选
+    if (singleDatasetOnly) {
+      const existingIds = new Set(
+        Object.values(selectedFilesMap)
+          .map((file: any) => file?.datasetId)
+          .filter((id) => id !== undefined && id !== null && id !== "")
+          .map((id) => String(id)),
+      );
+      const currentId = String(selectedDataset.id);
+      if (existingIds.size > 0 && (!existingIds.has(currentId) || existingIds.size > 1)) {
+        message.warning("当前仅支持从一个数据集选择文件，请先清空已选文件后再切换数据集");
+        return;
+      }
+    }
+
     try {
       setSelectingAll(true);
 
@@ -246,6 +325,23 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
     if (lockedIdSet.has(String(record.id))) {
       return;
     }
+
+    // 单数据集模式：禁止从多个数据集混选文件
+    if (singleDatasetOnly && !selectedFilesMap[record.id]) {
+      const recordDatasetId = (record as any).datasetId;
+      const existingIds = new Set(
+        Object.values(selectedFilesMap)
+          .map((file: any) => file?.datasetId)
+          .filter((id) => id !== undefined && id !== null && id !== "")
+          .map((id) => String(id)),
+      );
+      const recId = recordDatasetId !== undefined && recordDatasetId !== null ? String(recordDatasetId) : undefined;
+      if (existingIds.size > 0 && recId && !existingIds.has(recId)) {
+        message.warning("当前仅支持从一个数据集选择文件，请先清空已选文件后再切换数据集");
+        return;
+      }
+    }
+
     if (!selectedFilesMap[record.id]) {
       onSelectedFilesChange({
         ...selectedFilesMap,
@@ -321,28 +417,52 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
               placeholder="搜索数据集名称..."
               value={datasetSearch}
               allowClear
-              onChange={(e) => setDatasetSearch(e.target.value)}
+              onChange={(e) => !disabled && setDatasetSearch(e.target.value)}
+              disabled={disabled}
             />
           </div>
           <Table
             scroll={{ y: 400 }}
             rowKey="id"
             size="small"
-            rowClassName={(record) =>
-              `cursor-pointer ${
-                selectedDataset?.id === record.id ? "bg-blue-100" : ""
-              }`
-            }
+            rowClassName={(record) => {
+              const isActive = selectedDataset?.id === record.id;
+              const hasSelection = Object.keys(selectedFilesMap).length > 0;
+              const isLockedOtherDataset =
+                !!singleDatasetOnly &&
+                !!lockedDatasetId &&
+                hasSelection &&
+                String(record.id) !== lockedDatasetId;
+              return `cursor-pointer ${
+                isActive ? "bg-blue-100" : ""
+              } ${isLockedOtherDataset ? "text-gray-400 cursor-not-allowed" : ""}`;
+            }}
             onRow={(record: Dataset) => ({
               onClick: () => {
-                setSelectedDataset(record);
-                if (!datasetSelections.find((d) => d.id === record.id)) {
-                  setDatasetSelections([...datasetSelections, record]);
-                } else {
-                  setDatasetSelections(
-                    datasetSelections.filter((d) => d.id !== record.id)
-                  );
-                }
+                  if (disabled) return;
+
+                  // 单数据集模式：当已有选中文件且尝试切换到其他数据集时，直接提示并阻止切换
+                  const hasSelection =
+                    singleDatasetOnly &&
+                    Object.keys(selectedFilesMap).length > 0 &&
+                    !!lockedDatasetId;
+                  if (
+                    hasSelection &&
+                    String(record.id) !== String(lockedDatasetId)
+                  ) {
+                    message.warning(
+                      "当前仅支持从一个数据集选择文件，请先清空已选文件后再切换数据集"
+                    );
+                    return;
+                  }
+                  setSelectedDataset(record);
+                  if (!datasetSelections.find((d) => d.id === record.id)) {
+                    setDatasetSelections([...datasetSelections, record]);
+                  } else {
+                    setDatasetSelections(
+                      datasetSelections.filter((d) => d.id !== record.id)
+                    );
+                  }
               },
             })}
             dataSource={datasets}
@@ -350,6 +470,7 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
             pagination={{
                 ...datasetPagination,
                 onChange: (page, pageSize) =>
+                    !disabled &&
                     setDatasetPagination({
                         current: page,
                         pageSize: pageSize || datasetPagination.pageSize,
@@ -365,8 +486,8 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
             <Button
               type="link"
               size="small"
-              onClick={handleSelectAllInDataset}
-              disabled={!selectedDataset}
+              onClick={() => !disabled && handleSelectAllInDataset()}
+              disabled={!selectedDataset || !!disabled}
               loading={selectingAll}
             >
               全选当前数据集
@@ -388,6 +509,7 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
             pagination={{
               ...filesPagination,
               onChange: (page, pageSize) => {
+                  if (disabled) return;
                 const nextPageSize = pageSize || filesPagination.pageSize;
                 setFilesPagination((prev) => ({
                   ...prev,
@@ -399,7 +521,10 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
               },
             }}
             onRow={(record: DatasetFile) => ({
-              onClick: () => toggleSelectFile(record),
+              onClick: () => {
+                if (disabled) return;
+                toggleSelectFile(record);
+              },
             })}
             rowSelection={{
               type: "checkbox",
@@ -408,11 +533,13 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
 
               // 单选
               onSelect: (record: DatasetFile) => {
+                if (disabled) return;
                 toggleSelectFile(record);
               },
 
               // 全选 - 改为全选整个数据集而不是当前页
               onSelectAll: (selected, selectedRows: DatasetFile[]) => {
+                if (disabled) return;
                 if (selected) {
                   // 点击表头“全选”时，改为一键全选当前数据集的全部文件
                   // 而不是只选中当前页
@@ -437,7 +564,7 @@ const DatasetFileTransfer: React.FC<DatasetFileTransferProps> = ({
 
               getCheckboxProps: (record: DatasetFile) => ({
                 name: record.fileName,
-                disabled: lockedIdSet.has(String(record.id)),
+                disabled: !!disabled || lockedIdSet.has(String(record.id)),
               }),
             }}
           />
diff --git a/frontend/src/pages/DataAnnotation/AutoAnnotation/AutoAnnotation.tsx b/frontend/src/pages/DataAnnotation/AutoAnnotation/AutoAnnotation.tsx
index 589ca4ff7..8de4d190e 100644
--- a/frontend/src/pages/DataAnnotation/AutoAnnotation/AutoAnnotation.tsx
+++ b/frontend/src/pages/DataAnnotation/AutoAnnotation/AutoAnnotation.tsx
@@ -9,8 +9,7 @@ import {
 	EditOutlined,
 	MoreOutlined,
 	SettingOutlined,
-	ExportOutlined,
-	ImportOutlined,
+	SyncOutlined,
 } from "@ant-design/icons";
 import type { ColumnType } from "antd/es/table";
 import type { AutoAnnotationTask, AutoAnnotationStatus } from "../annotation.model";
@@ -18,8 +17,7 @@ import {
 	queryAutoAnnotationTasksUsingGet,
 	deleteAutoAnnotationTaskByIdUsingDelete,
 	downloadAutoAnnotationResultUsingGet,
-  queryAnnotationTasksUsingGet,
-  syncAutoAnnotationTaskToLabelStudioUsingPost,
+	queryAnnotationTasksUsingGet,
 } from "../annotation.api";
 import CreateAutoAnnotationDialog from "./components/CreateAutoAnnotationDialog";
 import EditAutoAnnotationDatasetDialog from "./components/EditAutoAnnotationDatasetDialog";
@@ -159,34 +157,6 @@ export default function AutoAnnotation() {
 		}
 	};
 
-	const handleSyncToLabelStudio = (task: AutoAnnotationTask) => {
-		if (task.status !== "completed") {
-			message.warning("仅已完成的任务可以同步到 Label Studio");
-			return;
-		}
-
-		Modal.confirm({
-			title: `确认同步自动标注任务「${task.name}」到 Label Studio 吗？`,
-			content: (
-				<div>
-					<div>将把该任务的检测结果作为预测框写入 Label Studio。</div>
-					<div>不会覆盖已有人工标注，仅作为可编辑的预测结果。</div>
-				</div>
-			),
-			okText: "同步",
-			cancelText: "取消",
-			onOk: async () => {
-				try {
-					await syncAutoAnnotationTaskToLabelStudioUsingPost(task.id);
-					message.success("同步请求已发送");
-				} catch (error) {
-					console.error(error);
-					message.error("同步失败，请稍后重试");
-				}
-			},
-		});
-	};
-
 	const handleAnnotate = (task: AutoAnnotationTask) => {
 		const datasetId = task.datasetId;
 		if (!datasetId) {
@@ -322,21 +292,11 @@ export default function AutoAnnotation() {
 		{
 			title: "操作",
 			key: "actions",
-			width: 320,
+			width: 300,
 			fixed: "right",
 			render: (_: any, record: AutoAnnotationTask) => (
 				<Space size="small">
-					{/* 一级功能菜单：前向同步 + 编辑（跳转 Label Studio） */}
-					<Tooltip title="将 YOLO 预测结果前向同步到 Label Studio">
-						<Button
-							type="link"
-							size="small"
-							icon={<ExportOutlined />}
-							onClick={() => handleSyncToLabelStudio(record)}
-						>
-							前向同步
-						</Button>
-					</Tooltip>
+					{/* 一级功能：编辑（跳转 Label Studio） + 同步（导回结果） */}
 					<Tooltip title="在 Label Studio 中手动标注">
 						<Button
 							type="link"
@@ -347,14 +307,14 @@ export default function AutoAnnotation() {
 							编辑
 						</Button>
 					</Tooltip>
-					<Tooltip title="从 Label Studio 导回标注结果到数据集">
+					<Tooltip title="从 Label Studio 同步标注结果到数据集">
 						<Button
 							type="link"
 							size="small"
-							icon={<ImportOutlined />}
+							icon={<SyncOutlined />}
 							onClick={() => handleImportFromLabelStudio(record)}
 						>
-							后向同步
+							同步
 						</Button>
 					</Tooltip>
 
diff --git a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/CreateAutoAnnotationDialog.tsx b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/CreateAutoAnnotationDialog.tsx
index b3f867a04..057e7a411 100644
--- a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/CreateAutoAnnotationDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/CreateAutoAnnotationDialog.tsx
@@ -188,7 +188,6 @@ export default function CreateAutoAnnotationDialog({
 					modelSize: values.modelSize,
 					confThreshold: values.confThreshold,
 					targetClasses: selectAllClasses ? [] : values.targetClasses || [],
-					outputDatasetName: values.outputDatasetName || undefined,
 				},
 			};
 
@@ -243,6 +242,7 @@ export default function CreateAutoAnnotationDialog({
 							form.setFieldsValue({ datasetId: dataset?.id ?? "" });
 						}}
 						datasetTypeFilter={DatasetType.IMAGE}
+						singleDatasetOnly
 					/>
 					{selectedDataset && (
 						<div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
@@ -291,9 +291,6 @@ export default function CreateAutoAnnotationDialog({
 					)}
 				</Form.Item>
 
-				<Form.Item name="outputDatasetName" label="输出数据集名称 (可选)">
-					<Input placeholder="留空则将结果写入原数据集的标签中" />
-				</Form.Item>
 			</Form>
 		</Modal>
 	);
diff --git a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/EditAutoAnnotationDatasetDialog.tsx b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/EditAutoAnnotationDatasetDialog.tsx
index 609dd0f60..4a3fa61ff 100644
--- a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/EditAutoAnnotationDatasetDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/EditAutoAnnotationDatasetDialog.tsx
@@ -186,6 +186,8 @@ export default function EditAutoAnnotationDatasetDialog({
               setSelectedDataset(dataset);
             }}
             datasetTypeFilter={DatasetType.IMAGE}
+            singleDatasetOnly
+            fixedDatasetId={task.datasetId}
             lockedFileIds={Array.from(initialFileIds)}
           />
           {selectedDataset && (
diff --git a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/ImportFromLabelStudioDialog.tsx b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/ImportFromLabelStudioDialog.tsx
index ac9a2a0b6..402643cdc 100644
--- a/frontend/src/pages/DataAnnotation/AutoAnnotation/components/ImportFromLabelStudioDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/AutoAnnotation/components/ImportFromLabelStudioDialog.tsx
@@ -1,8 +1,6 @@
 import { useEffect, useState } from "react";
 import { Modal, Form, Select, Input, message } from "antd";
 import type { AutoAnnotationTask } from "../../annotation.model";
-import { queryDatasetsUsingGet } from "@/pages/DataManagement/dataset.api";
-import type { Dataset } from "@/pages/DataManagement/dataset.model";
 import { importAutoAnnotationFromLabelStudioUsingPost } from "../../annotation.api";
 
 interface ImportFromLabelStudioDialogProps {
@@ -29,39 +27,12 @@ export default function ImportFromLabelStudioDialog({
   onSuccess,
 }: ImportFromLabelStudioDialogProps) {
   const [form] = Form.useForm();
-  const [datasets, setDatasets] = useState<Dataset[]>([]);
   const [loading, setLoading] = useState(false);
 
-  useEffect(() => {
-    if (!visible) return;
-
-    let cancelled = false;
-
-    (async () => {
-      try {
-        const resp: any = await queryDatasetsUsingGet({ page: 0, size: 1000 });
-        const list: Dataset[] = resp?.content || resp?.data?.content || resp?.data || resp || [];
-        if (!cancelled && Array.isArray(list)) {
-          setDatasets(list);
-        }
-      } catch (e) {
-        console.error("Failed to fetch datasets for LS import:", e);
-        if (!cancelled) {
-          message.error("获取数据集列表失败");
-        }
-      }
-    })();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [visible]);
-
   useEffect(() => {
     if (visible && task) {
       // 默认选中任务原始数据集和 JSON 导出格式
       form.setFieldsValue({
-        targetDatasetId: task.datasetId,
         exportFormat: "JSON",
       });
     }
@@ -70,7 +41,6 @@ export default function ImportFromLabelStudioDialog({
   const handleOk = async () => {
     try {
       const values = await form.validateFields();
-      const targetDatasetId: string = values.targetDatasetId;
       const exportFormat: string = values.exportFormat;
       const fileName: string | undefined = values.fileName;
 
@@ -81,7 +51,6 @@ export default function ImportFromLabelStudioDialog({
 
       setLoading(true);
       await importAutoAnnotationFromLabelStudioUsingPost(task.id, {
-        targetDatasetId,
         exportFormat,
         // 后端会自动附加正确的扩展名
         fileName: fileName?.trim() || undefined,
@@ -115,22 +84,6 @@ export default function ImportFromLabelStudioDialog({
           <span>{task?.name || "-"}</span>
         </Form.Item>
 
-        <Form.Item
-          label="导入目标数据集"
-          name="targetDatasetId"
-          rules={[{ required: true, message: "请选择目标数据集" }]}
-        >
-          <Select
-            placeholder="请选择要导入到的数据集"
-            optionFilterProp="label"
-            showSearch
-            options={datasets.map((ds) => ({
-              label: ds.name,
-              value: ds.id,
-            }))}
-          />
-        </Form.Item>
-
         <Form.Item
           label="导出/导入格式"
           name="exportFormat"
@@ -155,7 +108,8 @@ export default function ImportFromLabelStudioDialog({
 
         <div className="text-xs text-gray-500 mt-2">
           将从与该自动标注任务关联的 Label Studio 项目中，
-          按所选格式导出完整标注结果，并作为一个文件保存到所选数据集中。
+          按所选格式导出完整标注结果，并作为一个文件保存到源数据集下的
+          <span className="font-semibold">「标注数据」</span> 文件夹中。
           不会修改已有标签，仅追加一个导出工件文件。
         </div>
       </Form>
diff --git a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
index 45cc8acaf..cc389ecfc 100644
--- a/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx
@@ -11,6 +11,7 @@ import {
 import DatasetFileTransfer from "@/components/business/DatasetFileTransfer";
 import { DatasetType, type Dataset, type DatasetFile } from "@/pages/DataManagement/dataset.model";
 import type { AnnotationTemplate } from "../../annotation.model";
+import { DataType } from "../../annotation.model";
 
 const { Option } = Select;
 
@@ -118,6 +119,7 @@ export default function CreateAnnotationTask({
   const [selectedFilesMap, setSelectedFilesMap] = useState<Record<string, DatasetFile>>({});
   const [selectedDataset, setSelectedDataset] = useState<Dataset | null>(null);
   const [imageFileCount, setImageFileCount] = useState(0);
+  const [manualDatasetTypeFilter, setManualDatasetTypeFilter] = useState<DatasetType | undefined>(undefined);
 
   useEffect(() => {
     if (!open) return;
@@ -176,6 +178,46 @@ export default function CreateAnnotationTask({
     setImageFileCount(count);
   }, [selectedFilesMap]);
 
+  const mapTemplateDataTypeToDatasetType = (raw?: string): DatasetType | undefined => {
+    if (!raw) return undefined;
+    const v = String(raw).trim().toLowerCase();
+
+    // 兼容多种表示方式：
+    // - 英文大写/小写：IMAGE / image / Text / TEXT
+    // - 后端枚举 DataType：text / image / audio / video
+    // - 中文展示文案：图像 / 文本 / 音频 / 视频
+    // - 少量常见别称：图片 等
+
+    const textTokens = new Set([
+      "text",
+      DataType.TEXT.toLowerCase(),
+      "文本",
+    ]);
+    const imageTokens = new Set([
+      "image",
+      DataType.IMAGE.toLowerCase(),
+      "图像",
+      "图片",
+    ]);
+    const audioTokens = new Set([
+      "audio",
+      DataType.AUDIO.toLowerCase(),
+      "音频",
+    ]);
+    const videoTokens = new Set([
+      "video",
+      DataType.VIDEO.toLowerCase(),
+      "视频",
+    ]);
+
+    if (textTokens.has(v)) return DatasetType.TEXT;
+    if (imageTokens.has(v)) return DatasetType.IMAGE;
+    if (audioTokens.has(v)) return DatasetType.AUDIO;
+    if (videoTokens.has(v)) return DatasetType.VIDEO;
+
+    return undefined;
+  };
+
   const handleManualSubmit = async () => {
     try {
       const values = await manualForm.validateFields();
@@ -263,7 +305,6 @@ export default function CreateAnnotationTask({
           modelSize: values.modelSize,
           confThreshold: values.confThreshold,
           targetClasses: selectAllClasses ? [] : values.targetClasses || [],
-          outputDatasetName: values.outputDatasetName || undefined,
         },
       };
 
@@ -318,50 +359,13 @@ export default function CreateAnnotationTask({
             label: "手动标注",
             children: (
               <Form form={manualForm} layout="vertical">
-                {/* 选择数据集和文件（支持多数据集、多文件） */}
-                <Form.Item label="选择数据集和文件" required>
-                  <DatasetFileTransfer
-                    open
-                    selectedFilesMap={selectedFilesMap}
-                    onSelectedFilesChange={setSelectedFilesMap}
-                    onDatasetSelect={(dataset) => {
-                      setSelectedDataset(dataset as Dataset | null);
-                      // 将当前数据集写入隐藏字段，作为主数据集ID
-                      manualForm.setFieldsValue({ datasetId: dataset?.id ?? "" });
-
-                      // 如果用户未手动修改名称，则用当前数据集名称作为默认任务名
-                      if (!nameManuallyEdited && dataset) {
-                        let defaultName = dataset.name || "";
-                        if (defaultName.length < 3) {
-                          defaultName = `${defaultName}-标注`;
-                        }
-                        manualForm.setFieldsValue({ name: defaultName });
-                      }
-                    }}
-                  />
-                  {selectedDataset && (
-                    <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
-                      当前数据集：<span className="font-medium">{selectedDataset.name}</span> - 已选择
-                      <span className="font-medium text-blue-600"> {Object.keys(selectedFilesMap).length} </span>个文件
-                    </div>
-                  )}
-                </Form.Item>
-
-                {/* 隐藏的主数据集ID，用于后端兼容老字段 */}
-                <Form.Item
-                  hidden
-                  name="datasetId"
-                  rules={[{ required: true, message: "请选择数据集" }]}
-                >
-                  <Input type="hidden" />
-                </Form.Item>
-
-                {/* 标注工程名称 */}
+                {/* 任务名称放在第一行，必填 */}
                 <Form.Item
-                  label="标注工程名称"
+                  label="任务名称"
                   name="name"
                   rules={[
                     {
+                      required: true,
                       validator: (_rule, value) => {
                         const trimmed = (value || "").trim();
                         if (!trimmed) {
@@ -378,16 +382,12 @@ export default function CreateAnnotationTask({
                   ]}
                 >
                   <Input
-                    placeholder="输入标注工程名称"
+                    placeholder="请输入任务名称"
                     onChange={() => setNameManuallyEdited(true)}
                   />
                 </Form.Item>
-                {/* 描述变为可选 */}
-                <Form.Item label="描述" name="description">
-                  <TextArea placeholder="（可选）详细描述标注任务的要求和目标" rows={3} />
-                </Form.Item>
 
-                {/* 标注模板选择 */}
+                {/* 第二行：先选模板，再选数据集，模板的数据类型驱动可选数据集类型 */}
                 <Form.Item
                   label="标注模板"
                   name="templateId"
@@ -398,12 +398,33 @@ export default function CreateAnnotationTask({
                     showSearch
                     optionFilterProp="label"
                     notFoundContent={templates.length === 0 ? "暂无模板，请前往「标注模板」页面创建" : "未找到匹配的模板"}
-                    options={templates.map((template) => ({
-                      label: template.name,
-                      value: template.id,
-                      // Add description as subtitle
-                      title: template.description,
-                    }))}
+                    options={templates
+                      .filter((template) => {
+                        const tplType = mapTemplateDataTypeToDatasetType(template.dataType);
+                        if (!selectedDataset || !selectedDataset.datasetType) return true;
+                        if (!tplType) return true;
+                        return tplType === selectedDataset.datasetType;
+                      })
+                      .map((template) => ({
+                        label: template.name,
+                        value: template.id,
+                        title: template.description,
+                      }))}
+                    onChange={(value) => {
+                      manualForm.setFieldsValue({ templateId: value });
+
+                      const tpl = templates.find((t) => t.id === value);
+                      const nextType = mapTemplateDataTypeToDatasetType(tpl?.dataType);
+                      setManualDatasetTypeFilter(nextType);
+
+                      // 若当前已选数据集类型与模板不匹配，则清空当前选择
+                      if (selectedDataset && nextType && selectedDataset.datasetType !== nextType) {
+                        setSelectedDataset(null);
+                        setSelectedFilesMap({});
+                        manualForm.setFieldsValue({ datasetId: "" });
+                        message.warning("已根据模板类型筛选数据集，请重新选择数据集和文件");
+                      }
+                    }}
                     optionRender={(option) => (
                       <div>
                         <div style={{ fontWeight: 500 }}>{option.label}</div>
@@ -416,6 +437,51 @@ export default function CreateAnnotationTask({
                     )}
                   />
                 </Form.Item>
+
+                {/* 选择数据集和文件（仅允许单一数据集，多文件），需先选模板再操作 */}
+                <Form.Item label="选择数据集和文件" required>
+                  <DatasetFileTransfer
+                    open
+                    selectedFilesMap={selectedFilesMap}
+                    onSelectedFilesChange={setSelectedFilesMap}
+                    onDatasetSelect={(dataset) => {
+                      setSelectedDataset(dataset as Dataset | null);
+                      // 将当前数据集写入隐藏字段，作为主数据集ID
+                      manualForm.setFieldsValue({ datasetId: dataset?.id ?? "" });
+
+                      // 如果用户未手动修改名称，则用当前数据集名称作为默认任务名
+                      if (!nameManuallyEdited && dataset) {
+                        let defaultName = dataset.name || "";
+                        if (defaultName.length < 3) {
+                          defaultName = `${defaultName}-标注`;
+                        }
+                        manualForm.setFieldsValue({ name: defaultName });
+                      }
+                    }}
+                    datasetTypeFilter={manualDatasetTypeFilter}
+                    singleDatasetOnly
+                    disabled={!manualForm.getFieldValue("templateId")}
+                  />
+                  {selectedDataset && (
+                    <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
+                      当前数据集：<span className="font-medium">{selectedDataset.name}</span> - 已选择
+                      <span className="font-medium text-blue-600"> {Object.keys(selectedFilesMap).length} </span>个文件
+                    </div>
+                  )}
+                </Form.Item>
+
+                {/* 隐藏的主数据集ID，用于后端兼容老字段 */}
+                <Form.Item
+                  hidden
+                  name="datasetId"
+                  rules={[{ required: true, message: "请选择数据集" }]}
+                >
+                  <Input type="hidden" />
+                </Form.Item>
+                {/* 描述变为可选 */}
+                <Form.Item label="描述" name="description">
+                  <TextArea placeholder="（可选）详细描述标注任务的要求和目标" rows={3} />
+                </Form.Item>
               </Form>
             ),
           },
@@ -424,6 +490,7 @@ export default function CreateAnnotationTask({
             label: "自动标注",
             children: (
               <Form form={autoForm} layout="vertical" preserve={false}>
+                {/* 自动标注：任务名称仍然放在第一行，必填 */}
                 <Form.Item
                   name="name"
                   label="任务名称"
@@ -445,6 +512,7 @@ export default function CreateAnnotationTask({
                       autoForm.setFieldsValue({ datasetId: dataset?.id ?? "" });
                     }}
                     datasetTypeFilter={DatasetType.IMAGE}
+                    singleDatasetOnly
                   />
                   {selectedDataset && (
                     <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
@@ -510,10 +578,6 @@ export default function CreateAnnotationTask({
                     </Form.Item>
                   )}
                 </Form.Item>
-
-                <Form.Item name="outputDatasetName" label="输出数据集名称 (可选)">
-                  <Input placeholder="留空则将结果写入原数据集的标签中" />
-                </Form.Item>
               </Form>
             ),
           },
diff --git a/frontend/src/pages/DataAnnotation/EditManualAnnotationDatasetDialog.tsx b/frontend/src/pages/DataAnnotation/EditManualAnnotationDatasetDialog.tsx
index c80b088f7..2c190b950 100644
--- a/frontend/src/pages/DataAnnotation/EditManualAnnotationDatasetDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/EditManualAnnotationDatasetDialog.tsx
@@ -164,7 +164,9 @@ export default function EditManualAnnotationDatasetDialog({
             onDatasetSelect={(dataset) => {
               setSelectedDataset(dataset as Dataset | null);
             }}
-            // 手动标注支持所有数据集/文件类型，这里不设置 datasetTypeFilter
+            // 手动标注支持所有数据集/文件类型，但编辑时仅允许在创建任务的数据集中追加
+            singleDatasetOnly
+            fixedDatasetId={task.datasetId}
             lockedFileIds={Array.from(initialFileIds)}
           />
           <div className="mt-2 p-2 bg-blue-50 rounded border border-blue-200 text-xs">
diff --git a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
index 038068a59..8f045076b 100644
--- a/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
+++ b/frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx
@@ -20,7 +20,6 @@ import {
   syncAnnotationTaskUsingPost,
   queryAutoAnnotationTasksUsingGet,
   deleteAutoAnnotationTaskByIdUsingDelete,
-  syncAutoAnnotationTaskToLabelStudioUsingPost,
   getAutoAnnotationLabelStudioProjectUsingGet,
   loginAnnotationUsingGet,
 } from "../annotation.api";
@@ -278,34 +277,6 @@ export default function DataAnnotation() {
     setShowImportAutoDialog(true);
   };
 
-  const handleSyncAutoToLabelStudio = (task: any) => {
-    if (task.autoStatus !== "completed") {
-      message.warning("仅已完成的自动标注任务可以同步到 Label Studio");
-      return;
-    }
-
-    Modal.confirm({
-      title: `确认同步自动标注任务「${task.name}」到 Label Studio 吗？`,
-      content: (
-        <div>
-          <div>将把该任务的检测结果作为预测框写入 Label Studio。</div>
-          <div>不会覆盖已有人工标注，仅作为可编辑的预测结果。</div>
-        </div>
-      ),
-      okText: "同步",
-      cancelText: "取消",
-      onOk: async () => {
-        try {
-          await syncAutoAnnotationTaskToLabelStudioUsingPost(task.id);
-          message.success("自动标注结果同步请求已发送");
-        } catch (e) {
-          console.error(e);
-          message.error("自动标注结果同步失败，请稍后重试");
-        }
-      },
-    });
-  };
-
   const handleAnnotateAuto = (task: any) => {
     (async () => {
       try {
@@ -460,8 +431,8 @@ export default function DataAnnotation() {
     },
     {
       key: "back-sync",
-      label: "后向同步",
-      icon: <ImportOutlined className="w-4 h-4" style={{ color: "#1890ff" }} />,
+      label: "同步",
+      icon: <SyncOutlined className="w-4 h-4" style={{ color: "#1890ff" }} />,
       onClick: handleImportManualFromLabelStudio,
     },
     {
@@ -652,11 +623,11 @@ export default function DataAnnotation() {
               </Button>
               <Button
                 type="text"
-                icon={<ImportOutlined style={{ color: "#1890ff" }} />}
+                icon={<SyncOutlined style={{ color: "#1890ff" }} />}
                 onClick={() => handleImportManualFromLabelStudio(task)}
-                title="从 Label Studio 导回标注结果到数据集"
+                title="从 Label Studio 同步标注结果到数据集"
               >
-                后向同步
+                同步
               </Button>
 
               <Dropdown
@@ -685,15 +656,6 @@ export default function DataAnnotation() {
           )}
           {task._kind === "auto" && (
             <>
-              {/* 一级功能：前向同步 + 编辑（跳转 Label Studio） */}
-              <Button
-                type="text"
-                icon={<ExportOutlined style={{ color: "#722ed1" }} />}
-                onClick={() => handleSyncAutoToLabelStudio(task)}
-                title="将 YOLO 预测结果前向同步到 Label Studio"
-              >
-                前向同步
-              </Button>
               <Button
                 type="text"
                 icon={<EditOutlined style={{ color: "#52c41a" }} />}
@@ -705,11 +667,11 @@ export default function DataAnnotation() {
 
               <Button
                 type="text"
-                icon={<ImportOutlined style={{ color: "#1890ff" }} />}
+                icon={<SyncOutlined style={{ color: "#1890ff" }} />}
                 onClick={() => handleImportAutoFromLabelStudio(task)}
-                title="从 Label Studio 导回标注结果到数据集"
+                title="从 Label Studio 同步标注结果到数据集"
               >
-                后向同步
+                同步
               </Button>
 
               {/* 二级功能：编辑任务数据集 + 删除任务（折叠菜单） */}
diff --git a/frontend/src/pages/DataAnnotation/ManualImportFromLabelStudioDialog.tsx b/frontend/src/pages/DataAnnotation/ManualImportFromLabelStudioDialog.tsx
index 9dbefcb69..8770d1119 100644
--- a/frontend/src/pages/DataAnnotation/ManualImportFromLabelStudioDialog.tsx
+++ b/frontend/src/pages/DataAnnotation/ManualImportFromLabelStudioDialog.tsx
@@ -1,8 +1,6 @@
 import { useEffect, useState } from "react";
 import { Modal, Form, Select, Input, message } from "antd";
 import type { AnnotationTask } from "./annotation.model";
-import { queryDatasetsUsingGet } from "@/pages/DataManagement/dataset.api";
-import type { Dataset } from "@/pages/DataManagement/dataset.model";
 import { importManualAnnotationFromLabelStudioUsingPost } from "./annotation.api";
 
 interface ManualImportFromLabelStudioDialogProps {
@@ -29,38 +27,11 @@ export default function ManualImportFromLabelStudioDialog({
   onSuccess,
 }: ManualImportFromLabelStudioDialogProps) {
   const [form] = Form.useForm();
-  const [datasets, setDatasets] = useState<Dataset[]>([]);
   const [loading, setLoading] = useState(false);
 
-  useEffect(() => {
-    if (!visible) return;
-
-    let cancelled = false;
-
-    (async () => {
-      try {
-        const resp: any = await queryDatasetsUsingGet({ page: 0, size: 1000 });
-        const list: Dataset[] = resp?.content || resp?.data?.content || resp?.data || resp || [];
-        if (!cancelled && Array.isArray(list)) {
-          setDatasets(list);
-        }
-      } catch (e) {
-        console.error("Failed to fetch datasets for manual LS import:", e);
-        if (!cancelled) {
-          message.error("获取数据集列表失败");
-        }
-      }
-    })();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [visible]);
-
   useEffect(() => {
     if (visible && task) {
       form.setFieldsValue({
-        targetDatasetId: task.datasetId,
         exportFormat: "JSON",
       });
     }
@@ -69,7 +40,6 @@ export default function ManualImportFromLabelStudioDialog({
   const handleOk = async () => {
     try {
       const values = await form.validateFields();
-      const targetDatasetId: string = values.targetDatasetId;
       const exportFormat: string = values.exportFormat;
       const fileName: string | undefined = values.fileName;
 
@@ -80,7 +50,6 @@ export default function ManualImportFromLabelStudioDialog({
 
       setLoading(true);
       await importManualAnnotationFromLabelStudioUsingPost(task.id, {
-        targetDatasetId,
         exportFormat,
         fileName: fileName?.trim() || undefined,
       });
@@ -112,22 +81,6 @@ export default function ManualImportFromLabelStudioDialog({
           <span>{task?.name || "-"}</span>
         </Form.Item>
 
-        <Form.Item
-          label="导入目标数据集"
-          name="targetDatasetId"
-          rules={[{ required: true, message: "请选择目标数据集" }]}
-        >
-          <Select
-            placeholder="请选择要导入到的数据集"
-            optionFilterProp="label"
-            showSearch
-            options={datasets.map((ds) => ({
-              label: ds.name,
-              value: ds.id,
-            }))}
-          />
-        </Form.Item>
-
         <Form.Item
           label="导出/导入格式"
           name="exportFormat"
@@ -152,7 +105,8 @@ export default function ManualImportFromLabelStudioDialog({
 
         <div className="text-xs text-gray-500 mt-2">
           将从与该标注任务关联的 Label Studio 项目中，
-          按所选格式导出完整标注结果，并作为一个文件保存到所选数据集中。
+          按所选格式导出完整标注结果，并作为一个文件保存到源数据集下的
+          <span className="font-semibold">「标注数据」</span> 文件夹中。
           不会修改已有标签，仅追加一个导出工件文件。
         </div>
       </Form>
diff --git a/frontend/src/pages/DataAnnotation/annotation.api.ts b/frontend/src/pages/DataAnnotation/annotation.api.ts
index 38affaec6..f0faa5e11 100644
--- a/frontend/src/pages/DataAnnotation/annotation.api.ts
+++ b/frontend/src/pages/DataAnnotation/annotation.api.ts
@@ -74,7 +74,7 @@ export function loginAnnotationUsingGet(mappingId: string) {
 // 手动标注：从 Label Studio 导回标注结果到某个数据集（导出为文件写入数据集）
 export function importManualAnnotationFromLabelStudioUsingPost(
   mappingId: string,
-  data: { targetDatasetId: string; exportFormat?: string }
+  data: { exportFormat?: string; fileName?: string }
 ) {
   return post(`/api/annotation/project/${mappingId}/sync-label-studio-back`, data);
 }
@@ -91,7 +91,7 @@ export function syncAutoAnnotationTaskToLabelStudioUsingPost(taskId: string) {
 // 从 Label Studio 导回自动标注任务的标注结果（导出为文件写入指定数据集）
 export function importAutoAnnotationFromLabelStudioUsingPost(
   taskId: string,
-  data: { targetDatasetId: string; exportFormat?: string }
+  data: { exportFormat?: string; fileName?: string }
 ) {
   return post(`/api/annotation/auto/${taskId}/sync-label-studio-back`, data);
 }
diff --git a/runtime/datamate-python/app/module/annotation/interface/auto.py b/runtime/datamate-python/app/module/annotation/interface/auto.py
index 161dd6fda..ba54ce7c5 100644
--- a/runtime/datamate-python/app/module/annotation/interface/auto.py
+++ b/runtime/datamate-python/app/module/annotation/interface/auto.py
@@ -1055,9 +1055,9 @@ async def import_from_label_studio_to_dataset(
     if not task:
         raise HTTPException(status_code=404, detail="Task not found")
 
-    # 2. 校验目标数据集是否存在
+    # 2. 确定目标数据集：若请求体未显式指定，则使用自动标注任务绑定的数据集
     dm_service = DatasetManagementService(db)
-    target_dataset_id = body.target_dataset_id
+    target_dataset_id = body.target_dataset_id or task.dataset_id
     dataset = await dm_service.get_dataset(target_dataset_id)
     if not dataset:
         raise HTTPException(status_code=404, detail="Target dataset not found")
@@ -1167,7 +1167,8 @@ def _sanitize_base_name(raw: str) -> str:
         target_tmp_path = os.path.join(tmp_dir, base_name)
         os.replace(tmp_path, target_tmp_path)
 
-        await dm_service.add_files_to_dataset(target_dataset_id, [target_tmp_path])
+        # 统一写入源数据集下的 "标注数据" 目录，便于管理导出工件
+        await dm_service.add_files_to_dataset_subdir(target_dataset_id, [target_tmp_path], "标注数据")
     finally:
         # 清理临时文件（若仍存在）
         if os.path.exists(tmp_path):
diff --git a/runtime/datamate-python/app/module/annotation/interface/project.py b/runtime/datamate-python/app/module/annotation/interface/project.py
index c75318cd6..a74c28fbe 100644
--- a/runtime/datamate-python/app/module/annotation/interface/project.py
+++ b/runtime/datamate-python/app/module/annotation/interface/project.py
@@ -528,9 +528,9 @@ async def import_manual_from_label_studio_to_dataset(
     if not mapping:
         raise HTTPException(status_code=404, detail="Mapping not found")
 
-    # 2. 校验目标数据集是否存在
+    # 2. 确定目标数据集：若未显式指定，则使用映射绑定的数据集
     dm_service = DatasetManagementService(db)
-    target_dataset_id = body.target_dataset_id
+    target_dataset_id = body.target_dataset_id or mapping.dataset_id
     dataset = await dm_service.get_dataset(target_dataset_id)
     if not dataset:
         raise HTTPException(status_code=404, detail="Target dataset not found")
@@ -587,7 +587,8 @@ def _sanitize_base_name(raw: str) -> str:
         target_tmp_path = os.path.join(tmp_dir, base_name)
         os.replace(tmp_path, target_tmp_path)
 
-        await dm_service.add_files_to_dataset(target_dataset_id, [target_tmp_path])
+        # 写入目标（通常为源）数据集下的 "标注数据" 目录
+        await dm_service.add_files_to_dataset_subdir(target_dataset_id, [target_tmp_path], "标注数据")
     finally:
         if os.path.exists(tmp_path):
             try:
diff --git a/runtime/datamate-python/app/module/annotation/schema/auto.py b/runtime/datamate-python/app/module/annotation/schema/auto.py
index 95f410dfc..7315d28bd 100644
--- a/runtime/datamate-python/app/module/annotation/schema/auto.py
+++ b/runtime/datamate-python/app/module/annotation/schema/auto.py
@@ -103,16 +103,16 @@ class UpdateAutoAnnotationTaskFilesRequest(BaseModel):
 class ImportFromLabelStudioRequest(BaseModel):
     """从 Label Studio 导入标注结果到 DM 数据集的请求体。
 
-    - target_dataset_id: 要将导出结果写入的目标数据集ID；
-    - export_format: Label Studio 导出格式（如 JSON/JSON_MIN/CSV/TSV/COCO/YOLO 等）。
-        - file_name: 可选，自定义保存到数据集中的文件名称（不含路径）；
-            若包含扩展名或路径分隔符，服务端会自动裁剪，仅保留文件名主体并附加正确后缀。
+    - target_dataset_id: 目标数据集ID（可选）；若未提供，则自动使用源任务/映射所关联的数据集；
+    - export_format: Label Studio 导出格式（如 JSON/JSON_MIN/CSV/TSV/COCO/YOLO 等）；
+    - file_name: 可选，自定义保存到数据集中的文件名称（不含路径）；
+      若包含扩展名或路径分隔符，服务端会自动裁剪，仅保留文件名主体并附加正确后缀。
     """
 
-    target_dataset_id: str = Field(
-        ...,
+    target_dataset_id: Optional[str] = Field(
+        default=None,
         alias="targetDatasetId",
-        description="导入目标数据集ID",
+        description="导入目标数据集ID（可选，不传则使用源数据集）",
     )
     export_format: str = Field(
         default="JSON",
diff --git a/runtime/datamate-python/app/module/dataset/service/service.py b/runtime/datamate-python/app/module/dataset/service/service.py
index 8ccbc6f60..6bccc54de 100644
--- a/runtime/datamate-python/app/module/dataset/service/service.py
+++ b/runtime/datamate-python/app/module/dataset/service/service.py
@@ -321,6 +321,84 @@ async def add_files_to_dataset(self, dataset_id: str, source_paths: List[str]):
             await self.db.rollback()
             logger.error(f"Failed to add files to dataset {dataset_id}: {str(e)}", exc_info=True)
 
+    async def add_files_to_dataset_subdir(self, dataset_id: str, source_paths: List[str], subdir: str):
+        """将文件添加到数据集下的指定子目录中，并创建对应的数据库记录。
+
+        与 add_files_to_dataset 行为类似，但允许将文件放入形如
+        ``<dataset.path>/<subdir>/<filename>`` 的结构中，适用于诸如
+        "标注数据" 这类逻辑分组目录。
+        """
+
+        logger.info(f"Starting to add files to dataset {dataset_id} under subdir '{subdir}'")
+
+        try:
+            # Get dataset and existing files
+            dataset = await self.db.get(Dataset, dataset_id)
+            if not dataset:
+                logger.error(f"Dataset not found: {dataset_id}")
+                return
+
+            # Get existing files to check for duplicates (按 file_path 去重)
+            result = await self.db.execute(
+                select(DatasetFiles).where(DatasetFiles.dataset_id == dataset_id)
+            )
+            existing_files_map: Dict[str, DatasetFiles] = {}
+            for dataset_file in result.scalars().all():
+                existing_files_map[dataset_file.file_path] = dataset_file  # type: ignore[attr-defined]
+
+            # Get or create dataset root directory, then拼接子目录
+            dataset_root = await self._get_or_create_dataset_directory(dataset)
+            dataset_dir = os.path.join(dataset_root, subdir)
+            os.makedirs(dataset_dir, exist_ok=True)
+
+            # Process each source file
+            for source_path in source_paths:
+                try:
+                    file_record = await self.create_new_dataset_file(dataset_dir, dataset_id, source_path)
+                    if not file_record:
+                        continue
+
+                    target_path = file_record.file_path  # type: ignore[attr-defined]
+                    file_size = file_record.file_size  # type: ignore[attr-defined]
+
+                    # 如果同一 dataset_id + file_path 已存在，则更新大小，否则追加
+                    if target_path in existing_files_map:
+                        logger.warning(
+                            f"File {target_path} already exists in dataset {dataset.id}, updating size only",
+                        )
+                        dataset_file = existing_files_map.get(target_path)
+                        if dataset_file is not None:
+                            dataset.size_bytes = (dataset.size_bytes or 0) - (dataset_file.file_size or 0) + file_size  # type: ignore[attr-defined]
+                            dataset.updated_at = datetime.now()
+                            dataset_file.file_size = file_size  # type: ignore[attr-defined]
+                            dataset_file.updated_at = datetime.now()  # type: ignore[attr-defined]
+                    else:
+                        # 新文件：插入记录并更新统计
+                        self.db.add(file_record)
+                        dataset.file_count = (dataset.file_count or 0) + 1  # type: ignore[attr-defined]
+                        dataset.size_bytes = (dataset.size_bytes or 0) + file_record.file_size  # type: ignore[attr-defined]
+                        dataset.updated_at = datetime.now()
+                        dataset.status = 'ACTIVE'
+
+                    # 复制物理文件到目标路径
+                    logger.info(f"copy file {source_path} to {target_path}")
+                    dst_dir = os.path.dirname(target_path)
+                    await asyncio.to_thread(os.makedirs, dst_dir, exist_ok=True)
+                    await asyncio.to_thread(shutil.copy2, source_path, target_path)
+
+                    await self.db.commit()
+
+                except Exception as e:
+                    logger.error(f"Error processing file {source_path} into subdir {subdir}: {str(e)}", e)
+                    await self.db.rollback()
+
+        except Exception as e:
+            await self.db.rollback()
+            logger.error(
+                f"Failed to add files to dataset {dataset_id} under subdir '{subdir}': {str(e)}",
+                exc_info=True,
+            )
+
     async def handle_dataset_file(self, dataset, existing_files_map: dict[Any, Any], file_record: DatasetFiles, source_path: str):
         target_path = file_record.file_path
         file_size = file_record.file_size
diff --git a/runtime/ops/annotation/image_object_detection_bounding_box/process.py b/runtime/ops/annotation/image_object_detection_bounding_box/process.py
index 3439100c5..66e6a587b 100644
--- a/runtime/ops/annotation/image_object_detection_bounding_box/process.py
+++ b/runtime/ops/annotation/image_object_detection_bounding_box/process.py
@@ -180,21 +180,15 @@ def execute(self, sample: Dict[str, Any]) -> Dict[str, Any]:
         else:
             output_dir = os.path.dirname(image_path)
         
-        # 创建输出子目录（可选，用于组织文件）
-        images_dir = os.path.join(output_dir, "images")
+        # 创建输出子目录：仅保留 annotations 目录，不再额外保存标注图像，
+        # 以减少冗余占用；检测结果将直接写入 JSON 文件。
         annotations_dir = os.path.join(output_dir, "annotations")
-        os.makedirs(images_dir, exist_ok=True)
         os.makedirs(annotations_dir, exist_ok=True)
         
         # 保持原始文件名（不添加后缀），确保一一对应
         base_name = os.path.basename(image_path)
         name_without_ext = os.path.splitext(base_name)[0]
         
-        # 保存标注图像（保持原始扩展名或使用jpg）
-        output_filename = base_name
-        output_path = os.path.join(images_dir, output_filename)
-        cv2.imwrite(output_path, img)
-        
         # 保存标注 JSON（文件名与图像对应）
         json_filename = f"{name_without_ext}.json"
         json_path = os.path.join(annotations_dir, json_filename)
@@ -203,7 +197,8 @@ def execute(self, sample: Dict[str, Any]) -> Dict[str, Any]:
         
         # 更新样本数据
         sample["detection_count"] = len(annotations["detections"])
-        sample["output_image"] = output_path
+        # 不再额外保存 output_image 副本，仅返回原始路径和注释信息
+        sample["output_image"] = image_path
         sample["annotations_file"] = json_path
         sample["annotations"] = annotations
         
diff --git a/runtime/python-executor/datamate/auto_annotation_worker.py b/runtime/python-executor/datamate/auto_annotation_worker.py
index 90ccc56f6..10162efe1 100644
--- a/runtime/python-executor/datamate/auto_annotation_worker.py
+++ b/runtime/python-executor/datamate/auto_annotation_worker.py
@@ -28,6 +28,8 @@
 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
@@ -101,6 +103,13 @@
     "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 任务。"""
@@ -204,6 +213,29 @@ def _update_task_status(
         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]]:
     """加载指定数据集下的所有已激活文件。
 
@@ -319,205 +351,183 @@ def _update_dataset_file_tags(file_id: str, tags: List[Dict[str, Any]]) -> None:
         )
 
 
-def _ensure_output_dir(output_dir: str) -> str:
-    """确保输出目录及其 images/、annotations/ 子目录存在。"""
+def _register_annotation_output_file(dataset_id: str, annotations_path: str) -> None:
+    """确保自动标注生成的 JSON 结果文件在 t_dm_dataset_files 中有一条记录。
 
-    os.makedirs(output_dir, exist_ok=True)
-    os.makedirs(os.path.join(output_dir, "images"), exist_ok=True)
-    os.makedirs(os.path.join(output_dir, "annotations"), exist_ok=True)
-    return output_dir
+    - 若同一 dataset_id + file_path 已存在，则仅更新文件大小和时间戳；
+    - 若不存在，则插入一条新的 ACTIVE 记录。
+    """
 
+    if not annotations_path:
+        return
 
-def _create_output_dataset(
-    source_dataset_id: str,
-    source_dataset_name: str,
-    output_dataset_name: str,
-) -> Tuple[str, str]:
-    """为自动标注结果创建一个新的数据集并返回 (dataset_id, path)。"""
+    try:
+        if not os.path.isfile(annotations_path):
+            logger.warning(
+                "Annotation JSON file not found when registering dataset file: {}",
+                annotations_path,
+            )
+            return
 
-    new_dataset_id = str(uuid.uuid4())
-    dataset_base_path = DEFAULT_OUTPUT_ROOT.rstrip("/") or "/dataset"
-    output_dir = os.path.join(dataset_base_path, new_dataset_id)
+        file_name = os.path.basename(annotations_path)
+        ext = os.path.splitext(file_name)[1].lstrip(".").lower() or "other"
 
-    description = (
-        f"Auto annotations for dataset {source_dataset_name or source_dataset_id}"[:255]
-    )
+        try:
+            file_size = os.path.getsize(annotations_path)
+        except OSError:
+            file_size = 0
 
-    sql = text(
-        """
-        INSERT INTO t_dm_datasets (id, name, description, dataset_type, path, status)
-        VALUES (:id, :name, :description, :dataset_type, :path, :status)
-        """
-    )
-    params = {
-        "id": new_dataset_id,
-        "name": output_dataset_name,
-        "description": description,
-        "dataset_type": "IMAGE",
-        "path": output_dir,
-        "status": "ACTIVE",
-    }
+        now = datetime.utcnow()
 
-    with SQLManager.create_connect() as conn:
-        conn.execute(sql, params)
+        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,
+                    },
+                )
 
-    return new_dataset_id, output_dir
+                # 轻量更新数据集的文件数量和总大小统计
+                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 _register_output_dataset(
-    task_id: str,
-    output_dataset_id: str,
-    output_dir: str,
-    output_dataset_name: str,
-    total_images: int,
-    *,
-    tags_by_filename: Optional[Dict[str, List[Dict[str, Any]]]] = None,
-) -> None:
-    """将自动标注结果注册到数据集。
+def _ensure_output_dir(output_dir: str) -> str:
+    """确保输出目录存在。
 
-    如果多次为同一自动标注任务重复运行，将复用同一个输出数据集，并避免对
-    同一 dataset_id + file_name 插入重复记录，只为新文件追加记录。
+    annotations 子目录由算子本身负责创建；这里不再为 images 创建额外目录，
+    以符合“自动标注不再单独保存 images” 的新设计。
     """
 
-    images_dir = os.path.join(output_dir, "images")
-    if not os.path.isdir(images_dir):
-        logger.warning(
-            "Auto-annotation images directory not found for task {}: {}",
-            task_id,
-            images_dir,
-        )
-        return
+    os.makedirs(output_dir, exist_ok=True)
+    return output_dir
 
-    image_files: List[Tuple[str, str, int]] = []
-    annotation_files: List[Tuple[str, str, int]] = []
-    total_size = 0
 
-    for file_name in sorted(os.listdir(images_dir)):
-        file_path = os.path.join(images_dir, file_name)
-        if not os.path.isfile(file_path):
-            continue
-        try:
-            file_size = os.path.getsize(file_path)
-        except OSError:
-            file_size = 0
-        image_files.append((file_name, file_path, int(file_size)))
-        total_size += int(file_size)
+def _trigger_forward_sync_to_label_studio(task_id: str) -> None:
+    """在任务完成后，自动调用后端接口，将检测结果推送到 Label Studio。
 
-    annotations_dir = os.path.join(output_dir, "annotations")
-    if os.path.isdir(annotations_dir):
-        for file_name in sorted(os.listdir(annotations_dir)):
-            file_path = os.path.join(annotations_dir, file_name)
-            if not os.path.isfile(file_path):
-                continue
-            try:
-                file_size = os.path.getsize(file_path)
-            except OSError:
-                file_size = 0
-            annotation_files.append((file_name, file_path, int(file_size)))
-            total_size += int(file_size)
-
-    if not image_files:
-        logger.warning(
-            "No image files found in auto-annotation output for task {}: {}",
-            task_id,
-            images_dir,
-        )
-        return
+    该调用是“尽力而为”的：失败只记录日志，不影响任务本身的完成状态。
+    """
 
-    insert_file_sql = text(
-        """
-        INSERT INTO t_dm_dataset_files (
-            id, dataset_id, file_name, file_path, file_type, file_size, status, tags, tags_updated_at
-        ) VALUES (
-            :id, :dataset_id, :file_name, :file_path, :file_type, :file_size, :status, :tags, :tags_updated_at
+    if not AUTO_SYNC_ENABLED:
+        logger.info(
+            "Auto sync to Label Studio is disabled by env AUTO_ANNOTATION_SYNC_ENABLED",
         )
-        """
-    )
-    update_dataset_stat_sql = text(
-        """
-        UPDATE t_dm_datasets
-        SET file_count = COALESCE(file_count, 0) + :add_count,
-            size_bytes = COALESCE(size_bytes, 0) + :add_size
-        WHERE id = :dataset_id
-        """
-    )
+        return
 
-    with SQLManager.create_connect() as conn:
-        added_count = 0
+    base_url = BACKEND_BASE_URL.rstrip("/")
+    url = f"{base_url}/api/annotation/auto/{task_id}/sync-label-studio"
 
-        # 预先查询已存在的文件名，避免重复插入
-        existing_names_sql = text(
-            """
-            SELECT file_name FROM t_dm_dataset_files WHERE dataset_id = :dataset_id
-            """
+    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,
         )
-        rows = conn.execute(existing_names_sql, {"dataset_id": output_dataset_id}).fetchall()
-        existing_names = {str(r[0]) for r in rows}
-
-        for file_name, file_path, file_size in image_files:
-            if file_name in existing_names:
-                continue
-            ext = os.path.splitext(file_name)[1].lstrip(".").upper() or None
-            file_tags = None
-            if tags_by_filename:
-                file_tags = tags_by_filename.get(file_name)
-            conn.execute(
-                insert_file_sql,
-                {
-                    "id": str(uuid.uuid4()),
-                    "dataset_id": output_dataset_id,
-                    "file_name": file_name,
-                    "file_path": file_path,
-                    "file_type": ext,
-                    "file_size": int(file_size),
-                    "status": "ACTIVE",
-                    "tags": json.dumps(file_tags, ensure_ascii=False) if file_tags else None,
-                    "tags_updated_at": datetime.utcnow() if file_tags else None,
-                },
-            )
-            added_count += 1
-            existing_names.add(file_name)
-
-        for file_name, file_path, file_size in annotation_files:
-            if file_name in existing_names:
-                continue
-            ext = os.path.splitext(file_name)[1].lstrip(".").upper() or None
-            conn.execute(
-                insert_file_sql,
-                {
-                    "id": str(uuid.uuid4()),
-                    "dataset_id": output_dataset_id,
-                    "file_name": file_name,
-                    "file_path": file_path,
-                    "file_type": ext,
-                    "file_size": int(file_size),
-                    "status": "ACTIVE",
-                    "tags": None,
-                    "tags_updated_at": None,
-                },
-            )
-            added_count += 1
-            existing_names.add(file_name)
-
-        if added_count > 0:
-            conn.execute(
-                update_dataset_stat_sql,
-                {
-                    "dataset_id": output_dataset_id,
-                    "add_count": added_count,
-                    "add_size": int(total_size),
-                },
-            )
-
-    logger.info(
-        "Registered auto-annotation output into dataset: dataset_id={}, name={}, added_files={}, added_size_bytes={}, task_id={}, output_dir={}",
-        output_dataset_id,
-        output_dataset_name,
-        len(image_files) + len(annotation_files),
-        total_size,
-        task_id,
-        output_dir,
-    )
 
 
 def _process_single_task(task: Dict[str, Any]) -> None:
@@ -579,64 +589,57 @@ def _process_single_task(task: Dict[str, Any]) -> None:
     else:
         all_files = _load_dataset_files(dataset_id)
 
-    # 优先复用任务已有的输出目录和对应数据集，避免重复创建结果数据集
+    # 优先复用任务已有的输出目录，避免重复创建或切换路径
     existing_output_path = (task.get("output_path") or "").strip() or None
-    output_dataset_id: Optional[str] = None
     output_dir: Optional[str] = None
 
     if existing_output_path:
         try:
             # 确保目录存在
             output_dir = _ensure_output_dir(existing_output_path)
-
-            # 根据路径查找已存在的数据集记录
-            find_dataset_sql = text(
-                """
-                SELECT id FROM t_dm_datasets
-                WHERE path = :path
-                ORDER BY created_at DESC
-                LIMIT 1
-                """
-            )
-            with SQLManager.create_connect() as conn:
-                row = conn.execute(find_dataset_sql, {"path": output_dir}).fetchone()
-            if row:
-                output_dataset_id = str(row[0])
-                logger.info(
-                    "Reuse existing output dataset for auto-annotation task: task_id={}, dataset_id={}, path={}",
-                    task_id,
-                    output_dataset_id,
-                    output_dir,
-                )
         except Exception as e:
             logger.error(
-                "Failed to reuse existing output dataset for task {}: {}",
+                "Failed to reuse existing output directory for task {}: {}",
                 task_id,
                 e,
             )
 
-    # 如果没有可复用的数据集，则创建新的结果数据集
-    if not output_dataset_id or not output_dir:
-        output_dataset_id, new_output_dir = _create_output_dataset(
-            source_dataset_id=dataset_id,
-            source_dataset_name=source_dataset_name,
-            output_dataset_name=output_dataset_name,
-        )
-        output_dir = _ensure_output_dir(new_output_dir)
+    # 如果没有可复用的输出目录，则基于“源数据集路径/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)
 
     # 仅对“新选的数据”执行自动标注：
-    # 已经在输出目录 images/ 中存在对应文件名的，认为该任务已跑过，不再重复标注
-    existing_image_names: Set[str] = set()
-    images_dir = os.path.join(output_dir, "images")
-    if os.path.isdir(images_dir):
+    # 已经在输出目录中存在对应 JSON 文件的，认为该任务已跑过，不再重复标注
+    existing_stems: Set[str] = set()
+    annotations_dir = output_dir
+    if os.path.isdir(annotations_dir):
         try:
-            for name in os.listdir(images_dir):
-                if not os.path.isfile(os.path.join(images_dir, name)):
+            for name in os.listdir(annotations_dir):
+                file_path = os.path.join(annotations_dir, name)
+                if not os.path.isfile(file_path):
                     continue
-                existing_image_names.add(name)
+                stem, _ = os.path.splitext(name)
+                existing_stems.add(stem)
         except Exception as e:
             logger.error(
-                "Failed to list existing images for auto-annotation task {}: {}",
+                "Failed to list existing annotations for auto-annotation task {}: {}",
                 task_id,
                 e,
             )
@@ -645,7 +648,7 @@ def _process_single_task(task: Dict[str, Any]) -> None:
     files = [
         (file_id, file_path, file_name)
         for file_id, file_path, file_name in all_files
-        if os.path.basename(file_path) not in existing_image_names
+        if os.path.splitext(os.path.basename(file_path))[0] not in existing_stems
     ]
 
     total_images = len(files)
@@ -705,6 +708,27 @@ def _process_single_task(task: Dict[str, Any]) -> None:
             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:
@@ -761,22 +785,8 @@ def _process_single_task(task: Dict[str, Any]) -> None:
         output_dir,
     )
 
-    if output_dataset_name and output_dataset_id:
-        try:
-            _register_output_dataset(
-                task_id=task_id,
-                output_dataset_id=output_dataset_id,
-                output_dir=output_dir,
-                output_dataset_name=output_dataset_name,
-                total_images=total_images,
-                tags_by_filename=tags_by_filename,
-            )
-        except Exception as e:  # pragma: no cover - 防御性日志
-            logger.error(
-                "Failed to register auto-annotation output as dataset for task {}: {}",
-                task_id,
-                e,
-            )
+    # 任务完成后，自动触发一次前向同步，将检测结果推送到 Label Studio
+    _trigger_forward_sync_to_label_studio(task_id)
 
 
 def _worker_loop() -> None: