refactor(annotation): 简化任务选择逻辑并移除未使用的状态管理

- 移除了 resolveSegmentSummary 函数调用以简化完成状态判断
- 删除了未使用的 segmentStats 相关引用和缓存清理代码
- 简化了重置模式下的状态更新逻辑

Makefile.offline.mk

@@ -0,0 +1,304 @@
+# ============================================================================
+# Makefile 离线构建扩展
+# 将此文件内容追加到主 Makefile 末尾，或单独包含使用
+# ============================================================================
+
+# 离线构建配置
+CACHE_DIR ?= ./build-cache
+OFFLINE_VERSION ?= latest
+
+# 创建 buildx 构建器（如果不存在）
+.PHONY: ensure-buildx
+ensure-buildx:
+	@if ! docker buildx inspect offline-builder > /dev/null 2>&1; then \
+		echo "创建 buildx 构建器..."; \
+		docker buildx create --name offline-builder --driver docker-container --use 2>/dev/null || docker buildx use offline-builder; \
+	else \
+		docker buildx use offline-builder 2>/dev/null || true; \
+	fi
+
+# ========== 离线缓存导出（有网环境） ==========
+
+.PHONY: offline-export
+offline-export: ensure-buildx
+	@echo "======================================"
+	@echo "导出离线构建缓存..."
+	@echo "======================================"
+	@mkdir -p $(CACHE_DIR)/buildkit $(CACHE_DIR)/images $(CACHE_DIR)/resources
+	@$(MAKE) _offline-export-base-images
+	@$(MAKE) _offline-export-cache
+	@$(MAKE) _offline-export-resources
+	@$(MAKE) _offline-package
+
+.PHONY: _offline-export-base-images
+_offline-export-base-images:
+	@echo ""
+	@echo "1. 导出基础镜像..."
+	@bash -c 'images=( \
+		"maven:3-eclipse-temurin-21" \
+		"maven:3-eclipse-temurin-8" \
+		"eclipse-temurin:21-jdk" \
+		"mysql:8" \
+		"node:20-alpine" \
+		"nginx:1.29" \
+		"ghcr.nju.edu.cn/astral-sh/uv:python3.11-bookworm" \
+		"ghcr.nju.edu.cn/astral-sh/uv:python3.12-bookworm" \
+		"ghcr.nju.edu.cn/astral-sh/uv:latest" \
+		"python:3.12-slim" \
+		"python:3.11-slim" \
+		"gcr.nju.edu.cn/distroless/nodejs20-debian12" \
+	); for img in "$${images[@]}"; do echo "  Pulling $$img..."; docker pull "$$img" 2>/dev/null || true; done'
+	@echo "  Saving base images..."
+	@docker save -o $(CACHE_DIR)/images/base-images.tar \
+		maven:3-eclipse-temurin-21 \
+		maven:3-eclipse-temurin-8 \
+		eclipse-temurin:21-jdk \
+		mysql:8 \
+		node:20-alpine \
+		nginx:1.29 \
+		ghcr.nju.edu.cn/astral-sh/uv:python3.11-bookworm \
+		ghcr.nju.edu.cn/astral-sh/uv:python3.12-bookworm \
+		ghcr.nju.edu.cn/astral-sh/uv:latest \
+		python:3.12-slim \
+		python:3.11-slim \
+		gcr.nju.edu.cn/distroless/nodejs20-debian12 2>/dev/null || echo "  Warning: Some images may not exist"
+
+.PHONY: _offline-export-cache
+_offline-export-cache:
+	@echo ""
+	@echo "2. 导出 BuildKit 缓存..."
+	@echo "   backend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/backend-cache,mode=max -f scripts/images/backend/Dockerfile -t datamate-backend:cache . 2>/dev/null || echo "   Warning: backend cache export failed"
+	@echo "   backend-python..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/backend-python-cache,mode=max -f scripts/images/backend-python/Dockerfile -t datamate-backend-python:cache . 2>/dev/null || echo "   Warning: backend-python cache export failed"
+	@echo "   database..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/database-cache,mode=max -f scripts/images/database/Dockerfile -t datamate-database:cache . 2>/dev/null || echo "   Warning: database cache export failed"
+	@echo "   frontend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/frontend-cache,mode=max -f scripts/images/frontend/Dockerfile -t datamate-frontend:cache . 2>/dev/null || echo "   Warning: frontend cache export failed"
+	@echo "   gateway..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/gateway-cache,mode=max -f scripts/images/gateway/Dockerfile -t datamate-gateway:cache . 2>/dev/null || echo "   Warning: gateway cache export failed"
+	@echo "   runtime..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/runtime-cache,mode=max -f scripts/images/runtime/Dockerfile -t datamate-runtime:cache . 2>/dev/null || echo "   Warning: runtime cache export failed"
+	@echo "   deer-flow-backend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/deer-flow-backend-cache,mode=max -f scripts/images/deer-flow-backend/Dockerfile -t deer-flow-backend:cache . 2>/dev/null || echo "   Warning: deer-flow-backend cache export failed"
+	@echo "   deer-flow-frontend..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/deer-flow-frontend-cache,mode=max -f scripts/images/deer-flow-frontend/Dockerfile -t deer-flow-frontend:cache . 2>/dev/null || echo "   Warning: deer-flow-frontend cache export failed"
+	@echo "   mineru..."
+	@docker buildx build --cache-to type=local,dest=$(CACHE_DIR)/buildkit/mineru-cache,mode=max -f scripts/images/mineru/Dockerfile -t datamate-mineru:cache . 2>/dev/null || echo "   Warning: mineru cache export failed"
+
+.PHONY: _offline-export-resources
+_offline-export-resources:
+	@echo ""
+	@echo "3. 预下载外部资源..."
+	@mkdir -p $(CACHE_DIR)/resources/models
+	@echo "   PaddleOCR model..."
+	@wget -q -O $(CACHE_DIR)/resources/models/ch_ppocr_mobile_v2.0_cls_infer.tar \
+		https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar 2>/dev/null || echo "   Warning: PaddleOCR model download failed"
+	@echo "   spaCy model..."
+	@wget -q -O $(CACHE_DIR)/resources/models/zh_core_web_sm-3.8.0-py3-none-any.whl \
+		https://ghproxy.net/https://github.com/explosion/spacy-models/releases/download/zh_core_web_sm-3.8.0/zh_core_web_sm-3.8.0-py3-none-any.whl 2>/dev/null || echo "   Warning: spaCy model download failed"
+	@echo "   DataX source..."
+	@if [ ! -d "$(CACHE_DIR)/resources/DataX" ]; then \
+		git clone --depth 1 https://gitee.com/alibaba/DataX.git $(CACHE_DIR)/resources/DataX 2>/dev/null || echo "   Warning: DataX clone failed"; \
+	fi
+	@echo "   deer-flow source..."
+	@if [ ! -d "$(CACHE_DIR)/resources/deer-flow" ]; then \
+		git clone --depth 1 https://ghproxy.net/https://github.com/ModelEngine-Group/deer-flow.git $(CACHE_DIR)/resources/deer-flow 2>/dev/null || echo "   Warning: deer-flow clone failed"; \
+	fi
+
+.PHONY: _offline-package
+_offline-package:
+	@echo ""
+	@echo "4. 打包缓存..."
+	@cd $(CACHE_DIR) && tar -czf "build-cache-$$(date +%Y%m%d).tar.gz" buildkit images resources 2>/dev/null && cd - > /dev/null
+	@echo ""
+	@echo "======================================"
+	@echo "✓ 缓存导出完成！"
+	@echo "======================================"
+	@echo "传输文件: $(CACHE_DIR)/build-cache-$$(date +%Y%m%d).tar.gz"
+
+# ========== 离线构建（无网环境） ==========
+
+.PHONY: offline-setup
+offline-setup:
+	@echo "======================================"
+	@echo "设置离线构建环境..."
+	@echo "======================================"
+	@if [ ! -d "$(CACHE_DIR)" ]; then \
+		echo "查找并解压缓存包..."; \
+		cache_file=$$(ls -t build-cache-*.tar.gz 2>/dev/null | head -1); \
+		if [ -z "$$cache_file" ]; then \
+			echo "错误: 未找到缓存压缩包 (build-cache-*.tar.gz)"; \
+			exit 1; \
+		fi; \
+		echo "解压 $$cache_file..."; \
+		tar -xzf "$$cache_file"; \
+	else \
+		echo "缓存目录已存在: $(CACHE_DIR)"; \
+	fi
+	@echo ""
+	@echo "加载基础镜像..."
+	@if [ -f "$(CACHE_DIR)/images/base-images.tar" ]; then \
+		docker load -i $(CACHE_DIR)/images/base-images.tar; \
+	else \
+		echo "警告: 基础镜像文件不存在，假设已手动加载"; \
+	fi
+	@$(MAKE) ensure-buildx
+	@echo ""
+	@echo "✓ 离线环境准备完成"
+
+.PHONY: offline-build
+offline-build: offline-setup
+	@echo ""
+	@echo "======================================"
+	@echo "开始离线构建..."
+	@echo "======================================"
+	@$(MAKE) _offline-build-services
+
+.PHONY: _offline-build-services
+_offline-build-services: ensure-buildx
+	@echo ""
+	@echo "构建 datamate-database..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/database-cache \
+		--pull=false \
+		-f scripts/images/database/Dockerfile \
+		-t datamate-database:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-gateway..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/gateway-cache \
+		--pull=false \
+		-f scripts/images/gateway/Dockerfile \
+		-t datamate-gateway:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-backend..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/backend-cache \
+		--pull=false \
+		-f scripts/images/backend/Dockerfile \
+		-t datamate-backend:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-frontend..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/frontend-cache \
+		--pull=false \
+		-f scripts/images/frontend/Dockerfile \
+		-t datamate-frontend:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-runtime..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/runtime-cache \
+		--pull=false \
+		--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources \
+		-f scripts/images/runtime/Dockerfile \
+		-t datamate-runtime:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "构建 datamate-backend-python..."
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/backend-python-cache \
+		--pull=false \
+		--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources \
+		-f scripts/images/backend-python/Dockerfile \
+		-t datamate-backend-python:$(OFFLINE_VERSION) \
+		--load . || echo "  Failed"
+
+	@echo ""
+	@echo "======================================"
+	@echo "✓ 离线构建完成"
+	@echo "======================================"
+
+# 单个服务离线构建 (BuildKit)
+.PHONY: %-offline-build
+%-offline-build: offline-setup ensure-buildx
+	@echo "离线构建 $*..."
+	@if [ ! -d "$(CACHE_DIR)/buildkit/$*-cache" ]; then \
+		echo "错误: $* 的缓存不存在"; \
+		exit 1; \
+	fi
+	@$(eval IMAGE_NAME := $(if $(filter deer-flow%,$*),$*,datamate-$*))
+	@docker buildx build \
+		--cache-from type=local,src=$(CACHE_DIR)/buildkit/$*-cache \
+		--pull=false \
+		$(if $(filter runtime backend-python deer-flow%,$*),--build-arg RESOURCES_DIR=$(CACHE_DIR)/resources,) \
+		-f scripts/images/$*/Dockerfile \
+		-t $(IMAGE_NAME):$(OFFLINE_VERSION) \
+		--load .
+
+# 传统 Docker 构建（不使用 BuildKit，更稳定）
+.PHONY: offline-build-classic
+offline-build-classic: offline-setup
+	@echo "使用传统 docker build 进行离线构建..."
+	@bash scripts/offline/build-offline-classic.sh $(CACHE_DIR) $(OFFLINE_VERSION)
+
+# 诊断离线环境
+.PHONY: offline-diagnose
+offline-diagnose:
+	@bash scripts/offline/diagnose.sh $(CACHE_DIR)
+
+# 构建 APT 预装基础镜像（有网环境）
+.PHONY: offline-build-base-images
+offline-build-base-images:
+	@echo "构建 APT 预装基础镜像..."
+	@bash scripts/offline/build-base-images.sh $(CACHE_DIR)
+
+# 使用预装基础镜像进行离线构建（推荐）
+.PHONY: offline-build-final
+offline-build-final: offline-setup
+	@echo "使用预装 APT 包的基础镜像进行离线构建..."
+	@bash scripts/offline/build-offline-final.sh $(CACHE_DIR) $(OFFLINE_VERSION)
+
+# 完整离线导出（包含 APT 预装基础镜像）
+.PHONY: offline-export-full
+offline-export-full:
+	@echo "======================================"
+	@echo "完整离线缓存导出（含 APT 预装基础镜像）"
+	@echo "======================================"
+	@$(MAKE) offline-build-base-images
+	@$(MAKE) offline-export
+	@echo ""
+	@echo "导出完成！传输时请包含以下文件:"
+	@echo "  - build-cache/images/base-images-with-apt.tar"
+	@echo "  - build-cache-YYYYMMDD.tar.gz"
+
+# ========== 帮助 ==========
+
+.PHONY: help-offline
+help-offline:
+	@echo "离线构建命令:"
+	@echo ""
+	@echo "【有网环境】"
+	@echo "  make offline-export [CACHE_DIR=./build-cache]       - 导出构建缓存"
+	@echo "  make offline-export-full                            - 导出完整缓存（含 APT 预装基础镜像）"
+	@echo "  make offline-build-base-images                      - 构建 APT 预装基础镜像"
+	@echo ""
+	@echo "【无网环境】"
+	@echo "  make offline-setup [CACHE_DIR=./build-cache]        - 解压并准备离线缓存"
+	@echo "  make offline-build-final                            - 使用预装基础镜像构建（推荐，解决 APT 问题）"
+	@echo "  make offline-build-classic                          - 使用传统 docker build"
+	@echo "  make offline-build                                  - 使用 BuildKit 构建"
+	@echo "  make offline-diagnose                               - 诊断离线构建环境"
+	@echo "  make <service>-offline-build                        - 离线构建单个服务"
+	@echo ""
+	@echo "【完整工作流程（推荐）】"
+	@echo "  # 1. 有网环境导出完整缓存"
+	@echo "  make offline-export-full"
+	@echo ""
+	@echo "  # 2. 传输到无网环境（需要传输两个文件）"
+	@echo "  scp build-cache/images/base-images-with-apt.tar user@offline-server:/path/"
+	@echo "  scp build-cache-*.tar.gz user@offline-server:/path/"
+	@echo ""
+	@echo "  # 3. 无网环境构建"
+	@echo "  tar -xzf build-cache-*.tar.gz"
+	@echo "  docker load -i build-cache/images/base-images-with-apt.tar"
+	@echo "  make offline-build-final"

backend/openapi/specs/data-management.yaml

@@ -470,6 +470,23 @@ paths:
         '200':
           description: 上传成功
 
+  /data-management/datasets/upload/cancel-upload/{reqId}:
+    put:
+      tags: [ DatasetFile ]
+      operationId: cancelUpload
+      summary: 取消上传
+      description: 取消预上传请求并清理临时分片
+      parameters:
+        - name: reqId
+          in: path
+          required: true
+          schema:
+            type: string
+          description: 预上传请求ID
+      responses:
+        '200':
+          description: 取消成功
+
   /data-management/dataset-types:
     get:
       operationId: getDatasetTypes

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetApplicationService.java

@@ -1,5 +1,6 @@
 package com.datamate.datamanagement.application;
 
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.datamate.common.domain.utils.ChunksSaver;
@@ -19,8 +20,11 @@ import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorC
 import com.datamate.datamanagement.infrastructure.persistence.mapper.TagMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import com.datamate.datamanagement.interfaces.converter.DatasetConverter;
 import com.datamate.datamanagement.interfaces.dto.*;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
@@ -53,6 +57,7 @@ public class DatasetApplicationService {
     private static final int SIMILAR_DATASET_MAX_LIMIT = 50;
     private static final int SIMILAR_DATASET_CANDIDATE_FACTOR = 5;
     private static final int SIMILAR_DATASET_CANDIDATE_MAX = 100;
+    private static final String DERIVED_METADATA_KEY = "derived_from_file_id";
     private final DatasetRepository datasetRepository;
     private final TagMapper tagMapper;
     private final DatasetFileRepository datasetFileRepository;
@@ -97,6 +102,7 @@ public class DatasetApplicationService {
     public Dataset updateDataset(String datasetId, UpdateDatasetRequest updateDatasetRequest) {
         Dataset dataset = datasetRepository.getById(datasetId);
         BusinessAssert.notNull(dataset, DataManagementErrorCode.DATASET_NOT_FOUND);
+        
         if (StringUtils.hasText(updateDatasetRequest.getName())) {
             dataset.setName(updateDatasetRequest.getName());
         }
@@ -109,13 +115,31 @@ public class DatasetApplicationService {
         if (Objects.nonNull(updateDatasetRequest.getStatus())) {
             dataset.setStatus(updateDatasetRequest.getStatus());
         }
-        if (updateDatasetRequest.getParentDatasetId() != null) {
+        if (updateDatasetRequest.isParentDatasetIdProvided()) {
+            // 保存原始的 parentDatasetId 值，用于比较是否发生了变化
+            String originalParentDatasetId = dataset.getParentDatasetId();
+
+            // 处理父数据集变更：仅当请求显式包含 parentDatasetId 时处理
+            // handleParentChange 内部通过 normalizeParentId 方法将空字符串和 null 都转换为 null
+            // 这样既支持设置新的父数据集，也支持清除关联
             handleParentChange(dataset, updateDatasetRequest.getParentDatasetId());
+
+            // 检查 parentDatasetId 是否发生了变化
+            if (!Objects.equals(originalParentDatasetId, dataset.getParentDatasetId())) {
+                // 使用 LambdaUpdateWrapper 显式地更新 parentDatasetId 字段
+                // 这样即使值为 null 也能被正确更新到数据库
+                datasetRepository.update(null, new LambdaUpdateWrapper<Dataset>()
+                    .eq(Dataset::getId, datasetId)
+                    .set(Dataset::getParentDatasetId, dataset.getParentDatasetId()));
+            }
         }
+        
         if (StringUtils.hasText(updateDatasetRequest.getDataSource())) {
             // 数据源id不为空，使用异步线程进行文件扫盘落库
             processDataSourceAsync(dataset.getId(), updateDatasetRequest.getDataSource());
         }
+        
+        // 更新其他字段（不包括 parentDatasetId，因为它已经在上面的代码中更新了）
         datasetRepository.updateById(dataset);
         return dataset;
     }
@@ -142,6 +166,7 @@ public class DatasetApplicationService {
         BusinessAssert.notNull(dataset, DataManagementErrorCode.DATASET_NOT_FOUND);
         List<DatasetFile> datasetFiles = datasetFileRepository.findAllByDatasetId(datasetId);
         dataset.setFiles(datasetFiles);
+        applyVisibleFileCounts(Collections.singletonList(dataset));
         return dataset;
     }
 
@@ -153,6 +178,7 @@ public class DatasetApplicationService {
         IPage<Dataset> page = new Page<>(query.getPage(), query.getSize());
         page = datasetRepository.findByCriteria(page, query);
         String datasetPvcName = getDatasetPvcName();
+        applyVisibleFileCounts(page.getRecords());
         List<DatasetResponse> datasetResponses = DatasetConverter.INSTANCE.convertToResponse(page.getRecords());
         datasetResponses.forEach(dataset -> dataset.setPvcName(datasetPvcName));
         return PagedResponse.of(datasetResponses, page.getCurrent(), page.getTotal(), page.getPages());
@@ -200,6 +226,7 @@ public class DatasetApplicationService {
             })
             .limit(safeLimit)
             .toList();
+        applyVisibleFileCounts(sorted);
         List<DatasetResponse> responses = DatasetConverter.INSTANCE.convertToResponse(sorted);
         responses.forEach(item -> item.setPvcName(datasetPvcName));
         return responses;
@@ -345,6 +372,61 @@ public class DatasetApplicationService {
         dataset.setPath(newPath);
     }
 
+    private void applyVisibleFileCounts(List<Dataset> datasets) {
+        if (CollectionUtils.isEmpty(datasets)) {
+            return;
+        }
+        List<String> datasetIds = datasets.stream()
+            .filter(Objects::nonNull)
+            .map(Dataset::getId)
+            .filter(StringUtils::hasText)
+            .toList();
+        if (datasetIds.isEmpty()) {
+            return;
+        }
+        Map<String, Long> countMap = datasetFileRepository.countNonDerivedByDatasetIds(datasetIds).stream()
+            .filter(Objects::nonNull)
+            .collect(Collectors.toMap(
+                DatasetFileCount::getDatasetId,
+                count -> Optional.ofNullable(count.getFileCount()).orElse(0L),
+                (left, right) -> left
+            ));
+        for (Dataset dataset : datasets) {
+            if (dataset == null || !StringUtils.hasText(dataset.getId())) {
+                continue;
+            }
+            Long visibleCount = countMap.get(dataset.getId());
+            dataset.setFileCount(visibleCount != null ? visibleCount : 0L);
+        }
+    }
+
+    private List<DatasetFile> filterVisibleFiles(List<DatasetFile> files) {
+        if (CollectionUtils.isEmpty(files)) {
+            return Collections.emptyList();
+        }
+        return files.stream()
+            .filter(file -> !isDerivedFile(file))
+            .collect(Collectors.toList());
+    }
+
+    private boolean isDerivedFile(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String metadata = datasetFile.getMetadata();
+        if (!StringUtils.hasText(metadata)) {
+            return false;
+        }
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            Map<String, Object> metadataMap = mapper.readValue(metadata, new TypeReference<Map<String, Object>>() {});
+            return metadataMap.get(DERIVED_METADATA_KEY) != null;
+        } catch (Exception e) {
+            log.debug("Failed to parse dataset file metadata for derived detection: {}", datasetFile.getId(), e);
+            return false;
+        }
+    }
+
     /**
      * 获取数据集统计信息
      */
@@ -357,27 +439,29 @@ public class DatasetApplicationService {
 
         Map<String, Object> statistics = new HashMap<>();
 
-        // 基础统计
+        List<DatasetFile> allFiles = datasetFileRepository.findAllByDatasetId(datasetId);
-        Long totalFiles = datasetFileRepository.countByDatasetId(datasetId);
+        List<DatasetFile> visibleFiles = filterVisibleFiles(allFiles);
-        Long completedFiles = datasetFileRepository.countCompletedByDatasetId(datasetId);
+        long totalFiles = visibleFiles.size();
+        long completedFiles = visibleFiles.stream()
+            .filter(file -> "COMPLETED".equalsIgnoreCase(file.getStatus()))
+            .count();
         Long totalSize = datasetFileRepository.sumSizeByDatasetId(datasetId);
 
-        statistics.put("totalFiles", totalFiles != null ? totalFiles.intValue() : 0);
+        statistics.put("totalFiles", (int) totalFiles);
-        statistics.put("completedFiles", completedFiles != null ? completedFiles.intValue() : 0);
+        statistics.put("completedFiles", (int) completedFiles);
         statistics.put("totalSize", totalSize != null ? totalSize : 0L);
 
         // 完成率计算
         float completionRate = 0.0f;
-        if (totalFiles != null && totalFiles > 0) {
+        if (totalFiles > 0) {
-            completionRate = (completedFiles != null ? completedFiles.floatValue() : 0.0f) / totalFiles.floatValue() * 100.0f;
+            completionRate = ((float) completedFiles) / (float) totalFiles * 100.0f;
         }
         statistics.put("completionRate", completionRate);
 
         // 文件类型分布统计
         Map<String, Integer> fileTypeDistribution = new HashMap<>();
-        List<DatasetFile> allFiles = datasetFileRepository.findAllByDatasetId(datasetId);
+        if (!visibleFiles.isEmpty()) {
-        if (allFiles != null) {
+            for (DatasetFile file : visibleFiles) {
-            for (DatasetFile file : allFiles) {
                 String fileType = file.getFileType() != null ? file.getFileType() : "unknown";
                 fileTypeDistribution.put(fileType, fileTypeDistribution.getOrDefault(fileType, 0) + 1);
             }
@@ -386,8 +470,8 @@ public class DatasetApplicationService {
 
         // 状态分布统计
         Map<String, Integer> statusDistribution = new HashMap<>();
-        if (allFiles != null) {
+        if (!visibleFiles.isEmpty()) {
-            for (DatasetFile file : allFiles) {
+            for (DatasetFile file : visibleFiles) {
                 String status = file.getStatus() != null ? file.getStatus() : "unknown";
                 statusDistribution.put(status, statusDistribution.getOrDefault(status, 0) + 1);
             }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFileApplicationService.java

@@ -28,6 +28,7 @@ import com.datamate.datamanagement.interfaces.dto.CopyFilesRequest;
 import com.datamate.datamanagement.interfaces.dto.CreateDirectoryRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadFilesPreRequest;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.servlet.http.HttpServletResponse;
@@ -42,6 +43,8 @@ import org.springframework.core.io.UrlResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 import java.io.File;
 import java.io.IOException;
@@ -70,12 +73,22 @@ public class DatasetFileApplicationService {
     private static final String PDF_FILE_TYPE = "pdf";
     private static final String DOC_FILE_TYPE = "doc";
     private static final String DOCX_FILE_TYPE = "docx";
-    private static final Set<String> DOCUMENT_TEXT_FILE_TYPES = Set.of(PDF_FILE_TYPE, DOC_FILE_TYPE, DOCX_FILE_TYPE);
+    private static final String XLS_FILE_TYPE = "xls";
+    private static final String XLSX_FILE_TYPE = "xlsx";
+    private static final Set<String> DOCUMENT_TEXT_FILE_TYPES = Set.of(
+        PDF_FILE_TYPE,
+        DOC_FILE_TYPE,
+        DOCX_FILE_TYPE,
+        XLS_FILE_TYPE,
+        XLSX_FILE_TYPE
+    );
+    private static final String DERIVED_METADATA_KEY = "derived_from_file_id";
 
     private final DatasetFileRepository datasetFileRepository;
     private final DatasetRepository datasetRepository;
     private final FileService fileService;
     private final PdfTextExtractAsyncService pdfTextExtractAsyncService;
+    private final DatasetFilePreviewService datasetFilePreviewService;
 
     @Value("${datamate.data-management.base-path:/dataset}")
     private String datasetBasePath;
@@ -87,11 +100,13 @@ public class DatasetFileApplicationService {
     public DatasetFileApplicationService(DatasetFileRepository datasetFileRepository,
                                          DatasetRepository datasetRepository,
                                          FileService fileService,
-                                         PdfTextExtractAsyncService pdfTextExtractAsyncService) {
+                                         PdfTextExtractAsyncService pdfTextExtractAsyncService,
+                                         DatasetFilePreviewService datasetFilePreviewService) {
         this.datasetFileRepository = datasetFileRepository;
         this.datasetRepository = datasetRepository;
         this.fileService = fileService;
         this.pdfTextExtractAsyncService = pdfTextExtractAsyncService;
+        this.datasetFilePreviewService = datasetFilePreviewService;
     }
 
     /**
@@ -111,7 +126,7 @@ public class DatasetFileApplicationService {
      * @param status                状态过滤
      * @param name                  文件名模糊查询
      * @param hasAnnotation         是否有标注
-     * @param excludeSourceDocuments 是否排除已被转换为TXT的源文档（PDF/DOC/DOCX）
+     * @param excludeSourceDocuments 是否排除源文档（PDF/DOC/DOCX/XLS/XLSX）
      * @param pagingQuery           分页参数
      * @return 分页文件列表
      */
@@ -122,19 +137,15 @@ public class DatasetFileApplicationService {
         IPage<DatasetFile> files = datasetFileRepository.findByCriteria(datasetId, fileType, status, name, hasAnnotation, page);
         
         if (excludeSourceDocuments) {
-            // 查询所有作为衍生TXT文件源的文档文件ID
+            // 过滤掉源文档文件（PDF/DOC/DOCX/XLS/XLSX），用于标注场景只展示派生文件
-            List<String> sourceFileIds = datasetFileRepository.findSourceFileIdsWithDerivedFiles(datasetId);
+            List<DatasetFile> filteredRecords = files.getRecords().stream()
-            if (!sourceFileIds.isEmpty()) {
+                .filter(file -> !isSourceDocument(file))
-                // 过滤掉源文件
+                .collect(Collectors.toList());
-                List<DatasetFile> filteredRecords = files.getRecords().stream()
-                        .filter(file -> !sourceFileIds.contains(file.getId()))
-                        .collect(Collectors.toList());
 
-                // 重新构建分页结果
+            // 重新构建分页结果
-                Page<DatasetFile> filteredPage = new Page<>(files.getCurrent(), files.getSize(), files.getTotal());
+            Page<DatasetFile> filteredPage = new Page<>(files.getCurrent(), files.getSize(), files.getTotal());
-                filteredPage.setRecords(filteredRecords);
+            filteredPage.setRecords(filteredRecords);
-                return PagedResponse.of(filteredPage);
+            return PagedResponse.of(filteredPage);
-            }
         }
         
         return PagedResponse.of(files);
@@ -144,7 +155,7 @@ public class DatasetFileApplicationService {
      * 获取数据集文件列表
      */
     @Transactional(readOnly = true)
-    public PagedResponse<DatasetFile> getDatasetFilesWithDirectory(String datasetId, String prefix, PagingQuery pagingQuery) {
+    public PagedResponse<DatasetFile> getDatasetFilesWithDirectory(String datasetId, String prefix, boolean excludeDerivedFiles, PagingQuery pagingQuery) {
         Dataset dataset = datasetRepository.getById(datasetId);
         int page = Math.max(pagingQuery.getPage(), 1);
         int size = pagingQuery.getSize() == null || pagingQuery.getSize() < 0 ? 20 : pagingQuery.getSize();
@@ -154,10 +165,31 @@ public class DatasetFileApplicationService {
         String datasetPath = dataset.getPath();
         Path queryPath = Path.of(dataset.getPath() + File.separator + prefix);
         Map<String, DatasetFile> datasetFilesMap = datasetFileRepository.findAllByDatasetId(datasetId)
-            .stream().collect(Collectors.toMap(DatasetFile::getFilePath, Function.identity()));
+            .stream()
+            .filter(file -> file.getFilePath() != null)
+            .collect(Collectors.toMap(
+                file -> normalizeFilePath(file.getFilePath()),
+                Function.identity(),
+                (left, right) -> left
+            ));
+        Set<String> derivedFilePaths = excludeDerivedFiles
+            ? datasetFilesMap.values().stream()
+                .filter(this::isDerivedFile)
+                .map(DatasetFile::getFilePath)
+                .map(this::normalizeFilePath)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet())
+            : Collections.emptySet();
+        // 如果目录不存在，直接返回空结果（数据集刚创建时目录可能还未生成）
+        if (!Files.exists(queryPath)) {
+            return new PagedResponse<>(page, size, 0, 0, Collections.emptyList());
+        }
         try (Stream<Path> pathStream = Files.list(queryPath)) {
             List<Path> allFiles = pathStream
                 .filter(path -> path.toString().startsWith(datasetPath))
+                .filter(path -> !excludeDerivedFiles
+                    || Files.isDirectory(path)
+                    || !derivedFilePaths.contains(normalizeFilePath(path.toString())))
                 .sorted(Comparator
                     .comparing((Path path) -> !Files.isDirectory(path))
                     .thenComparing(path -> path.getFileName().toString()))
@@ -176,7 +208,9 @@ public class DatasetFileApplicationService {
             if (fromIndex < total) {
                 pageData = allFiles.subList(fromIndex, toIndex);
             }
-            List<DatasetFile> datasetFiles = pageData.stream().map(path -> getDatasetFile(path, datasetFilesMap)).toList();
+            List<DatasetFile> datasetFiles = pageData.stream()
+                .map(path -> getDatasetFile(path, datasetFilesMap, excludeDerivedFiles, derivedFilePaths))
+                .toList();
 
             return new PagedResponse<>(page, size, total, totalPages, datasetFiles);
         } catch (IOException e) {
@@ -185,7 +219,10 @@ public class DatasetFileApplicationService {
         }
     }
 
-    private DatasetFile getDatasetFile(Path path, Map<String, DatasetFile> datasetFilesMap) {
+    private DatasetFile getDatasetFile(Path path,
+                                       Map<String, DatasetFile> datasetFilesMap,
+                                       boolean excludeDerivedFiles,
+                                       Set<String> derivedFilePaths) {
         DatasetFile datasetFile = new DatasetFile();
         LocalDateTime localDateTime = LocalDateTime.now();
         try {
@@ -207,12 +244,21 @@ public class DatasetFileApplicationService {
                 long totalSize;
 
                 try (Stream<Path> walk = Files.walk(path)) {
-                    fileCount = walk.filter(Files::isRegularFile).count();
+                    Stream<Path> fileStream = walk.filter(Files::isRegularFile);
+                    if (excludeDerivedFiles && !derivedFilePaths.isEmpty()) {
+                        fileStream = fileStream.filter(filePath ->
+                            !derivedFilePaths.contains(normalizeFilePath(filePath.toString())));
+                    }
+                    fileCount = fileStream.count();
                 }
 
                 try (Stream<Path> walk = Files.walk(path)) {
-                    totalSize = walk
+                    Stream<Path> fileStream = walk.filter(Files::isRegularFile);
-                        .filter(Files::isRegularFile)
+                    if (excludeDerivedFiles && !derivedFilePaths.isEmpty()) {
+                        fileStream = fileStream.filter(filePath ->
+                            !derivedFilePaths.contains(normalizeFilePath(filePath.toString())));
+                    }
+                    totalSize = fileStream
                         .mapToLong(p -> {
                             try {
                                 return Files.size(p);
@@ -230,7 +276,7 @@ public class DatasetFileApplicationService {
                 log.error("stat directory info error", e);
             }
         } else {
-            DatasetFile exist = datasetFilesMap.get(path.toString());
+            DatasetFile exist = datasetFilesMap.get(normalizeFilePath(path.toString()));
             if (exist == null) {
                 datasetFile.setId("file-" + datasetFile.getFileName());
                 datasetFile.setFileSize(path.toFile().length());
@@ -241,6 +287,46 @@ public class DatasetFileApplicationService {
         return datasetFile;
     }
 
+    private String normalizeFilePath(String filePath) {
+        if (filePath == null || filePath.isBlank()) {
+            return null;
+        }
+        try {
+            return Paths.get(filePath).toAbsolutePath().normalize().toString();
+        } catch (Exception e) {
+            return filePath.replace("\\", "/");
+        }
+    }
+
+    private boolean isSourceDocument(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String fileType = datasetFile.getFileType();
+        if (fileType == null || fileType.isBlank()) {
+            return false;
+        }
+        return DOCUMENT_TEXT_FILE_TYPES.contains(fileType.toLowerCase(Locale.ROOT));
+    }
+
+    private boolean isDerivedFile(DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return false;
+        }
+        String metadata = datasetFile.getMetadata();
+        if (metadata == null || metadata.isBlank()) {
+            return false;
+        }
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            Map<String, Object> metadataMap = mapper.readValue(metadata, new TypeReference<Map<String, Object>>() {});
+            return metadataMap.get(DERIVED_METADATA_KEY) != null;
+        } catch (Exception e) {
+            log.debug("Failed to parse dataset file metadata for derived detection: {}", datasetFile.getId(), e);
+            return false;
+        }
+    }
+
     /**
      * 获取文件详情
      */
@@ -267,6 +353,7 @@ public class DatasetFileApplicationService {
         datasetFileRepository.removeById(fileId);
         dataset.removeFile(file);
         datasetRepository.updateById(dataset);
+        datasetFilePreviewService.deletePreviewFileQuietly(datasetId, fileId);
         // 删除文件时，上传到数据集中的文件会同时删除数据库中的记录和文件系统中的文件，归集过来的文件仅删除数据库中的记录
         if (file.getFilePath().startsWith(dataset.getPath())) {
             try {
@@ -418,6 +505,14 @@ public class DatasetFileApplicationService {
         saveFileInfoToDb(uploadResult, datasetId);
     }
 
+    /**
+     * 取消上传
+     */
+    @Transactional
+    public void cancelUpload(String reqId) {
+        fileService.cancelUpload(reqId);
+    }
+
     private void saveFileInfoToDb(FileUploadResult fileUploadResult, String datasetId) {
         if (Objects.isNull(fileUploadResult.getSavedFile())) {
             // 文件切片上传没有完成
@@ -639,6 +734,7 @@ public class DatasetFileApplicationService {
 
         for (DatasetFile file : filesToDelete) {
             datasetFileRepository.removeById(file.getId());
+            datasetFilePreviewService.deletePreviewFileQuietly(datasetId, file.getId());
         }
 
         // 删除文件系统中的目录
@@ -918,6 +1014,20 @@ public class DatasetFileApplicationService {
         if (fileType == null || !DOCUMENT_TEXT_FILE_TYPES.contains(fileType.toLowerCase(Locale.ROOT))) {
             return;
         }
-        pdfTextExtractAsyncService.extractPdfText(dataset.getId(), datasetFile.getId());
+        String datasetId = dataset.getId();
+        String fileId = datasetFile.getId();
+        if (datasetId == null || fileId == null) {
+            return;
+        }
+        if (TransactionSynchronizationManager.isSynchronizationActive()) {
+            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
+                @Override
+                public void afterCommit() {
+                    pdfTextExtractAsyncService.extractPdfText(datasetId, fileId);
+                }
+            });
+            return;
+        }
+        pdfTextExtractAsyncService.extractPdfText(datasetId, fileId);
     }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFilePreviewAsyncService.java

@@ -0,0 +1,171 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Set;
+
+/**
+ * 数据集文件预览转换异步任务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DatasetFilePreviewAsyncService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String DATASET_PREVIEW_DIR = "dataset-previews";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final int MAX_ERROR_LENGTH = 500;
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final DatasetFileRepository datasetFileRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Async
+    public void convertPreviewAsync(String fileId) {
+        if (StringUtils.isBlank(fileId)) {
+            return;
+        }
+        DatasetFile file = datasetFileRepository.getById(fileId);
+        if (file == null) {
+            return;
+        }
+        String extension = resolveFileExtension(resolveOriginalName(file));
+        if (!OFFICE_EXTENSIONS.contains(extension)) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "仅支持 DOC/DOCX 转换");
+            return;
+        }
+        if (StringUtils.isBlank(file.getFilePath())) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "源文件路径为空");
+            return;
+        }
+        Path sourcePath = Paths.get(file.getFilePath()).toAbsolutePath().normalize();
+        if (!Files.exists(sourcePath) || !Files.isRegularFile(sourcePath)) {
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, null, "源文件不存在");
+            return;
+        }
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+        String previewRelativePath = StringUtils.defaultIfBlank(
+            previewInfo.pdfPath(),
+            resolvePreviewRelativePath(file.getDatasetId(), file.getId())
+        );
+        Path targetPath = resolvePreviewStoragePath(previewRelativePath);
+
+        try {
+            ensureParentDirectory(targetPath);
+            LibreOfficeConverter.convertToPdf(sourcePath, targetPath);
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.READY, previewRelativePath, null);
+        } catch (Exception e) {
+            log.error("dataset preview convert failed, fileId: {}", file.getId(), e);
+            updatePreviewStatus(file, KnowledgeItemPreviewStatus.FAILED, previewRelativePath, trimError(e.getMessage()));
+        }
+    }
+
+    private void updatePreviewStatus(
+        DatasetFile file,
+        KnowledgeItemPreviewStatus status,
+        String previewRelativePath,
+        String error
+    ) {
+        if (file == null) {
+            return;
+        }
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            status,
+            previewRelativePath,
+            error,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+    }
+
+    private String resolveOriginalName(DatasetFile file) {
+        if (file == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(file.getFileName())) {
+            return file.getFileName();
+        }
+        if (StringUtils.isNotBlank(file.getFilePath())) {
+            return Paths.get(file.getFilePath()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewRelativePath(String datasetId, String fileId) {
+        String relativePath = Paths.get(DATASET_PREVIEW_DIR, datasetId, fileId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid preview path");
+        }
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private void ensureParentDirectory(Path targetPath) {
+        try {
+            Path parent = targetPath.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+        } catch (Exception e) {
+            throw new IllegalStateException("创建预览目录失败", e);
+        }
+    }
+
+    private String trimError(String error) {
+        if (StringUtils.isBlank(error)) {
+            return "";
+        }
+        if (error.length() <= MAX_ERROR_LENGTH) {
+            return error;
+        }
+        return error.substring(0, MAX_ERROR_LENGTH);
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/DatasetFilePreviewService.java

@@ -0,0 +1,233 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.datamate.datamanagement.interfaces.dto.DatasetFilePreviewStatusResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * 数据集文件预览转换服务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DatasetFilePreviewService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String DATASET_PREVIEW_DIR = "dataset-previews";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final DatasetFileRepository datasetFileRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final DatasetFilePreviewAsyncService datasetFilePreviewAsyncService;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    public DatasetFilePreviewStatusResponse getPreviewStatus(String datasetId, String fileId) {
+        DatasetFile file = requireDatasetFile(datasetId, fileId);
+        assertOfficeDocument(file);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && !previewPdfExists(file, previewInfo)) {
+            previewInfo = markPreviewFailed(file, previewInfo, "预览文件不存在");
+        }
+
+        return buildResponse(previewInfo);
+    }
+
+    public DatasetFilePreviewStatusResponse ensurePreview(String datasetId, String fileId) {
+        DatasetFile file = requireDatasetFile(datasetId, fileId);
+        assertOfficeDocument(file);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && previewPdfExists(file, previewInfo)) {
+            return buildResponse(previewInfo);
+        }
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.PROCESSING) {
+            return buildResponse(previewInfo);
+        }
+
+        String previewRelativePath = resolvePreviewRelativePath(file.getDatasetId(), file.getId());
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.PROCESSING,
+            previewRelativePath,
+            null,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+        datasetFilePreviewAsyncService.convertPreviewAsync(file.getId());
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo refreshed = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(updatedMetadata, objectMapper);
+        return buildResponse(refreshed);
+    }
+
+    public boolean isOfficeDocument(String fileName) {
+        String extension = resolveFileExtension(fileName);
+        return StringUtils.isNotBlank(extension) && OFFICE_EXTENSIONS.contains(extension.toLowerCase());
+    }
+
+    public PreviewFile resolveReadyPreviewFile(String datasetId, DatasetFile file) {
+        if (file == null) {
+            return null;
+        }
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(file.getMetadata(), objectMapper);
+        if (previewInfo.status() != KnowledgeItemPreviewStatus.READY) {
+            return null;
+        }
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(datasetId, file.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+            markPreviewFailed(file, previewInfo, "预览文件不存在");
+            return null;
+        }
+        String previewName = resolvePreviewPdfName(file);
+        return new PreviewFile(filePath, previewName);
+    }
+
+    public void deletePreviewFileQuietly(String datasetId, String fileId) {
+        String relativePath = resolvePreviewRelativePath(datasetId, fileId);
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        try {
+            Files.deleteIfExists(filePath);
+        } catch (Exception e) {
+            log.warn("delete dataset preview pdf error, fileId: {}", fileId, e);
+        }
+    }
+
+    private DatasetFilePreviewStatusResponse buildResponse(KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        DatasetFilePreviewStatusResponse response = new DatasetFilePreviewStatusResponse();
+        KnowledgeItemPreviewStatus status = previewInfo.status() == null
+            ? KnowledgeItemPreviewStatus.PENDING
+            : previewInfo.status();
+        response.setStatus(status);
+        response.setPreviewError(previewInfo.error());
+        response.setUpdatedAt(previewInfo.updatedAt());
+        return response;
+    }
+
+    private DatasetFile requireDatasetFile(String datasetId, String fileId) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(datasetId), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(StringUtils.isNotBlank(fileId), CommonErrorCode.PARAM_ERROR);
+        DatasetFile datasetFile = datasetFileRepository.getById(fileId);
+        BusinessAssert.notNull(datasetFile, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(Objects.equals(datasetFile.getDatasetId(), datasetId), CommonErrorCode.PARAM_ERROR);
+        return datasetFile;
+    }
+
+    private void assertOfficeDocument(DatasetFile file) {
+        BusinessAssert.notNull(file, CommonErrorCode.PARAM_ERROR);
+        String extension = resolveFileExtension(resolveOriginalName(file));
+        BusinessAssert.isTrue(OFFICE_EXTENSIONS.contains(extension), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String resolveOriginalName(DatasetFile file) {
+        if (file == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(file.getFileName())) {
+            return file.getFileName();
+        }
+        if (StringUtils.isNotBlank(file.getFilePath())) {
+            return Paths.get(file.getFilePath()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewPdfName(DatasetFile file) {
+        String originalName = resolveOriginalName(file);
+        if (StringUtils.isBlank(originalName)) {
+            return "预览.pdf";
+        }
+        int dotIndex = originalName.lastIndexOf('.');
+        if (dotIndex <= 0) {
+            return originalName + PREVIEW_FILE_SUFFIX;
+        }
+        return originalName.substring(0, dotIndex) + PREVIEW_FILE_SUFFIX;
+    }
+
+    private boolean previewPdfExists(DatasetFile file, KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(file.getDatasetId(), file.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        return Files.exists(filePath) && Files.isRegularFile(filePath);
+    }
+
+    private KnowledgeItemPreviewMetadataHelper.PreviewInfo markPreviewFailed(
+        DatasetFile file,
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo,
+        String error
+    ) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(file.getDatasetId(), file.getId()));
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            file.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.FAILED,
+            relativePath,
+            error,
+            nowText()
+        );
+        file.setMetadata(updatedMetadata);
+        datasetFileRepository.updateById(file);
+        return KnowledgeItemPreviewMetadataHelper.readPreviewInfo(updatedMetadata, objectMapper);
+    }
+
+    private String resolvePreviewRelativePath(String datasetId, String fileId) {
+        String relativePath = Paths.get(DATASET_PREVIEW_DIR, datasetId, fileId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        BusinessAssert.isTrue(StringUtils.isNotBlank(uploadDir), CommonErrorCode.PARAM_ERROR);
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+
+    public record PreviewFile(Path filePath, String fileName) {
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeDirectoryApplicationService.java

@@ -0,0 +1,142 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeStatusType;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
+import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorCode;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemDirectoryRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeSetRepository;
+import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * 知识条目目录应用服务
+ */
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class KnowledgeDirectoryApplicationService {
+    private static final String PATH_SEPARATOR = "/";
+    private static final String INVALID_PATH_SEGMENT = "..";
+
+    private final KnowledgeItemDirectoryRepository knowledgeItemDirectoryRepository;
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final KnowledgeSetRepository knowledgeSetRepository;
+
+    @Transactional(readOnly = true)
+    public List<KnowledgeItemDirectory> getKnowledgeDirectories(String setId, KnowledgeDirectoryQuery query) {
+        BusinessAssert.notNull(query, CommonErrorCode.PARAM_ERROR);
+        query.setSetId(setId);
+        return knowledgeItemDirectoryRepository.findByCriteria(query);
+    }
+
+    public KnowledgeItemDirectory createKnowledgeDirectory(String setId, CreateKnowledgeDirectoryRequest request) {
+        BusinessAssert.notNull(request, CommonErrorCode.PARAM_ERROR);
+        KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
+        BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
+            DataManagementErrorCode.KNOWLEDGE_SET_STATUS_ERROR);
+
+        String directoryName = normalizeDirectoryName(request.getDirectoryName());
+        validateDirectoryName(directoryName);
+
+        String parentPrefix = normalizeRelativePathPrefix(request.getParentPrefix());
+        String relativePath = normalizeRelativePathValue(parentPrefix + directoryName);
+        validateRelativePath(relativePath);
+
+        BusinessAssert.isTrue(!knowledgeItemRepository.existsBySetIdAndRelativePath(setId, relativePath),
+            CommonErrorCode.PARAM_ERROR);
+
+        KnowledgeItemDirectory existing = knowledgeItemDirectoryRepository.findBySetIdAndPath(setId, relativePath);
+        if (existing != null) {
+            return existing;
+        }
+
+        KnowledgeItemDirectory directory = new KnowledgeItemDirectory();
+        directory.setId(UUID.randomUUID().toString());
+        directory.setSetId(setId);
+        directory.setName(directoryName);
+        directory.setRelativePath(relativePath);
+        knowledgeItemDirectoryRepository.save(directory);
+        return directory;
+    }
+
+    public void deleteKnowledgeDirectory(String setId, String relativePath) {
+        KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
+        BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
+            DataManagementErrorCode.KNOWLEDGE_SET_STATUS_ERROR);
+
+        String normalized = normalizeRelativePathValue(relativePath);
+        validateRelativePath(normalized);
+
+        knowledgeItemRepository.removeByRelativePathPrefix(setId, normalized);
+        knowledgeItemDirectoryRepository.removeByRelativePathPrefix(setId, normalized);
+    }
+
+    private KnowledgeSet requireKnowledgeSet(String setId) {
+        KnowledgeSet knowledgeSet = knowledgeSetRepository.getById(setId);
+        BusinessAssert.notNull(knowledgeSet, DataManagementErrorCode.KNOWLEDGE_SET_NOT_FOUND);
+        return knowledgeSet;
+    }
+
+    private boolean isReadOnlyStatus(KnowledgeStatusType status) {
+        return status == KnowledgeStatusType.ARCHIVED || status == KnowledgeStatusType.DEPRECATED;
+    }
+
+    private String normalizeDirectoryName(String name) {
+        return StringUtils.trimToEmpty(name);
+    }
+
+    private void validateDirectoryName(String name) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(name), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains(PATH_SEPARATOR), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains("\\"), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!name.contains(INVALID_PATH_SEGMENT), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private void validateRelativePath(String relativePath) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(!relativePath.contains(INVALID_PATH_SEGMENT), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String normalizeRelativePathPrefix(String prefix) {
+        if (StringUtils.isBlank(prefix)) {
+            return "";
+        }
+        String normalized = prefix.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        validateRelativePath(normalized);
+        return normalized + PATH_SEPARATOR;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemApplicationService.java

@@ -16,15 +16,20 @@ import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
 import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorCode;
+import com.datamate.datamanagement.infrastructure.persistence.mapper.TagMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeSetRepository;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
+import com.datamate.datamanagement.interfaces.dto.DeleteKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeManagementStatisticsResponse;
 import com.datamate.datamanagement.interfaces.dto.ReplaceKnowledgeItemFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadKnowledgeItemsRequest;
@@ -71,16 +76,20 @@ public class KnowledgeItemApplicationService {
     private static final String EXPORT_FILE_PREFIX = "knowledge_set_";
     private static final String EXPORT_FILE_SUFFIX = ".zip";
     private static final String EXPORT_CONTENT_TYPE = "application/zip";
+    private static final String PREVIEW_PDF_CONTENT_TYPE = "application/pdf";
     private static final int MAX_FILE_BASE_LENGTH = 120;
     private static final int MAX_TITLE_LENGTH = 200;
     private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
     private static final String DEFAULT_FILE_EXTENSION = "bin";
+    private static final String PATH_SEPARATOR = "/";
 
     private final KnowledgeItemRepository knowledgeItemRepository;
     private final KnowledgeSetRepository knowledgeSetRepository;
     private final DatasetRepository datasetRepository;
     private final DatasetFileRepository datasetFileRepository;
     private final DataManagementProperties dataManagementProperties;
+    private final TagMapper tagMapper;
+    private final KnowledgeItemPreviewService knowledgeItemPreviewService;
 
     public KnowledgeItem createKnowledgeItem(String setId, CreateKnowledgeItemRequest request) {
         KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
@@ -109,6 +118,7 @@ public class KnowledgeItemApplicationService {
 
         List<MultipartFile> files = request.getFiles();
         BusinessAssert.isTrue(CollectionUtils.isNotEmpty(files), CommonErrorCode.PARAM_ERROR);
+        String parentPrefix = normalizeRelativePathPrefix(request.getParentPrefix());
 
         Path uploadRoot = resolveUploadRootPath();
         Path setDir = uploadRoot.resolve(KNOWLEDGE_ITEM_UPLOAD_DIR).resolve(setId).normalize();
@@ -142,6 +152,7 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setContentType(KnowledgeContentType.FILE);
             knowledgeItem.setSourceType(KnowledgeSourceType.FILE_UPLOAD);
             knowledgeItem.setSourceFileId(trimToLength(safeOriginalName, MAX_TITLE_LENGTH));
+            knowledgeItem.setRelativePath(buildRelativePath(parentPrefix, safeOriginalName));
 
             items.add(knowledgeItem);
         }
@@ -167,6 +178,9 @@ public class KnowledgeItemApplicationService {
         if (request.getContentType() != null) {
             knowledgeItem.setContentType(request.getContentType());
         }
+        if (request.getMetadata() != null) {
+            knowledgeItem.setMetadata(request.getMetadata());
+        }
 
         knowledgeItemRepository.updateById(knowledgeItem);
         return knowledgeItem;
@@ -179,6 +193,22 @@ public class KnowledgeItemApplicationService {
         knowledgeItemRepository.removeById(itemId);
     }
 
+    public void deleteKnowledgeItems(String setId, DeleteKnowledgeItemsRequest request) {
+        BusinessAssert.notNull(request, CommonErrorCode.PARAM_ERROR);
+        List<String> ids = request.getIds();
+        BusinessAssert.isTrue(CollectionUtils.isNotEmpty(ids), CommonErrorCode.PARAM_ERROR);
+
+        List<KnowledgeItem> items = knowledgeItemRepository.listByIds(ids);
+        BusinessAssert.isTrue(CollectionUtils.isNotEmpty(items), DataManagementErrorCode.KNOWLEDGE_ITEM_NOT_FOUND);
+        BusinessAssert.isTrue(items.size() == ids.size(), DataManagementErrorCode.KNOWLEDGE_ITEM_NOT_FOUND);
+
+        boolean allMatch = items.stream().allMatch(item -> Objects.equals(item.getSetId(), setId));
+        BusinessAssert.isTrue(allMatch, CommonErrorCode.PARAM_ERROR);
+
+        List<String> deleteIds = items.stream().map(KnowledgeItem::getId).toList();
+        knowledgeItemRepository.removeByIds(deleteIds);
+    }
+
     @Transactional(readOnly = true)
     public KnowledgeItem getKnowledgeItem(String setId, String itemId) {
         KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
@@ -196,6 +226,40 @@ public class KnowledgeItemApplicationService {
         return PagedResponse.of(responses, page.getCurrent(), page.getTotal(), page.getPages());
     }
 
+    @Transactional(readOnly = true)
+    public KnowledgeManagementStatisticsResponse getKnowledgeManagementStatistics() {
+        KnowledgeManagementStatisticsResponse response = new KnowledgeManagementStatisticsResponse();
+        response.setTotalKnowledgeSets(knowledgeSetRepository.count());
+
+        long totalFiles = knowledgeItemRepository.countBySourceTypes(List.of(
+            KnowledgeSourceType.DATASET_FILE,
+            KnowledgeSourceType.FILE_UPLOAD
+        ));
+        response.setTotalFiles(totalFiles);
+
+        long datasetFileSize = safeLong(knowledgeItemRepository.sumDatasetFileSize());
+        long uploadFileSize = calculateUploadFileTotalSize();
+        response.setTotalSize(datasetFileSize + uploadFileSize);
+        response.setTotalTags(safeLong(tagMapper.countKnowledgeSetTags()));
+
+        return response;
+    }
+
+    @Transactional(readOnly = true)
+    public PagedResponse<KnowledgeItemSearchResponse> searchKnowledgeItems(KnowledgeItemSearchQuery query) {
+        BusinessAssert.notNull(query, CommonErrorCode.PARAM_ERROR);
+        String keyword = StringUtils.trimToEmpty(query.getKeyword());
+        BusinessAssert.isTrue(StringUtils.isNotBlank(keyword), CommonErrorCode.PARAM_ERROR);
+
+        IPage<KnowledgeItemSearchResponse> page = new Page<>(query.getPage(), query.getSize());
+        IPage<KnowledgeItemSearchResponse> result = knowledgeItemRepository.searchFileItems(page, keyword);
+        List<KnowledgeItemSearchResponse> responses = result.getRecords()
+            .stream()
+            .map(this::normalizeSearchResponse)
+            .toList();
+        return PagedResponse.of(responses, result.getCurrent(), result.getTotal(), result.getPages());
+    }
+
     public List<KnowledgeItem> importKnowledgeItems(String setId, ImportKnowledgeItemsRequest request) {
         KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
         BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
@@ -220,6 +284,7 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setSourceType(KnowledgeSourceType.DATASET_FILE);
             knowledgeItem.setSourceDatasetId(dataset.getId());
             knowledgeItem.setSourceFileId(datasetFile.getId());
+            knowledgeItem.setRelativePath(resolveDatasetFileRelativePath(dataset, datasetFile));
 
             items.add(knowledgeItem);
         }
@@ -271,7 +336,7 @@ public class KnowledgeItemApplicationService {
 
         String relativePath = knowledgeItem.getContent();
         BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
-        Path filePath = resolveKnowledgeItemStoragePath(relativePath);
+        Path filePath = resolveKnowledgeItemStoragePathWithFallback(relativePath);
         BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
 
         String downloadName = StringUtils.isNotBlank(knowledgeItem.getSourceFileId())
@@ -304,12 +369,32 @@ public class KnowledgeItemApplicationService {
 
         String relativePath = knowledgeItem.getContent();
         BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
-        Path filePath = resolveKnowledgeItemStoragePath(relativePath);
-        BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
-
         String previewName = StringUtils.isNotBlank(knowledgeItem.getSourceFileId())
             ? knowledgeItem.getSourceFileId()
-            : filePath.getFileName().toString();
+            : Paths.get(relativePath).getFileName().toString();
+
+        if (knowledgeItemPreviewService.isOfficeDocument(previewName)) {
+            KnowledgeItemPreviewService.PreviewFile previewFile = knowledgeItemPreviewService.resolveReadyPreviewFile(setId, knowledgeItem);
+            if (previewFile == null) {
+                response.setStatus(HttpServletResponse.SC_CONFLICT);
+                return;
+            }
+            response.setContentType(PREVIEW_PDF_CONTENT_TYPE);
+            response.setCharacterEncoding(StandardCharsets.UTF_8.name());
+            response.setHeader(HttpHeaders.CONTENT_DISPOSITION,
+                "inline; filename=\"" + URLEncoder.encode(previewFile.fileName(), StandardCharsets.UTF_8) + "\"");
+            try (InputStream inputStream = Files.newInputStream(previewFile.filePath())) {
+                inputStream.transferTo(response.getOutputStream());
+                response.flushBuffer();
+            } catch (IOException e) {
+                log.error("preview knowledge item pdf error, itemId: {}", itemId, e);
+                throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
+            }
+            return;
+        }
+
+        Path filePath = resolveKnowledgeItemStoragePathWithFallback(relativePath);
+        BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
 
         String contentType = null;
         try {
@@ -382,7 +467,10 @@ public class KnowledgeItemApplicationService {
             knowledgeItem.setContentType(KnowledgeContentType.FILE);
             knowledgeItem.setSourceType(KnowledgeSourceType.FILE_UPLOAD);
             knowledgeItem.setSourceFileId(sourceFileId);
+            knowledgeItem.setRelativePath(resolveReplacedRelativePath(knowledgeItem.getRelativePath(), sourceFileId));
+            knowledgeItem.setMetadata(knowledgeItemPreviewService.clearPreviewMetadata(knowledgeItem.getMetadata()));
             knowledgeItemRepository.updateById(knowledgeItem);
+            knowledgeItemPreviewService.deletePreviewFileQuietly(setId, knowledgeItem.getId());
             deleteFile(oldFilePath);
         } catch (Exception e) {
             deleteFileQuietly(targetPath);
@@ -447,11 +535,221 @@ public class KnowledgeItemApplicationService {
         return target;
     }
 
+    private Path resolveKnowledgeItemStoragePathWithFallback(String relativePath) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
+        String normalizedInput = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        Path root = resolveUploadRootPath();
+        java.util.LinkedHashSet<Path> candidates = new java.util.LinkedHashSet<>();
+
+        Path inputPath = Paths.get(normalizedInput.replace(PATH_SEPARATOR, File.separator));
+        if (inputPath.isAbsolute()) {
+            Path normalizedAbsolute = inputPath.toAbsolutePath().normalize();
+            if (normalizedAbsolute.startsWith(root)) {
+                candidates.add(normalizedAbsolute);
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            BusinessAssert.isTrue(!candidates.isEmpty(), CommonErrorCode.PARAM_ERROR);
+        } else {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, normalizedRelative));
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && !normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)
+                    && !normalizedRelative.equals(KNOWLEDGE_ITEM_UPLOAD_DIR)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR + normalizedRelative));
+            }
+        }
+
+        if (root.getFileName() != null && KNOWLEDGE_ITEM_UPLOAD_DIR.equals(root.getFileName().toString())) {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)) {
+                String withoutPrefix = normalizedRelative.substring(KNOWLEDGE_ITEM_UPLOAD_DIR.length() + PATH_SEPARATOR.length());
+                if (StringUtils.isNotBlank(withoutPrefix)) {
+                    candidates.add(buildKnowledgeItemStoragePath(root, withoutPrefix));
+                }
+            }
+        }
+
+        Path fallback = null;
+        for (Path candidate : candidates) {
+            if (fallback == null) {
+                fallback = candidate;
+            }
+            if (Files.exists(candidate) && Files.isRegularFile(candidate)) {
+                return candidate;
+            }
+        }
+        BusinessAssert.notNull(fallback, CommonErrorCode.PARAM_ERROR);
+        return fallback;
+    }
+
+    private Path buildKnowledgeItemStoragePath(Path root, String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace(PATH_SEPARATOR, File.separator);
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private String extractRelativePathFromSegment(String rawPath, String segment) {
+        if (StringUtils.isBlank(rawPath) || StringUtils.isBlank(segment)) {
+            return null;
+        }
+        String normalized = rawPath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        String segmentPrefix = segment + PATH_SEPARATOR;
+        int index = normalized.indexOf(segmentPrefix);
+        if (index < 0) {
+            return segment.equals(normalized) ? segment : null;
+        }
+        return normalizeRelativePathValue(normalized.substring(index));
+    }
+
+    private KnowledgeItemSearchResponse normalizeSearchResponse(KnowledgeItemSearchResponse item) {
+        BusinessAssert.notNull(item, CommonErrorCode.PARAM_ERROR);
+        if (item.getSourceType() == KnowledgeSourceType.FILE_UPLOAD) {
+            item.setFileSize(resolveUploadFileSize(item.getContent()));
+            if (StringUtils.isBlank(item.getFileName())) {
+                item.setFileName(item.getSourceFileId());
+            }
+        }
+        if (item.getSourceType() == KnowledgeSourceType.DATASET_FILE) {
+            if (item.getFileSize() == null) {
+                item.setFileSize(0L);
+            }
+            if (StringUtils.isBlank(item.getFileName())) {
+                item.setFileName(item.getSourceFileId());
+            }
+        }
+        item.setContent(null);
+        return item;
+    }
+
+    private long calculateUploadFileTotalSize() {
+        List<KnowledgeItem> items = knowledgeItemRepository.findFileUploadItems();
+        if (CollectionUtils.isEmpty(items)) {
+            return 0L;
+        }
+        long total = 0L;
+        for (KnowledgeItem item : items) {
+            total += resolveUploadFileSize(item.getContent());
+        }
+        return total;
+    }
+
+    private long resolveUploadFileSize(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return 0L;
+        }
+        try {
+            Path filePath = resolveKnowledgeItemStoragePath(relativePath);
+            if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+                return 0L;
+            }
+            return Files.size(filePath);
+        } catch (Exception e) {
+            log.warn("resolve knowledge item file size error, path: {}", relativePath, e);
+            return 0L;
+        }
+    }
+
+    private long safeLong(Long value) {
+        return value == null ? 0L : value;
+    }
+
     private String buildRelativeFilePath(String setId, String storedName) {
         String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, storedName).toString();
         return relativePath.replace(File.separatorChar, '/');
     }
 
+    private String buildRelativePath(String parentPrefix, String fileName) {
+        String safeName = sanitizeFileName(fileName);
+        if (StringUtils.isBlank(safeName)) {
+            safeName = "file";
+        }
+        String normalizedPrefix = normalizeRelativePathPrefix(parentPrefix);
+        return normalizedPrefix + safeName;
+    }
+
+    private String normalizeRelativePathPrefix(String prefix) {
+        if (StringUtils.isBlank(prefix)) {
+            return "";
+        }
+        String normalized = prefix.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        BusinessAssert.isTrue(!normalized.contains(".."), CommonErrorCode.PARAM_ERROR);
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        return normalized + PATH_SEPARATOR;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+
+    private String resolveDatasetFileRelativePath(Dataset dataset, DatasetFile datasetFile) {
+        if (datasetFile == null) {
+            return "";
+        }
+        String fileName = StringUtils.defaultIfBlank(datasetFile.getFileName(), datasetFile.getId());
+        String datasetPath = dataset == null ? null : dataset.getPath();
+        String filePath = datasetFile.getFilePath();
+        if (StringUtils.isBlank(datasetPath) || StringUtils.isBlank(filePath)) {
+            return buildRelativePath("", fileName);
+        }
+        try {
+            Path datasetRoot = Paths.get(datasetPath).toAbsolutePath().normalize();
+            Path targetPath = Paths.get(filePath).toAbsolutePath().normalize();
+            if (targetPath.startsWith(datasetRoot)) {
+                Path relative = datasetRoot.relativize(targetPath);
+                String relativeValue = relative.toString().replace(File.separatorChar, '/');
+                String normalized = normalizeRelativePathValue(relativeValue);
+                if (!normalized.contains("..") && StringUtils.isNotBlank(normalized)) {
+                    return normalized;
+                }
+            }
+        } catch (Exception e) {
+            log.warn("resolve dataset file relative path failed, fileId: {}", datasetFile.getId(), e);
+        }
+        return buildRelativePath("", fileName);
+    }
+
+    private String resolveReplacedRelativePath(String existingRelativePath, String newFileName) {
+        String normalized = normalizeRelativePathValue(existingRelativePath);
+        if (StringUtils.isBlank(normalized)) {
+            return buildRelativePath("", newFileName);
+        }
+        int lastIndex = normalized.lastIndexOf(PATH_SEPARATOR);
+        String parentPrefix = lastIndex >= 0 ? normalized.substring(0, lastIndex + 1) : "";
+        return buildRelativePath(parentPrefix, newFileName);
+    }
+
     private void createDirectories(Path path) {
         try {
             Files.createDirectories(path);

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewAsyncService.java

@@ -0,0 +1,275 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Set;
+
+/**
+ * 知识条目预览转换异步任务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class KnowledgeItemPreviewAsyncService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
+    private static final String PREVIEW_SUB_DIR = "preview";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final int MAX_ERROR_LENGTH = 500;
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    @Async
+    public void convertPreviewAsync(String itemId) {
+        if (StringUtils.isBlank(itemId)) {
+            return;
+        }
+        KnowledgeItem item = knowledgeItemRepository.getById(itemId);
+        if (item == null) {
+            return;
+        }
+        String extension = resolveFileExtension(resolveOriginalName(item));
+        if (!OFFICE_EXTENSIONS.contains(extension)) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "仅支持 DOC/DOCX 转换");
+            return;
+        }
+        if (StringUtils.isBlank(item.getContent())) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "源文件路径为空");
+            return;
+        }
+        Path sourcePath = resolveKnowledgeItemStoragePath(item.getContent());
+        if (!Files.exists(sourcePath) || !Files.isRegularFile(sourcePath)) {
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, null, "源文件不存在");
+            return;
+        }
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+        String previewRelativePath = StringUtils.defaultIfBlank(
+            previewInfo.pdfPath(),
+            resolvePreviewRelativePath(item.getSetId(), item.getId())
+        );
+        Path targetPath = resolvePreviewStoragePath(previewRelativePath);
+        ensureParentDirectory(targetPath);
+
+        try {
+            LibreOfficeConverter.convertToPdf(sourcePath, targetPath);
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.READY, previewRelativePath, null);
+        } catch (Exception e) {
+            log.error("preview convert failed, itemId: {}", item.getId(), e);
+            updatePreviewStatus(item, KnowledgeItemPreviewStatus.FAILED, previewRelativePath, trimError(e.getMessage()));
+        }
+    }
+
+    private void updatePreviewStatus(
+        KnowledgeItem item,
+        KnowledgeItemPreviewStatus status,
+        String previewRelativePath,
+        String error
+    ) {
+        if (item == null) {
+            return;
+        }
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            status,
+            previewRelativePath,
+            error,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+    }
+
+    private String resolveOriginalName(KnowledgeItem item) {
+        if (item == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(item.getSourceFileId())) {
+            return item.getSourceFileId();
+        }
+        if (StringUtils.isNotBlank(item.getContent())) {
+            return Paths.get(item.getContent()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewRelativePath(String setId, String itemId) {
+        String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, PREVIEW_SUB_DIR, itemId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid preview path");
+        }
+        return target;
+    }
+
+    private Path resolveKnowledgeItemStoragePath(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        String normalizedInput = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        Path root = resolveUploadRootPath();
+        java.util.LinkedHashSet<Path> candidates = new java.util.LinkedHashSet<>();
+
+        Path inputPath = Paths.get(normalizedInput.replace(PATH_SEPARATOR, java.io.File.separator));
+        if (inputPath.isAbsolute()) {
+            Path normalizedAbsolute = inputPath.toAbsolutePath().normalize();
+            if (normalizedAbsolute.startsWith(root)) {
+                candidates.add(normalizedAbsolute);
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (candidates.isEmpty()) {
+                throw new IllegalArgumentException("invalid knowledge item path");
+            }
+        } else {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, normalizedRelative));
+            }
+            String segmentRelativePath = extractRelativePathFromSegment(normalizedInput, KNOWLEDGE_ITEM_UPLOAD_DIR);
+            if (StringUtils.isNotBlank(segmentRelativePath)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, segmentRelativePath));
+            }
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && !normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)
+                    && !normalizedRelative.equals(KNOWLEDGE_ITEM_UPLOAD_DIR)) {
+                candidates.add(buildKnowledgeItemStoragePath(root, KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR + normalizedRelative));
+            }
+        }
+
+        if (root.getFileName() != null && KNOWLEDGE_ITEM_UPLOAD_DIR.equals(root.getFileName().toString())) {
+            String normalizedRelative = normalizeRelativePathValue(normalizedInput);
+            if (StringUtils.isNotBlank(normalizedRelative)
+                    && normalizedRelative.startsWith(KNOWLEDGE_ITEM_UPLOAD_DIR + PATH_SEPARATOR)) {
+                String withoutPrefix = normalizedRelative.substring(KNOWLEDGE_ITEM_UPLOAD_DIR.length() + PATH_SEPARATOR.length());
+                if (StringUtils.isNotBlank(withoutPrefix)) {
+                    candidates.add(buildKnowledgeItemStoragePath(root, withoutPrefix));
+                }
+            }
+        }
+
+        Path fallback = null;
+        for (Path candidate : candidates) {
+            if (fallback == null) {
+                fallback = candidate;
+            }
+            if (Files.exists(candidate) && Files.isRegularFile(candidate)) {
+                return candidate;
+            }
+        }
+        if (fallback == null) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        return fallback;
+    }
+
+    private Path buildKnowledgeItemStoragePath(Path root, String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace(PATH_SEPARATOR, java.io.File.separator);
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        if (!target.startsWith(root)) {
+            throw new IllegalArgumentException("invalid knowledge item path");
+        }
+        return target;
+    }
+
+    private String extractRelativePathFromSegment(String rawPath, String segment) {
+        if (StringUtils.isBlank(rawPath) || StringUtils.isBlank(segment)) {
+            return null;
+        }
+        String normalized = rawPath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        String segmentPrefix = segment + PATH_SEPARATOR;
+        int index = normalized.indexOf(segmentPrefix);
+        if (index < 0) {
+            return segment.equals(normalized) ? segment : null;
+        }
+        return normalizeRelativePathValue(normalized.substring(index));
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private void ensureParentDirectory(Path targetPath) {
+        try {
+            Path parent = targetPath.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException("创建预览目录失败", e);
+        }
+    }
+
+    private String trimError(String error) {
+        if (StringUtils.isBlank(error)) {
+            return "";
+        }
+        if (error.length() <= MAX_ERROR_LENGTH) {
+            return error;
+        }
+        return error.substring(0, MAX_ERROR_LENGTH);
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewMetadataHelper.java

@@ -0,0 +1,134 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * 知识条目预览元数据解析与写入辅助类
+ */
+public final class KnowledgeItemPreviewMetadataHelper {
+    public static final String PREVIEW_STATUS_KEY = "previewStatus";
+    public static final String PREVIEW_PDF_PATH_KEY = "previewPdfPath";
+    public static final String PREVIEW_ERROR_KEY = "previewError";
+    public static final String PREVIEW_UPDATED_AT_KEY = "previewUpdatedAt";
+
+    private KnowledgeItemPreviewMetadataHelper() {
+    }
+
+    public static PreviewInfo readPreviewInfo(String metadata, ObjectMapper objectMapper) {
+        if (StringUtils.isBlank(metadata) || objectMapper == null) {
+            return PreviewInfo.empty();
+        }
+        try {
+            JsonNode node = objectMapper.readTree(metadata);
+            if (node == null || !node.isObject()) {
+                return PreviewInfo.empty();
+            }
+            String statusText = textValue(node, PREVIEW_STATUS_KEY);
+            KnowledgeItemPreviewStatus status = parseStatus(statusText);
+            return new PreviewInfo(
+                status,
+                textValue(node, PREVIEW_PDF_PATH_KEY),
+                textValue(node, PREVIEW_ERROR_KEY),
+                textValue(node, PREVIEW_UPDATED_AT_KEY)
+            );
+        } catch (Exception ignore) {
+            return PreviewInfo.empty();
+        }
+    }
+
+    public static String applyPreviewInfo(
+        String metadata,
+        ObjectMapper objectMapper,
+        KnowledgeItemPreviewStatus status,
+        String pdfPath,
+        String error,
+        String updatedAt
+    ) {
+        if (objectMapper == null) {
+            return metadata;
+        }
+        ObjectNode root = parseRoot(metadata, objectMapper);
+        if (status == null) {
+            root.remove(PREVIEW_STATUS_KEY);
+        } else {
+            root.put(PREVIEW_STATUS_KEY, status.name());
+        }
+        if (StringUtils.isBlank(pdfPath)) {
+            root.remove(PREVIEW_PDF_PATH_KEY);
+        } else {
+            root.put(PREVIEW_PDF_PATH_KEY, pdfPath);
+        }
+        if (StringUtils.isBlank(error)) {
+            root.remove(PREVIEW_ERROR_KEY);
+        } else {
+            root.put(PREVIEW_ERROR_KEY, error);
+        }
+        if (StringUtils.isBlank(updatedAt)) {
+            root.remove(PREVIEW_UPDATED_AT_KEY);
+        } else {
+            root.put(PREVIEW_UPDATED_AT_KEY, updatedAt);
+        }
+        return root.size() == 0 ? null : root.toString();
+    }
+
+    public static String clearPreviewInfo(String metadata, ObjectMapper objectMapper) {
+        if (objectMapper == null) {
+            return metadata;
+        }
+        ObjectNode root = parseRoot(metadata, objectMapper);
+        root.remove(PREVIEW_STATUS_KEY);
+        root.remove(PREVIEW_PDF_PATH_KEY);
+        root.remove(PREVIEW_ERROR_KEY);
+        root.remove(PREVIEW_UPDATED_AT_KEY);
+        return root.size() == 0 ? null : root.toString();
+    }
+
+    private static ObjectNode parseRoot(String metadata, ObjectMapper objectMapper) {
+        if (StringUtils.isBlank(metadata)) {
+            return objectMapper.createObjectNode();
+        }
+        try {
+            JsonNode node = objectMapper.readTree(metadata);
+            if (node instanceof ObjectNode objectNode) {
+                return objectNode;
+            }
+        } catch (Exception ignore) {
+            return objectMapper.createObjectNode();
+        }
+        return objectMapper.createObjectNode();
+    }
+
+    private static String textValue(JsonNode node, String key) {
+        if (node == null || StringUtils.isBlank(key)) {
+            return null;
+        }
+        JsonNode value = node.get(key);
+        return value == null || value.isNull() ? null : value.asText();
+    }
+
+    private static KnowledgeItemPreviewStatus parseStatus(String statusText) {
+        if (StringUtils.isBlank(statusText)) {
+            return null;
+        }
+        try {
+            return KnowledgeItemPreviewStatus.valueOf(statusText);
+        } catch (Exception ignore) {
+            return null;
+        }
+    }
+
+    public record PreviewInfo(
+        KnowledgeItemPreviewStatus status,
+        String pdfPath,
+        String error,
+        String updatedAt
+    ) {
+        public static PreviewInfo empty() {
+            return new PreviewInfo(null, null, null, null);
+        }
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemPreviewService.java

@@ -0,0 +1,244 @@
+package com.datamate.datamanagement.application;
+
+import com.datamate.common.infrastructure.exception.BusinessAssert;
+import com.datamate.common.infrastructure.exception.CommonErrorCode;
+import com.datamate.datamanagement.common.enums.KnowledgeContentType;
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPreviewStatusResponse;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * 知识条目预览转换服务
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class KnowledgeItemPreviewService {
+    private static final Set<String> OFFICE_EXTENSIONS = Set.of("doc", "docx");
+    private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
+    private static final String PREVIEW_SUB_DIR = "preview";
+    private static final String PREVIEW_FILE_SUFFIX = ".pdf";
+    private static final String PATH_SEPARATOR = "/";
+    private static final DateTimeFormatter PREVIEW_TIME_FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    private final KnowledgeItemRepository knowledgeItemRepository;
+    private final DataManagementProperties dataManagementProperties;
+    private final KnowledgeItemPreviewAsyncService knowledgeItemPreviewAsyncService;
+    private final ObjectMapper objectMapper = new ObjectMapper();
+
+    public KnowledgeItemPreviewStatusResponse getPreviewStatus(String setId, String itemId) {
+        KnowledgeItem item = requireKnowledgeItem(setId, itemId);
+        assertOfficeDocument(item);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && !previewPdfExists(item, previewInfo)) {
+            previewInfo = markPreviewFailed(item, previewInfo, "预览文件不存在");
+        }
+
+        return buildResponse(previewInfo);
+    }
+
+    public KnowledgeItemPreviewStatusResponse ensurePreview(String setId, String itemId) {
+        KnowledgeItem item = requireKnowledgeItem(setId, itemId);
+        assertOfficeDocument(item);
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.READY && previewPdfExists(item, previewInfo)) {
+            return buildResponse(previewInfo);
+        }
+        if (previewInfo.status() == KnowledgeItemPreviewStatus.PROCESSING) {
+            return buildResponse(previewInfo);
+        }
+
+        String previewRelativePath = resolvePreviewRelativePath(item.getSetId(), item.getId());
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.PROCESSING,
+            previewRelativePath,
+            null,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+        knowledgeItemPreviewAsyncService.convertPreviewAsync(item.getId());
+
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo refreshed = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(updatedMetadata, objectMapper);
+        return buildResponse(refreshed);
+    }
+
+    public boolean isOfficeDocument(String fileName) {
+        String extension = resolveFileExtension(fileName);
+        return StringUtils.isNotBlank(extension) && OFFICE_EXTENSIONS.contains(extension.toLowerCase());
+    }
+
+    public PreviewFile resolveReadyPreviewFile(String setId, KnowledgeItem item) {
+        if (item == null) {
+            return null;
+        }
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo = KnowledgeItemPreviewMetadataHelper
+            .readPreviewInfo(item.getMetadata(), objectMapper);
+        if (previewInfo.status() != KnowledgeItemPreviewStatus.READY) {
+            return null;
+        }
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(setId, item.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        if (!Files.exists(filePath) || !Files.isRegularFile(filePath)) {
+            markPreviewFailed(item, previewInfo, "预览文件不存在");
+            return null;
+        }
+        String previewName = resolvePreviewPdfName(item);
+        return new PreviewFile(filePath, previewName);
+    }
+
+    public String clearPreviewMetadata(String metadata) {
+        return KnowledgeItemPreviewMetadataHelper.clearPreviewInfo(metadata, objectMapper);
+    }
+
+    public void deletePreviewFileQuietly(String setId, String itemId) {
+        String relativePath = resolvePreviewRelativePath(setId, itemId);
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        try {
+            Files.deleteIfExists(filePath);
+        } catch (Exception e) {
+            log.warn("delete preview pdf error, itemId: {}", itemId, e);
+        }
+    }
+
+    private KnowledgeItemPreviewStatusResponse buildResponse(KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        KnowledgeItemPreviewStatusResponse response = new KnowledgeItemPreviewStatusResponse();
+        KnowledgeItemPreviewStatus status = previewInfo.status() == null
+            ? KnowledgeItemPreviewStatus.PENDING
+            : previewInfo.status();
+        response.setStatus(status);
+        response.setPreviewError(previewInfo.error());
+        response.setUpdatedAt(previewInfo.updatedAt());
+        return response;
+    }
+
+    private KnowledgeItem requireKnowledgeItem(String setId, String itemId) {
+        BusinessAssert.isTrue(StringUtils.isNotBlank(setId), CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(StringUtils.isNotBlank(itemId), CommonErrorCode.PARAM_ERROR);
+        KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
+        BusinessAssert.notNull(knowledgeItem, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(Objects.equals(knowledgeItem.getSetId(), setId), CommonErrorCode.PARAM_ERROR);
+        return knowledgeItem;
+    }
+
+    private void assertOfficeDocument(KnowledgeItem item) {
+        BusinessAssert.notNull(item, CommonErrorCode.PARAM_ERROR);
+        BusinessAssert.isTrue(
+            item.getContentType() == KnowledgeContentType.FILE || item.getSourceType() == KnowledgeSourceType.FILE_UPLOAD,
+            CommonErrorCode.PARAM_ERROR
+        );
+        String extension = resolveFileExtension(resolveOriginalName(item));
+        BusinessAssert.isTrue(OFFICE_EXTENSIONS.contains(extension), CommonErrorCode.PARAM_ERROR);
+    }
+
+    private String resolveOriginalName(KnowledgeItem item) {
+        if (item == null) {
+            return "";
+        }
+        if (StringUtils.isNotBlank(item.getSourceFileId())) {
+            return item.getSourceFileId();
+        }
+        if (StringUtils.isNotBlank(item.getContent())) {
+            return Paths.get(item.getContent()).getFileName().toString();
+        }
+        return "";
+    }
+
+    private String resolveFileExtension(String fileName) {
+        if (StringUtils.isBlank(fileName)) {
+            return "";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
+            return "";
+        }
+        return fileName.substring(dotIndex + 1).toLowerCase();
+    }
+
+    private String resolvePreviewPdfName(KnowledgeItem item) {
+        String originalName = resolveOriginalName(item);
+        if (StringUtils.isBlank(originalName)) {
+            return "预览.pdf";
+        }
+        int dotIndex = originalName.lastIndexOf('.');
+        if (dotIndex <= 0) {
+            return originalName + PREVIEW_FILE_SUFFIX;
+        }
+        return originalName.substring(0, dotIndex) + PREVIEW_FILE_SUFFIX;
+    }
+
+    private boolean previewPdfExists(KnowledgeItem item, KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(item.getSetId(), item.getId()));
+        Path filePath = resolvePreviewStoragePath(relativePath);
+        return Files.exists(filePath) && Files.isRegularFile(filePath);
+    }
+
+    private KnowledgeItemPreviewMetadataHelper.PreviewInfo markPreviewFailed(
+        KnowledgeItem item,
+        KnowledgeItemPreviewMetadataHelper.PreviewInfo previewInfo,
+        String error
+    ) {
+        String relativePath = StringUtils.defaultIfBlank(previewInfo.pdfPath(), resolvePreviewRelativePath(item.getSetId(), item.getId()));
+        String updatedMetadata = KnowledgeItemPreviewMetadataHelper.applyPreviewInfo(
+            item.getMetadata(),
+            objectMapper,
+            KnowledgeItemPreviewStatus.FAILED,
+            relativePath,
+            error,
+            nowText()
+        );
+        item.setMetadata(updatedMetadata);
+        knowledgeItemRepository.updateById(item);
+        return KnowledgeItemPreviewMetadataHelper.readPreviewInfo(updatedMetadata, objectMapper);
+    }
+
+    private String resolvePreviewRelativePath(String setId, String itemId) {
+        String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, PREVIEW_SUB_DIR, itemId + PREVIEW_FILE_SUFFIX)
+            .toString();
+        return relativePath.replace("\\", PATH_SEPARATOR);
+    }
+
+    private Path resolvePreviewStoragePath(String relativePath) {
+        String normalizedRelativePath = StringUtils.defaultString(relativePath).replace("/", java.io.File.separator);
+        Path root = resolveUploadRootPath();
+        Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
+        BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
+        return target;
+    }
+
+    private Path resolveUploadRootPath() {
+        String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
+        BusinessAssert.isTrue(StringUtils.isNotBlank(uploadDir), CommonErrorCode.PARAM_ERROR);
+        return Paths.get(uploadDir).toAbsolutePath().normalize();
+    }
+
+    private String nowText() {
+        return LocalDateTime.now().format(PREVIEW_TIME_FORMATTER);
+    }
+
+    public record PreviewFile(Path filePath, String fileName) {
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/LibreOfficeConverter.java

@@ -0,0 +1,93 @@
+package com.datamate.datamanagement.application;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * LibreOffice 文档转换工具
+ */
+public final class LibreOfficeConverter {
+    private static final String LIBREOFFICE_COMMAND = "soffice";
+    private static final Duration CONVERT_TIMEOUT = Duration.ofMinutes(5);
+    private static final int MAX_OUTPUT_LENGTH = 500;
+
+    private LibreOfficeConverter() {
+    }
+
+    public static void convertToPdf(Path sourcePath, Path targetPath) throws Exception {
+        Path outputDir = targetPath.getParent();
+        List<String> command = List.of(
+            LIBREOFFICE_COMMAND,
+            "--headless",
+            "--nologo",
+            "--nolockcheck",
+            "--nodefault",
+            "--nofirststartwizard",
+            "--convert-to",
+            "pdf",
+            "--outdir",
+            outputDir.toString(),
+            sourcePath.toString()
+        );
+        ProcessBuilder processBuilder = new ProcessBuilder(command);
+        processBuilder.redirectErrorStream(true);
+        Process process = processBuilder.start();
+        boolean finished = process.waitFor(CONVERT_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS);
+        String output = readProcessOutput(process.getInputStream());
+        if (!finished) {
+            process.destroyForcibly();
+            throw new IllegalStateException("LibreOffice 转换超时");
+        }
+        if (process.exitValue() != 0) {
+            throw new IllegalStateException("LibreOffice 转换失败: " + output);
+        }
+        Path generated = outputDir.resolve(stripExtension(sourcePath.getFileName().toString()) + ".pdf");
+        if (!Files.exists(generated)) {
+            throw new IllegalStateException("LibreOffice 输出文件不存在");
+        }
+        if (!generated.equals(targetPath)) {
+            Files.move(generated, targetPath, StandardCopyOption.REPLACE_EXISTING);
+        }
+    }
+
+    private static String readProcessOutput(InputStream inputStream) throws IOException {
+        if (inputStream == null) {
+            return "";
+        }
+        byte[] buffer = new byte[1024];
+        StringBuilder builder = new StringBuilder();
+        int total = 0;
+        int read;
+        while ((read = inputStream.read(buffer)) >= 0) {
+            if (read == 0) {
+                continue;
+            }
+            int remaining = MAX_OUTPUT_LENGTH - total;
+            if (remaining <= 0) {
+                break;
+            }
+            int toAppend = Math.min(remaining, read);
+            builder.append(new String(buffer, 0, toAppend, StandardCharsets.UTF_8));
+            total += toAppend;
+            if (total >= MAX_OUTPUT_LENGTH) {
+                break;
+            }
+        }
+        return builder.toString();
+    }
+
+    private static String stripExtension(String fileName) {
+        if (fileName == null || fileName.isBlank()) {
+            return "preview";
+        }
+        int dotIndex = fileName.lastIndexOf('.');
+        return dotIndex <= 0 ? fileName : fileName.substring(0, dotIndex);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/common/enums/KnowledgeItemPreviewStatus.java

@@ -0,0 +1,11 @@
+package com.datamate.datamanagement.common.enums;
+
+/**
+ * 知识条目预览转换状态
+ */
+public enum KnowledgeItemPreviewStatus {
+    PENDING,
+    PROCESSING,
+    READY,
+    FAILED
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/domain/model/knowledge/KnowledgeItem.java

@@ -38,4 +38,12 @@ public class KnowledgeItem extends BaseEntity<String> {
      * 来源文件ID
      */
     private String sourceFileId;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/domain/model/knowledge/KnowledgeItemDirectory.java

@@ -0,0 +1,29 @@
+package com.datamate.datamanagement.domain.model.knowledge;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.datamate.common.domain.model.base.BaseEntity;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目目录实体（与数据库表 t_dm_knowledge_item_directories 对齐）
+ */
+@Getter
+@Setter
+@TableName(value = "t_dm_knowledge_item_directories", autoResultMap = true)
+public class KnowledgeItemDirectory extends BaseEntity<String> {
+    /**
+     * 所属知识集ID
+     */
+    private String setId;
+
+    /**
+     * 目录名称
+     */
+    private String name;
+
+    /**
+     * 目录相对路径
+     */
+    private String relativePath;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/DatasetFileMapper.java

@@ -2,6 +2,7 @@ package com.datamate.datamanagement.infrastructure.persistence.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.session.RowBounds;
@@ -17,6 +18,7 @@ public interface DatasetFileMapper extends BaseMapper<DatasetFile> {
     Long countByDatasetId(@Param("datasetId") String datasetId);
     Long countCompletedByDatasetId(@Param("datasetId") String datasetId);
     Long sumSizeByDatasetId(@Param("datasetId") String datasetId);
+    Long countNonDerivedByDatasetId(@Param("datasetId") String datasetId);
     DatasetFile findByDatasetIdAndFileName(@Param("datasetId") String datasetId, @Param("fileName") String fileName);
     List<DatasetFile> findAllByDatasetId(@Param("datasetId") String datasetId);
     List<DatasetFile> findByCriteria(@Param("datasetId") String datasetId,
@@ -38,4 +40,12 @@ public interface DatasetFileMapper extends BaseMapper<DatasetFile> {
      * @return 源文件ID列表
      */
     List<String> findSourceFileIdsWithDerivedFiles(@Param("datasetId") String datasetId);
+
+    /**
+     * 批量统计排除衍生文件后的文件数
+     *
+     * @param datasetIds 数据集ID列表
+     * @return 文件数统计列表
+     */
+    List<DatasetFileCount> countNonDerivedByDatasetIds(@Param("datasetIds") List<String> datasetIds);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/KnowledgeItemDirectoryMapper.java

@@ -0,0 +1,9 @@
+package com.datamate.datamanagement.infrastructure.persistence.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface KnowledgeItemDirectoryMapper extends BaseMapper<KnowledgeItemDirectory> {
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/KnowledgeItemMapper.java

@@ -1,9 +1,52 @@
 package com.datamate.datamanagement.infrastructure.persistence.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 @Mapper
 public interface KnowledgeItemMapper extends BaseMapper<KnowledgeItem> {
+    @Select("""
+        SELECT
+            ki.id AS id,
+            ki.set_id AS setId,
+            ks.name AS setName,
+            ki.content_type AS contentType,
+            ki.source_type AS sourceType,
+            ki.source_dataset_id AS sourceDatasetId,
+            ki.source_file_id AS sourceFileId,
+            CASE
+                WHEN ki.source_type = 'DATASET_FILE' THEN df.file_name
+                ELSE ki.source_file_id
+            END AS fileName,
+            df.file_size AS fileSize,
+            CASE
+                WHEN ki.source_type = 'FILE_UPLOAD' THEN ki.content
+                ELSE NULL
+            END AS content,
+            ki.relative_path AS relativePath,
+            ki.created_at AS createdAt,
+            ki.updated_at AS updatedAt
+        FROM t_dm_knowledge_items ki
+        LEFT JOIN t_dm_knowledge_sets ks ON ki.set_id = ks.id
+        LEFT JOIN t_dm_dataset_files df ON ki.source_file_id = df.id AND ki.source_type = 'DATASET_FILE'
+        WHERE (ki.source_type = 'FILE_UPLOAD' AND (ki.source_file_id LIKE CONCAT('%', #{keyword}, '%')
+           OR ki.relative_path LIKE CONCAT('%', #{keyword}, '%')))
+           OR (ki.source_type = 'DATASET_FILE' AND (df.file_name LIKE CONCAT('%', #{keyword}, '%')
+           OR ki.relative_path LIKE CONCAT('%', #{keyword}, '%')))
+        ORDER BY ki.created_at DESC
+        """)
+    IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, @Param("keyword") String keyword);
+
+    @Select("""
+        SELECT COALESCE(SUM(df.file_size), 0)
+        FROM t_dm_knowledge_items ki
+        LEFT JOIN t_dm_dataset_files df ON ki.source_file_id = df.id
+        WHERE ki.source_type = 'DATASET_FILE'
+        """)
+    Long sumDatasetFileSize();
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/mapper/TagMapper.java

@@ -14,6 +14,7 @@ public interface TagMapper {
     List<Tag> findByIdIn(@Param("ids") List<String> ids);
     List<Tag> findByKeyword(@Param("keyword") String keyword);
     List<Tag> findAllByOrderByUsageCountDesc();
+    Long countKnowledgeSetTags();
 
     int insert(Tag tag);
     int update(Tag tag);

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/DatasetFileRepository.java

@@ -3,6 +3,7 @@ package com.datamate.datamanagement.infrastructure.persistence.repository;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.IRepository;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 
 import java.util.List;
 
@@ -15,6 +16,8 @@ import java.util.List;
 public interface DatasetFileRepository extends IRepository<DatasetFile> {
     Long countByDatasetId(String datasetId);
 
+    Long countNonDerivedByDatasetId(String datasetId);
+
     Long countCompletedByDatasetId(String datasetId);
 
     Long sumSizeByDatasetId(String datasetId);
@@ -36,4 +39,6 @@ public interface DatasetFileRepository extends IRepository<DatasetFile> {
      * @return 源文件ID列表
      */
     List<String> findSourceFileIdsWithDerivedFiles(String datasetId);
+
+    List<DatasetFileCount> countNonDerivedByDatasetIds(List<String> datasetIds);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/KnowledgeItemDirectoryRepository.java

@@ -0,0 +1,18 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository;
+
+import com.baomidou.mybatisplus.extension.repository.IRepository;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+
+import java.util.List;
+
+/**
+ * 知识条目目录仓储接口
+ */
+public interface KnowledgeItemDirectoryRepository extends IRepository<KnowledgeItemDirectory> {
+    List<KnowledgeItemDirectory> findByCriteria(KnowledgeDirectoryQuery query);
+
+    KnowledgeItemDirectory findBySetIdAndPath(String setId, String relativePath);
+
+    int removeByRelativePathPrefix(String setId, String relativePath);
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/KnowledgeItemRepository.java

@@ -2,8 +2,11 @@ package com.datamate.datamanagement.infrastructure.persistence.repository;
 
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.IRepository;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import java.util.List;
 
 /**
@@ -15,4 +18,16 @@ public interface KnowledgeItemRepository extends IRepository<KnowledgeItem> {
     long countBySetId(String setId);
 
     List<KnowledgeItem> findAllBySetId(String setId);
+
+    long countBySourceTypes(List<KnowledgeSourceType> sourceTypes);
+
+    List<KnowledgeItem> findFileUploadItems();
+
+    IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, String keyword);
+
+    Long sumDatasetFileSize();
+
+    boolean existsBySetIdAndRelativePath(String setId, String relativePath);
+
+    int removeByRelativePathPrefix(String setId, String relativePath);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/dto/DatasetFileCount.java

@@ -0,0 +1,18 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+/**
+ * 数据集文件数统计结果
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class DatasetFileCount {
+    private String datasetId;
+    private Long fileCount;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/DatasetFileRepositoryImpl.java

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.extension.repository.CrudRepository;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
 import com.datamate.datamanagement.infrastructure.persistence.mapper.DatasetFileMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
+import com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Repository;
 import org.springframework.util.StringUtils;
@@ -30,6 +31,11 @@ public class DatasetFileRepositoryImpl extends CrudRepository<DatasetFileMapper,
         return datasetFileMapper.selectCount(new LambdaQueryWrapper<DatasetFile>().eq(DatasetFile::getDatasetId, datasetId));
     }
 
+    @Override
+    public Long countNonDerivedByDatasetId(String datasetId) {
+        return datasetFileMapper.countNonDerivedByDatasetId(datasetId);
+    }
+
     @Override
     public Long countCompletedByDatasetId(String datasetId) {
         return datasetFileMapper.countCompletedByDatasetId(datasetId);
@@ -71,4 +77,9 @@ public class DatasetFileRepositoryImpl extends CrudRepository<DatasetFileMapper,
         // 使用 MyBatis 的 @Select 注解或直接调用 mapper 方法
         return datasetFileMapper.findSourceFileIdsWithDerivedFiles(datasetId);
     }
+
+    @Override
+    public List<DatasetFileCount> countNonDerivedByDatasetIds(List<String> datasetIds) {
+        return datasetFileMapper.countNonDerivedByDatasetIds(datasetIds);
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/KnowledgeItemDirectoryRepositoryImpl.java

@@ -0,0 +1,96 @@
+package com.datamate.datamanagement.infrastructure.persistence.repository.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.repository.CrudRepository;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.infrastructure.persistence.mapper.KnowledgeItemDirectoryMapper;
+import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemDirectoryRepository;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 知识条目目录仓储实现类
+ */
+@Repository
+@RequiredArgsConstructor
+public class KnowledgeItemDirectoryRepositoryImpl
+    extends CrudRepository<KnowledgeItemDirectoryMapper, KnowledgeItemDirectory>
+    implements KnowledgeItemDirectoryRepository {
+
+    private static final String PATH_SEPARATOR = "/";
+    private final KnowledgeItemDirectoryMapper knowledgeItemDirectoryMapper;
+
+    @Override
+    public List<KnowledgeItemDirectory> findByCriteria(KnowledgeDirectoryQuery query) {
+        String relativePath = normalizeRelativePathPrefix(query.getRelativePath());
+        LambdaQueryWrapper<KnowledgeItemDirectory> wrapper = new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(StringUtils.isNotBlank(query.getSetId()), KnowledgeItemDirectory::getSetId, query.getSetId())
+            .likeRight(StringUtils.isNotBlank(relativePath), KnowledgeItemDirectory::getRelativePath, relativePath);
+
+        if (StringUtils.isNotBlank(query.getKeyword())) {
+            wrapper.and(w -> w.like(KnowledgeItemDirectory::getName, query.getKeyword())
+                .or()
+                .like(KnowledgeItemDirectory::getRelativePath, query.getKeyword()));
+        }
+
+        wrapper.orderByAsc(KnowledgeItemDirectory::getRelativePath);
+        return knowledgeItemDirectoryMapper.selectList(wrapper);
+    }
+
+    @Override
+    public KnowledgeItemDirectory findBySetIdAndPath(String setId, String relativePath) {
+        return knowledgeItemDirectoryMapper.selectOne(new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(KnowledgeItemDirectory::getSetId, setId)
+            .eq(KnowledgeItemDirectory::getRelativePath, relativePath));
+    }
+
+    @Override
+    public int removeByRelativePathPrefix(String setId, String relativePath) {
+        String normalized = normalizeRelativePathValue(relativePath);
+        if (StringUtils.isBlank(normalized)) {
+            return 0;
+        }
+        String prefix = normalizeRelativePathPrefix(normalized);
+        LambdaQueryWrapper<KnowledgeItemDirectory> wrapper = new LambdaQueryWrapper<KnowledgeItemDirectory>()
+            .eq(KnowledgeItemDirectory::getSetId, setId)
+            .and(w -> w.eq(KnowledgeItemDirectory::getRelativePath, normalized)
+                .or()
+                .likeRight(KnowledgeItemDirectory::getRelativePath, prefix));
+        return knowledgeItemDirectoryMapper.delete(wrapper);
+    }
+
+    private String normalizeRelativePathPrefix(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        if (!normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized + PATH_SEPARATOR;
+        }
+        return normalized;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/infrastructure/persistence/repository/impl/KnowledgeItemRepositoryImpl.java

@@ -3,10 +3,12 @@ package com.datamate.datamanagement.infrastructure.persistence.repository.impl;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.repository.CrudRepository;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.infrastructure.persistence.mapper.KnowledgeItemMapper;
 import com.datamate.datamanagement.infrastructure.persistence.repository.KnowledgeItemRepository;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Repository;
@@ -19,21 +21,26 @@ import java.util.List;
 @Repository
 @RequiredArgsConstructor
 public class KnowledgeItemRepositoryImpl extends CrudRepository<KnowledgeItemMapper, KnowledgeItem> implements KnowledgeItemRepository {
+    private static final String PATH_SEPARATOR = "/";
     private final KnowledgeItemMapper knowledgeItemMapper;
 
     @Override
     public IPage<KnowledgeItem> findByCriteria(IPage<KnowledgeItem> page, KnowledgeItemPagingQuery query) {
+        String relativePath = normalizeRelativePathPrefix(query.getRelativePath());
         LambdaQueryWrapper<KnowledgeItem> wrapper = new LambdaQueryWrapper<KnowledgeItem>()
             .eq(StringUtils.isNotBlank(query.getSetId()), KnowledgeItem::getSetId, query.getSetId())
             .eq(query.getContentType() != null, KnowledgeItem::getContentType, query.getContentType())
             .eq(query.getSourceType() != null, KnowledgeItem::getSourceType, query.getSourceType())
             .eq(StringUtils.isNotBlank(query.getSourceDatasetId()), KnowledgeItem::getSourceDatasetId, query.getSourceDatasetId())
-            .eq(StringUtils.isNotBlank(query.getSourceFileId()), KnowledgeItem::getSourceFileId, query.getSourceFileId());
+            .eq(StringUtils.isNotBlank(query.getSourceFileId()), KnowledgeItem::getSourceFileId, query.getSourceFileId())
+            .likeRight(StringUtils.isNotBlank(relativePath), KnowledgeItem::getRelativePath, relativePath);
 
         if (StringUtils.isNotBlank(query.getKeyword())) {
             wrapper.and(w -> w.like(KnowledgeItem::getSourceFileId, query.getKeyword())
                 .or()
-                .like(KnowledgeItem::getContent, query.getKeyword()));
+                .like(KnowledgeItem::getContent, query.getKeyword())
+                .or()
+                .like(KnowledgeItem::getRelativePath, query.getKeyword()));
         }
 
         wrapper.orderByDesc(KnowledgeItem::getCreatedAt);
@@ -52,4 +59,83 @@ public class KnowledgeItemRepositoryImpl extends CrudRepository<KnowledgeItemMap
             .eq(KnowledgeItem::getSetId, setId)
             .orderByDesc(KnowledgeItem::getCreatedAt));
     }
+
+    @Override
+    public long countBySourceTypes(List<KnowledgeSourceType> sourceTypes) {
+        return knowledgeItemMapper.selectCount(new LambdaQueryWrapper<KnowledgeItem>()
+            .in(KnowledgeItem::getSourceType, sourceTypes));
+    }
+
+    @Override
+    public List<KnowledgeItem> findFileUploadItems() {
+        return knowledgeItemMapper.selectList(new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSourceType, KnowledgeSourceType.FILE_UPLOAD)
+            .select(KnowledgeItem::getId, KnowledgeItem::getContent, KnowledgeItem::getSourceFileId));
+    }
+
+    @Override
+    public IPage<KnowledgeItemSearchResponse> searchFileItems(IPage<?> page, String keyword) {
+        return knowledgeItemMapper.searchFileItems(page, keyword);
+    }
+
+    @Override
+    public Long sumDatasetFileSize() {
+        return knowledgeItemMapper.sumDatasetFileSize();
+    }
+
+    @Override
+    public boolean existsBySetIdAndRelativePath(String setId, String relativePath) {
+        if (StringUtils.isBlank(setId) || StringUtils.isBlank(relativePath)) {
+            return false;
+        }
+        return knowledgeItemMapper.selectCount(new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSetId, setId)
+            .eq(KnowledgeItem::getRelativePath, relativePath)) > 0;
+    }
+
+    @Override
+    public int removeByRelativePathPrefix(String setId, String relativePath) {
+        String normalized = normalizeRelativePathValue(relativePath);
+        if (StringUtils.isBlank(setId) || StringUtils.isBlank(normalized)) {
+            return 0;
+        }
+        String prefix = normalizeRelativePathPrefix(normalized);
+        LambdaQueryWrapper<KnowledgeItem> wrapper = new LambdaQueryWrapper<KnowledgeItem>()
+            .eq(KnowledgeItem::getSetId, setId)
+            .and(w -> w.eq(KnowledgeItem::getRelativePath, normalized)
+                .or()
+                .likeRight(KnowledgeItem::getRelativePath, prefix));
+        return knowledgeItemMapper.delete(wrapper);
+    }
+
+    private String normalizeRelativePathPrefix(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        if (StringUtils.isBlank(normalized)) {
+            return "";
+        }
+        if (!normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized + PATH_SEPARATOR;
+        }
+        return normalized;
+    }
+
+    private String normalizeRelativePathValue(String relativePath) {
+        if (StringUtils.isBlank(relativePath)) {
+            return "";
+        }
+        String normalized = relativePath.replace("\\", PATH_SEPARATOR).trim();
+        while (normalized.startsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(1);
+        }
+        while (normalized.endsWith(PATH_SEPARATOR)) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/converter/KnowledgeConverter.java

@@ -1,9 +1,11 @@
 package com.datamate.datamanagement.interfaces.converter;
 
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeSetRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetResponse;
 import org.mapstruct.Mapper;
@@ -31,4 +33,8 @@ public interface KnowledgeConverter {
     KnowledgeItemResponse convertToResponse(KnowledgeItem knowledgeItem);
 
     List<KnowledgeItemResponse> convertItemResponses(List<KnowledgeItem> items);
+
+    KnowledgeDirectoryResponse convertToResponse(KnowledgeItemDirectory directory);
+
+    List<KnowledgeDirectoryResponse> convertDirectoryResponses(List<KnowledgeItemDirectory> directories);
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/CreateKnowledgeDirectoryRequest.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 创建知识条目目录请求
+ */
+@Getter
+@Setter
+public class CreateKnowledgeDirectoryRequest {
+
+    /** 父级前缀路径，例如 "docs/"，为空表示知识集根目录 */
+    private String parentPrefix;
+
+    /** 新建目录名称 */
+    @NotBlank
+    private String directoryName;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/CreateKnowledgeItemRequest.java

@@ -34,4 +34,8 @@ public class CreateKnowledgeItemRequest {
      * 来源文件ID（用于标注同步等场景）
      */
     private String sourceFileId;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/DatasetFilePreviewStatusResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 数据集文件预览状态响应
+ */
+@Getter
+@Setter
+public class DatasetFilePreviewStatusResponse {
+    private KnowledgeItemPreviewStatus status;
+    private String previewError;
+    private String updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/DeleteKnowledgeItemsRequest.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+/**
+ * 批量删除知识条目请求
+ */
+@Getter
+@Setter
+public class DeleteKnowledgeItemsRequest {
+    /**
+     * 知识条目ID列表
+     */
+    @NotEmpty(message = "知识条目ID不能为空")
+    private List<String> ids;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeDirectoryQuery.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目目录查询参数
+ */
+@Getter
+@Setter
+public class KnowledgeDirectoryQuery {
+    /** 所属知识集ID */
+    private String setId;
+
+    /** 目录相对路径前缀 */
+    private String relativePath;
+
+    /** 搜索关键字 */
+    private String keyword;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeDirectoryResponse.java

@@ -0,0 +1,20 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * 知识条目目录响应
+ */
+@Getter
+@Setter
+public class KnowledgeDirectoryResponse {
+    private String id;
+    private String setId;
+    private String name;
+    private String relativePath;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemPagingQuery.java

@@ -41,4 +41,8 @@ public class KnowledgeItemPagingQuery extends PagingQuery {
      * 来源文件ID
      */
     private String sourceFileId;
+    /**
+     * 相对路径前缀
+     */
+    private String relativePath;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemPreviewStatusResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeItemPreviewStatus;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目预览状态响应
+ */
+@Getter
+@Setter
+public class KnowledgeItemPreviewStatusResponse {
+    private KnowledgeItemPreviewStatus status;
+    private String previewError;
+    private String updatedAt;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemResponse.java

@@ -20,6 +20,14 @@ public class KnowledgeItemResponse {
     private KnowledgeSourceType sourceType;
     private String sourceDatasetId;
     private String sourceFileId;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
     private LocalDateTime createdAt;
     private LocalDateTime updatedAt;
     private String createdBy;

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemSearchQuery.java

@@ -0,0 +1,17 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.common.interfaces.PagingQuery;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识条目文件搜索请求
+ */
+@Getter
+@Setter
+public class KnowledgeItemSearchQuery extends PagingQuery {
+    /**
+     * 文件名关键词
+     */
+    private String keyword;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeItemSearchResponse.java

@@ -0,0 +1,35 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import com.datamate.datamanagement.common.enums.KnowledgeContentType;
+import com.datamate.datamanagement.common.enums.KnowledgeSourceType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.time.LocalDateTime;
+
+/**
+ * 知识条目文件搜索响应
+ */
+@Getter
+@Setter
+public class KnowledgeItemSearchResponse {
+    private String id;
+    private String setId;
+    private String setName;
+    private KnowledgeContentType contentType;
+    private KnowledgeSourceType sourceType;
+    private String sourceDatasetId;
+    private String sourceFileId;
+    private String fileName;
+    private Long fileSize;
+    /**
+     * 相对路径（用于目录展示）
+     */
+    private String relativePath;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+
+    @JsonIgnore
+    private String content;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/KnowledgeManagementStatisticsResponse.java

@@ -0,0 +1,16 @@
+package com.datamate.datamanagement.interfaces.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 知识管理统计响应
+ */
+@Getter
+@Setter
+public class KnowledgeManagementStatisticsResponse {
+    private Long totalKnowledgeSets = 0L;
+    private Long totalFiles = 0L;
+    private Long totalSize = 0L;
+    private Long totalTags = 0L;
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateDatasetRequest.java

@@ -1,8 +1,10 @@
 package com.datamate.datamanagement.interfaces.dto;
 
 import com.datamate.datamanagement.common.enums.DatasetStatusType;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.Size;
+import lombok.AccessLevel;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -24,9 +26,18 @@ public class UpdateDatasetRequest {
     /** 归集任务id */
     private String dataSource;
     /** 父数据集ID */
+    @Setter(AccessLevel.NONE)
     private String parentDatasetId;
+    @JsonIgnore
+    @Setter(AccessLevel.NONE)
+    private boolean parentDatasetIdProvided;
     /** 标签列表 */
     private List<String> tags;
     /** 数据集状态 */
     private DatasetStatusType status;
+
+    public void setParentDatasetId(String parentDatasetId) {
+        this.parentDatasetIdProvided = true;
+        this.parentDatasetId = parentDatasetId;
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UpdateKnowledgeItemRequest.java

@@ -18,4 +18,8 @@ public class UpdateKnowledgeItemRequest {
      * 内容类型
      */
     private KnowledgeContentType contentType;
+    /**
+     * 扩展元数据
+     */
+    private String metadata;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UploadKnowledgeItemsRequest.java

@@ -17,4 +17,8 @@ public class UploadKnowledgeItemsRequest {
      */
     @NotEmpty(message = "文件列表不能为空")
     private List<MultipartFile> files;
+    /**
+     * 目录前缀（用于目录上传）
+     */
+    private String parentPrefix;
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetFileController.java

@@ -6,11 +6,13 @@ import com.datamate.common.infrastructure.exception.SystemErrorCode;
 import com.datamate.common.interfaces.PagedResponse;
 import com.datamate.common.interfaces.PagingQuery;
 import com.datamate.datamanagement.application.DatasetFileApplicationService;
+import com.datamate.datamanagement.application.DatasetFilePreviewService;
 import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
 import com.datamate.datamanagement.interfaces.converter.DatasetConverter;
 import com.datamate.datamanagement.interfaces.dto.AddFilesRequest;
 import com.datamate.datamanagement.interfaces.dto.CopyFilesRequest;
 import com.datamate.datamanagement.interfaces.dto.CreateDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.DatasetFilePreviewStatusResponse;
 import com.datamate.datamanagement.interfaces.dto.DatasetFileResponse;
 import com.datamate.datamanagement.interfaces.dto.UploadFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UploadFilesPreRequest;
@@ -19,6 +21,7 @@ import jakarta.validation.Valid;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.io.Resource;
+import org.springframework.core.io.UrlResource;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -37,10 +40,13 @@ import java.util.List;
 public class DatasetFileController {
 
     private final DatasetFileApplicationService datasetFileApplicationService;
+    private final DatasetFilePreviewService datasetFilePreviewService;
 
     @Autowired
-    public DatasetFileController(DatasetFileApplicationService datasetFileApplicationService) {
+    public DatasetFileController(DatasetFileApplicationService datasetFileApplicationService,
+                                 DatasetFilePreviewService datasetFilePreviewService) {
         this.datasetFileApplicationService = datasetFileApplicationService;
+        this.datasetFilePreviewService = datasetFilePreviewService;
     }
 
     @GetMapping
@@ -52,11 +58,17 @@ public class DatasetFileController {
             @RequestParam(value = "prefix", required = false, defaultValue = "") String prefix,
             @RequestParam(value = "status", required = false) String status,
             @RequestParam(value = "hasAnnotation", required = false) Boolean hasAnnotation,
-            @RequestParam(value = "excludeSourceDocuments", required = false, defaultValue = "false") Boolean excludeSourceDocuments) {
+            @RequestParam(value = "excludeSourceDocuments", required = false, defaultValue = "false") Boolean excludeSourceDocuments,
+            @RequestParam(value = "excludeDerivedFiles", required = false, defaultValue = "false") Boolean excludeDerivedFiles) {
         PagingQuery pagingQuery = new PagingQuery(page, size);
         PagedResponse<DatasetFile> filesPage;
         if (isWithDirectory) {
-            filesPage = datasetFileApplicationService.getDatasetFilesWithDirectory(datasetId, prefix, pagingQuery);
+            filesPage = datasetFileApplicationService.getDatasetFilesWithDirectory(
+                datasetId,
+                prefix,
+                Boolean.TRUE.equals(excludeDerivedFiles),
+                pagingQuery
+            );
         } else {
             filesPage = datasetFileApplicationService.getDatasetFiles(datasetId, null, status, null, hasAnnotation, 
                     Boolean.TRUE.equals(excludeSourceDocuments), pagingQuery);
@@ -114,6 +126,19 @@ public class DatasetFileController {
                                                            @PathVariable("fileId") String fileId) {
         try {
             DatasetFile datasetFile = datasetFileApplicationService.getDatasetFile(datasetId, fileId);
+            if (datasetFilePreviewService.isOfficeDocument(datasetFile.getFileName())) {
+                DatasetFilePreviewService.PreviewFile previewFile = datasetFilePreviewService
+                    .resolveReadyPreviewFile(datasetId, datasetFile);
+                if (previewFile == null) {
+                    return ResponseEntity.status(HttpStatus.CONFLICT).build();
+                }
+                Resource previewResource = new UrlResource(previewFile.filePath().toUri());
+                return ResponseEntity.ok()
+                        .contentType(MediaType.APPLICATION_PDF)
+                        .header(HttpHeaders.CONTENT_DISPOSITION,
+                                "inline; filename=\"" + previewFile.fileName() + "\"")
+                        .body(previewResource);
+            }
             Resource resource = datasetFileApplicationService.downloadFile(datasetId, fileId);
             MediaType mediaType = MediaTypeFactory.getMediaType(resource)
                     .orElse(MediaType.APPLICATION_OCTET_STREAM);
@@ -130,6 +155,18 @@ public class DatasetFileController {
         }
     }
 
+    @GetMapping("/{fileId}/preview/status")
+    public DatasetFilePreviewStatusResponse getDatasetFilePreviewStatus(@PathVariable("datasetId") String datasetId,
+                                                                        @PathVariable("fileId") String fileId) {
+        return datasetFilePreviewService.getPreviewStatus(datasetId, fileId);
+    }
+
+    @PostMapping("/{fileId}/preview/convert")
+    public DatasetFilePreviewStatusResponse convertDatasetFilePreview(@PathVariable("datasetId") String datasetId,
+                                                                      @PathVariable("fileId") String fileId) {
+        return datasetFilePreviewService.ensurePreview(datasetId, fileId);
+    }
+
     @IgnoreResponseWrap
     @GetMapping(value = "/download", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
     public void downloadDatasetFileAsZip(@PathVariable("datasetId") String datasetId, HttpServletResponse response) {

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetTypeController.java

@@ -23,7 +23,7 @@ public class DatasetTypeController {
     public List<DatasetTypeResponse> getDatasetTypes() {
         return Arrays.asList(
             createDatasetType("IMAGE", "图像数据集", "用于机器学习的图像数据集", Arrays.asList("jpg", "jpeg", "png", "bmp", "gif")),
-            createDatasetType("TEXT", "文本数据集", "用于文本分析的文本数据集", Arrays.asList("txt", "csv", "json", "xml")),
+            createDatasetType("TEXT", "文本数据集", "用于文本分析的文本数据集", Arrays.asList("txt", "csv", "xls", "xlsx", "json", "xml")),
             createDatasetType("AUDIO", "音频数据集", "用于音频处理的音频数据集", Arrays.asList("wav", "mp3", "flac", "aac")),
             createDatasetType("VIDEO", "视频数据集", "用于视频分析的视频数据集", Arrays.asList("mp4", "avi", "mov", "mkv")),
             createDatasetType("MULTIMODAL", "多模态数据集", "包含多种数据类型的数据集", List.of("*"))

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/DatasetUploadController.java

@@ -0,0 +1,33 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.datamanagement.application.DatasetFileApplicationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 数据集上传控制器
+ */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/datasets/upload")
+public class DatasetUploadController {
+
+    private final DatasetFileApplicationService datasetFileApplicationService;
+
+    /**
+     * 取消上传
+     *
+     * @param reqId 预上传请求ID
+     */
+    @PutMapping("/cancel-upload/{reqId}")
+    public ResponseEntity<Void> cancelUpload(@PathVariable("reqId") String reqId) {
+        datasetFileApplicationService.cancelUpload(reqId);
+        return ResponseEntity.ok().build();
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeDirectoryController.java

@@ -0,0 +1,43 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.datamanagement.application.KnowledgeDirectoryApplicationService;
+import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItemDirectory;
+import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
+import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeDirectoryRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeDirectoryResponse;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+/**
+ * 知识条目目录 REST 控制器
+ */
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/knowledge-sets/{setId}/directories")
+public class KnowledgeDirectoryController {
+    private final KnowledgeDirectoryApplicationService knowledgeDirectoryApplicationService;
+
+    @GetMapping
+    public List<KnowledgeDirectoryResponse> getKnowledgeDirectories(@PathVariable("setId") String setId,
+                                                                   KnowledgeDirectoryQuery query) {
+        List<KnowledgeItemDirectory> directories = knowledgeDirectoryApplicationService.getKnowledgeDirectories(setId, query);
+        return KnowledgeConverter.INSTANCE.convertDirectoryResponses(directories);
+    }
+
+    @PostMapping
+    public KnowledgeDirectoryResponse createKnowledgeDirectory(@PathVariable("setId") String setId,
+                                                              @RequestBody @Valid CreateKnowledgeDirectoryRequest request) {
+        KnowledgeItemDirectory directory = knowledgeDirectoryApplicationService.createKnowledgeDirectory(setId, request);
+        return KnowledgeConverter.INSTANCE.convertToResponse(directory);
+    }
+
+    @DeleteMapping
+    public void deleteKnowledgeDirectory(@PathVariable("setId") String setId,
+                                         @RequestParam("relativePath") String relativePath) {
+        knowledgeDirectoryApplicationService.deleteKnowledgeDirectory(setId, relativePath);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeItemController.java

@@ -3,11 +3,14 @@ package com.datamate.datamanagement.interfaces.rest;
 import com.datamate.common.infrastructure.common.IgnoreResponseWrap;
 import com.datamate.common.interfaces.PagedResponse;
 import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
+import com.datamate.datamanagement.application.KnowledgeItemPreviewService;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeItemRequest;
+import com.datamate.datamanagement.interfaces.dto.DeleteKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPreviewStatusResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
 import com.datamate.datamanagement.interfaces.dto.ReplaceKnowledgeItemFileRequest;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
@@ -30,6 +33,7 @@ import java.util.List;
 @RequestMapping("/data-management/knowledge-sets/{setId}/items")
 public class KnowledgeItemController {
     private final KnowledgeItemApplicationService knowledgeItemApplicationService;
+    private final KnowledgeItemPreviewService knowledgeItemPreviewService;
 
     @GetMapping
     public PagedResponse<KnowledgeItemResponse> getKnowledgeItems(@PathVariable("setId") String setId,
@@ -80,6 +84,18 @@ public class KnowledgeItemController {
         knowledgeItemApplicationService.previewKnowledgeItemFile(setId, itemId, response);
     }
 
+    @GetMapping("/{itemId}/preview/status")
+    public KnowledgeItemPreviewStatusResponse getKnowledgeItemPreviewStatus(@PathVariable("setId") String setId,
+                                                                            @PathVariable("itemId") String itemId) {
+        return knowledgeItemPreviewService.getPreviewStatus(setId, itemId);
+    }
+
+    @PostMapping("/{itemId}/preview/convert")
+    public KnowledgeItemPreviewStatusResponse convertKnowledgeItemPreview(@PathVariable("setId") String setId,
+                                                                          @PathVariable("itemId") String itemId) {
+        return knowledgeItemPreviewService.ensurePreview(setId, itemId);
+    }
+
     @GetMapping("/{itemId}")
     public KnowledgeItemResponse getKnowledgeItemById(@PathVariable("setId") String setId,
                                                       @PathVariable("itemId") String itemId) {
@@ -108,4 +124,10 @@ public class KnowledgeItemController {
                                     @PathVariable("itemId") String itemId) {
         knowledgeItemApplicationService.deleteKnowledgeItem(setId, itemId);
     }
+
+    @PostMapping("/batch-delete")
+    public void deleteKnowledgeItems(@PathVariable("setId") String setId,
+                                     @RequestBody @Valid DeleteKnowledgeItemsRequest request) {
+        knowledgeItemApplicationService.deleteKnowledgeItems(setId, request);
+    }
 }

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeItemSearchController.java

@@ -0,0 +1,27 @@
+package com.datamate.datamanagement.interfaces.rest;
+
+import com.datamate.common.interfaces.PagedResponse;
+import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchQuery;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeItemSearchResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 知识条目搜索控制器
+ */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/data-management/knowledge-items")
+public class KnowledgeItemSearchController {
+    private final KnowledgeItemApplicationService knowledgeItemApplicationService;
+
+    @GetMapping("/search")
+    public PagedResponse<KnowledgeItemSearchResponse> search(KnowledgeItemSearchQuery query) {
+        return knowledgeItemApplicationService.searchKnowledgeItems(query);
+    }
+}

backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeSetController.java

@@ -1,10 +1,12 @@
 package com.datamate.datamanagement.interfaces.rest;
 
 import com.datamate.common.interfaces.PagedResponse;
+import com.datamate.datamanagement.application.KnowledgeItemApplicationService;
 import com.datamate.datamanagement.application.KnowledgeSetApplicationService;
 import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
 import com.datamate.datamanagement.interfaces.converter.KnowledgeConverter;
 import com.datamate.datamanagement.interfaces.dto.CreateKnowledgeSetRequest;
+import com.datamate.datamanagement.interfaces.dto.KnowledgeManagementStatisticsResponse;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetPagingQuery;
 import com.datamate.datamanagement.interfaces.dto.KnowledgeSetResponse;
 import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeSetRequest;
@@ -22,6 +24,7 @@ import org.springframework.web.bind.annotation.*;
 @RequestMapping("/data-management/knowledge-sets")
 public class KnowledgeSetController {
     private final KnowledgeSetApplicationService knowledgeSetApplicationService;
+    private final KnowledgeItemApplicationService knowledgeItemApplicationService;
 
     @GetMapping
     public PagedResponse<KnowledgeSetResponse> getKnowledgeSets(KnowledgeSetPagingQuery query) {
@@ -51,4 +54,9 @@ public class KnowledgeSetController {
     public void deleteKnowledgeSet(@PathVariable("setId") String setId) {
         knowledgeSetApplicationService.deleteKnowledgeSet(setId);
     }
+
+    @GetMapping("/statistics")
+    public KnowledgeManagementStatisticsResponse getKnowledgeManagementStatistics() {
+        return knowledgeItemApplicationService.getKnowledgeManagementStatistics();
+    }
 }

backend/services/data-management-service/src/main/resources/mappers/DatasetFileMapper.xml

@@ -42,6 +42,13 @@
         SELECT COUNT(*) FROM t_dm_dataset_files WHERE dataset_id = #{datasetId}
     </select>
 
+    <select id="countNonDerivedByDatasetId" parameterType="string" resultType="long">
+        SELECT COUNT(*)
+        FROM t_dm_dataset_files
+        WHERE dataset_id = #{datasetId}
+          AND (metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL)
+    </select>
+
     <select id="countCompletedByDatasetId" parameterType="string" resultType="long">
         SELECT COUNT(*) FROM t_dm_dataset_files WHERE dataset_id = #{datasetId} AND status = 'COMPLETED'
     </select>
@@ -110,4 +117,16 @@
           AND metadata IS NOT NULL
           AND JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NOT NULL
     </select>
+
+    <select id="countNonDerivedByDatasetIds" resultType="com.datamate.datamanagement.infrastructure.persistence.repository.dto.DatasetFileCount">
+        SELECT dataset_id AS datasetId,
+               COUNT(*) AS fileCount
+        FROM t_dm_dataset_files
+        WHERE dataset_id IN
+        <foreach collection="datasetIds" item="datasetId" open="(" separator="," close=")">
+            #{datasetId}
+        </foreach>
+          AND (metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL)
+        GROUP BY dataset_id
+    </select>
 </mapper>

backend/services/data-management-service/src/main/resources/mappers/DatasetMapper.xml

@@ -145,9 +145,10 @@
 
     <select id="getAllDatasetStatistics" resultType="com.datamate.datamanagement.interfaces.dto.AllDatasetStatisticsResponse">
       SELECT
-        COUNT(*) AS total_datasets,
+        (SELECT COUNT(*) FROM t_dm_datasets) AS total_datasets,
-        SUM(size_bytes) AS total_size,
+        (SELECT COALESCE(SUM(size_bytes), 0) FROM t_dm_datasets) AS total_size,
-        SUM(file_count) AS total_files
+        (SELECT COUNT(*)
-      FROM t_dm_datasets;
+         FROM t_dm_dataset_files
+         WHERE metadata IS NULL OR JSON_EXTRACT(metadata, '$.derived_from_file_id') IS NULL) AS total_files
     </select>
 </mapper>

backend/services/data-management-service/src/main/resources/mappers/TagMapper.xml

@@ -53,6 +53,19 @@
         ORDER BY usage_count DESC, name ASC
     </select>
 
+    <select id="countKnowledgeSetTags" resultType="long">
+        SELECT COUNT(DISTINCT t.id)
+        FROM t_dm_tags t
+        WHERE EXISTS (
+            SELECT 1
+            FROM t_dm_knowledge_sets ks
+            WHERE ks.tags IS NOT NULL
+              AND JSON_VALID(ks.tags) = 1
+              AND JSON_LENGTH(ks.tags) > 0
+              AND JSON_SEARCH(ks.tags, 'one', t.name, NULL, '$[*].name') IS NOT NULL
+        )
+    </select>
+
     <insert id="insert" parameterType="com.datamate.datamanagement.domain.model.dataset.Tag">
         INSERT INTO t_dm_tags (id, name, description, category, color, usage_count)
         VALUES (#{id}, #{name}, #{description}, #{category}, #{color}, #{usageCount})

backend/services/main-application/src/main/java/com/datamate/main/config/SecurityConfig.java

@@ -17,6 +17,7 @@ public class SecurityConfig {
     @Bean
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http.csrf(csrf -> csrf.disable())
+            .headers(headers -> headers.frameOptions(frameOptions -> frameOptions.disable()))
             .authorizeHttpRequests(authz -> authz
                 .anyRequest().permitAll()  // 允许所有请求无需认证
             );

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/application/KnowledgeBaseService.java

@@ -140,6 +140,7 @@ public class KnowledgeBaseService {
         return PagedResponse.of(respList, page.getCurrent(), page.getTotal(), page.getPages());
     }
 
+
     @Transactional(rollbackFor = Exception.class)
     public void addFiles(AddFilesReq request) {
         KnowledgeBase knowledgeBase = Optional.ofNullable(knowledgeBaseRepository.getById(request.getKnowledgeBaseId()))

backend/services/rag-indexer-service/src/main/java/com/datamate/rag/indexer/interfaces/KnowledgeBaseController.java

@@ -80,6 +80,7 @@ public class KnowledgeBaseController {
         return knowledgeBaseService.list(request);
     }
 
+
     /**
      * 添加文件到知识库
      *

backend/shared/domain-common/src/main/java/com/datamate/common/domain/service/FileService.java

@@ -21,7 +21,7 @@ import java.util.UUID;
  */
 @Component
 public class FileService {
-    private static final int DEFAULT_TIMEOUT = 120;
+    private static final int DEFAULT_TIMEOUT = 1800;
 
     private final ChunkUploadRequestMapper chunkUploadRequestMapper;
 
@@ -74,6 +74,26 @@ public class FileService {
             .build();
     }
 
+    /**
+     * 取消上传
+     */
+    @Transactional
+    public void cancelUpload(String reqId) {
+        if (reqId == null || reqId.isBlank()) {
+            throw BusinessException.of(CommonErrorCode.PARAM_ERROR);
+        }
+        ChunkUploadPreRequest preRequest = chunkUploadRequestMapper.findById(reqId);
+        if (preRequest == null) {
+            return;
+        }
+        String uploadPath = preRequest.getUploadPath();
+        if (uploadPath != null && !uploadPath.isBlank()) {
+            File tempDir = new File(uploadPath, String.format(ChunksSaver.TEMP_DIR_NAME_FORMAT, preRequest.getId()));
+            ChunksSaver.deleteFolder(tempDir.getPath());
+        }
+        chunkUploadRequestMapper.deleteById(reqId);
+    }
+
     private File uploadFile(ChunkUploadRequest fileUploadRequest, ChunkUploadPreRequest preRequest) {
         File savedFile = ChunksSaver.saveFile(fileUploadRequest, preRequest);
         preRequest.setTimeout(LocalDateTime.now().plusSeconds(DEFAULT_TIMEOUT));

deployment/docker/datamate/backend.conf

@@ -5,7 +5,7 @@ server {
     access_log /var/log/datamate/frontend/access.log main;
     error_log /var/log/datamate/frontend/error.log notice;
 
-    client_max_body_size 1024M;
+    client_max_body_size 0;
 
     add_header Set-Cookie "NEXT_LOCALE=zh";
 

deployment/docker/datamate/docker-compose.yml

@@ -11,6 +11,7 @@ services:
       - log_volume:/var/log/datamate
       - operator-upload-volume:/operators/upload
       - operator-runtime-volume:/operators/extract
+      - uploads_volume:/uploads
     networks: [ datamate ]
     depends_on:
       - datamate-database
@@ -154,6 +155,8 @@ services:
     profiles: [ data-juicer ]
 
 volumes:
+  uploads_volume:
+    name: datamate-uploads-volume
   dataset_volume:
     name: datamate-dataset-volume
   flow_volume:

deployment/docker/milvus/docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   etcd:
     container_name: milvus-etcd
-    image: quay.io/coreos/etcd:v3.5.18
+    image: quay.nju.edu.cn/coreos/etcd:v3.5.18
     environment:
       - ETCD_AUTO_COMPACTION_MODE=revision
       - ETCD_AUTO_COMPACTION_RETENTION=1000

frontend/public/lsf/lsf.html

@@ -169,6 +169,33 @@
           }
         }
 
+        function isAnnotationObject(value) {
+          if (!value || typeof value !== "object") return false;
+          return typeof value.serializeAnnotation === "function" || typeof value.serialize === "function";
+        }
+
+        function resolveSelectedAnnotation(store) {
+          if (!store) return null;
+          const annotations = Array.isArray(store.annotations) ? store.annotations : [];
+          if (isAnnotationObject(store.selectedAnnotation)) {
+            return store.selectedAnnotation;
+          }
+          if (isAnnotationObject(store.selected)) {
+            return store.selected;
+          }
+          const selectedId = store.selected;
+          if (selectedId !== undefined && selectedId !== null && annotations.length) {
+            const matched = annotations.find((ann) => ann && String(ann.id) === String(selectedId));
+            if (isAnnotationObject(matched)) {
+              return matched;
+            }
+          }
+          if (annotations.length && isAnnotationObject(annotations[0])) {
+            return annotations[0];
+          }
+          return null;
+        }
+
         function exportSelectedAnnotation() {
           if (!lsInstance) {
             throw new Error("LabelStudio 未初始化");
@@ -179,10 +206,10 @@
             throw new Error("无法访问 annotationStore");
           }
 
-          const selected =
+          const selected = resolveSelectedAnnotation(store);
-            store.selected ||
+          if (!selected) {
-            store.selectedAnnotation ||
+            throw new Error("未找到可导出的标注对象");
-            (Array.isArray(store.annotations) && store.annotations.length ? store.annotations[0] : null);
+          }
 
           let serialized = null;
           if (selected && typeof selected.serializeAnnotation === "function") {
@@ -197,6 +224,10 @@
               ? { id: selected?.id || serialized.id || "draft", ...serialized }
               : { id: selected?.id || "draft", result: (selected && selected.result) || [] };
 
+          if (!Array.isArray(annotationPayload.result) && Array.isArray(annotationPayload.results)) {
+            annotationPayload.result = annotationPayload.results;
+          }
+
           // 最小化对齐 Label Studio Server 的字段（DataMate 侧会原样存储）
           const taskId = typeof currentTask?.id === "number" ? currentTask.id : Number(currentTask?.id) || null;
           const fileId = currentTask?.data?.file_id || currentTask?.data?.fileId || null;
@@ -226,6 +257,52 @@
           };
         }
 
+        function isSaveAndNextShortcut(event) {
+          if (!event || event.defaultPrevented || event.isComposing) return false;
+          const key = event.key;
+          const code = event.code;
+          const isEnter = key === "Enter" || code === "Enter" || code === "NumpadEnter";
+          if (!isEnter) return false;
+          if (!(event.ctrlKey || event.metaKey)) return false;
+          if (event.shiftKey || event.altKey) return false;
+          return true;
+        }
+
+        function isSaveShortcut(event) {
+          if (!event || event.defaultPrevented || event.isComposing) return false;
+          const key = event.key;
+          const code = event.code;
+          const isS = key === "s" || key === "S" || code === "KeyS";
+          if (!isS) return false;
+          if (!(event.ctrlKey || event.metaKey)) return false;
+          if (event.shiftKey || event.altKey) return false;
+          return true;
+        }
+
+        function handleSaveAndNextShortcut(event) {
+          if (!isSaveAndNextShortcut(event) || event.repeat) return;
+          event.preventDefault();
+          event.stopPropagation();
+          try {
+            const raw = exportSelectedAnnotation();
+            postToParent("LS_SAVE_AND_NEXT", raw);
+          } catch (e) {
+            postToParent("LS_ERROR", { message: e?.message || String(e) });
+          }
+        }
+
+        function handleSaveShortcut(event) {
+          if (!isSaveShortcut(event) || event.repeat) return;
+          event.preventDefault();
+          event.stopPropagation();
+          try {
+            const raw = exportSelectedAnnotation();
+            postToParent("LS_EXPORT_RESULT", raw);
+          } catch (e) {
+            postToParent("LS_ERROR", { message: e?.message || String(e) });
+          }
+        }
+
         function initLabelStudio(payload) {
           if (!window.LabelStudio) {
             throw new Error("LabelStudio 未加载（请检查静态资源/网络）");
@@ -296,6 +373,9 @@
           });
         }
 
+        window.addEventListener("keydown", handleSaveAndNextShortcut);
+        window.addEventListener("keydown", handleSaveShortcut);
+
         window.addEventListener("message", (event) => {
           if (event.origin !== ORIGIN) return;
 

frontend/src/components/AddTagPopover.tsx

@@ -1,17 +1,17 @@
 import { Button, Input, Popover, theme, Tag, Empty } from "antd";
 import { PlusOutlined } from "@ant-design/icons";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 
 interface Tag {
-  id: number;
+  id?: string | number;
   name: string;
-  color: string;
+  color?: string;
 }
 
 interface AddTagPopoverProps {
   tags: Tag[];
   onFetchTags?: () => Promise<Tag[]>;
-  onAddTag?: (tag: Tag) => void;
+  onAddTag?: (tagName: string) => void;
   onCreateAndTag?: (tagName: string) => void;
 }
 
@@ -27,20 +27,23 @@ export default function AddTagPopover({
   const [newTag, setNewTag] = useState("");
   const [allTags, setAllTags] = useState<Tag[]>([]);
 
-  const tagsSet = useMemo(() => new Set(tags.map((tag) => tag.id)), [tags]);
+  const tagsSet = useMemo(
+    () => new Set(tags.map((tag) => (tag.id ?? tag.name))),
+    [tags]
+  );
 
-  const fetchTags = async () => {
+  const fetchTags = useCallback(async () => {
     if (onFetchTags && showPopover) {
       const data = await onFetchTags?.();
       setAllTags(data || []);
     }
-  };
+  }, [onFetchTags, showPopover]);
   useEffect(() => {
     fetchTags();
-  }, [showPopover]);
+  }, [fetchTags]);
 
   const availableTags = useMemo(() => {
-    return allTags.filter((tag) => !tagsSet.has(tag.id));
+    return allTags.filter((tag) => !tagsSet.has(tag.id ?? tag.name));
   }, [allTags, tagsSet]);
 
   const handleCreateAndAddTag = () => {

frontend/src/components/CardView.tsx

@@ -276,7 +276,7 @@ function CardView<T extends BaseCardDataType>(props: CardViewProps<T>) {
                     {formatDateTime(item?.updatedAt)}
                   </div>
                 </div>
-                {operations && (
+                {operations && ops(item).length > 0 && (
                   <ActionDropdown
                     actions={ops(item)}
                     onAction={(key) => {

frontend/src/components/DetailHeader.tsx

@@ -24,21 +24,28 @@ interface OperationItem {
 
 interface TagConfig {
   showAdd: boolean;
-  tags: { id: number; name: string; color: string }[];
+  tags: { id?: string | number; name: string; color?: string }[];
-  onFetchTags?: () => Promise<{
+  onFetchTags?: () => Promise<{ id?: string | number; name: string; color?: string }[]>;
-    data: { id: number; name: string; color: string }[];
+  onAddTag?: (tagName: string) => void;
-  }>;
-  onAddTag?: (tag: { id: number; name: string; color: string }) => void;
   onCreateAndTag?: (tagName: string) => void;
 }
-interface DetailHeaderProps<T> {
+interface DetailHeaderData {
+  name?: string;
+  description?: string;
+  status?: { color?: string; icon?: React.ReactNode; label?: string };
+  tags?: { id?: string | number; name?: string }[];
+  icon?: React.ReactNode;
+  iconColor?: string;
+}
+
+interface DetailHeaderProps<T extends DetailHeaderData> {
   data: T;
   statistics: StatisticItem[];
   operations: OperationItem[];
   tagConfig?: TagConfig;
 }
 
-function DetailHeader<T>({
+function DetailHeader<T extends DetailHeaderData>({
   data = {} as T,
   statistics,
   operations,
@@ -50,13 +57,13 @@ function DetailHeader<T>({
         <div className="flex items-start gap-4 flex-1">
           <div
             className={`w-16 h-16 text-white rounded-lg flex-center shadow-lg ${
-              (data as any)?.iconColor
+              data?.iconColor
                 ? ""
                 : "bg-gradient-to-br from-sky-300 to-blue-500 text-white"
             }`}
-            style={(data as any)?.iconColor ? { backgroundColor: (data as any).iconColor } : undefined}
+            style={data?.iconColor ? { backgroundColor: data.iconColor } : undefined}
           >
-            {<div className="w-[2.8rem] h-[2.8rem] text-gray-50">{(data as any)?.icon}</div> || (
+            {<div className="w-[2.8rem] h-[2.8rem] text-gray-50">{data?.icon}</div> || (
               <Database className="w-8 h-8 text-white" />
             )}
           </div>

frontend/src/components/ProtectedRoute.tsx

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Navigate, useLocation, Outlet } from 'react-router';
+import { useAppSelector } from '@/store/hooks';
+
+interface ProtectedRouteProps {
+  children?: React.ReactNode;
+}
+
+const ProtectedRoute: React.FC<ProtectedRouteProps> = ({ children }) => {
+  const { isAuthenticated } = useAppSelector((state) => state.auth);
+  const location = useLocation();
+
+  if (!isAuthenticated) {
+    // Redirect to the login page, but save the current location they were trying to go to
+    return <Navigate to="/login" state={{ from: location }} replace />;
+  }
+
+  return children ? <>{children}</> : <Outlet />;
+};
+
+export default ProtectedRoute;

frontend/src/components/business/DatasetFileTransfer.tsx

@@ -23,8 +23,7 @@ interface DatasetFileTransferProps
   datasetTypeFilter?: DatasetType;
   hasAnnotationFilter?: boolean;
   /**
-   * 是否排除已被转换为TXT的源文档文件（PDF/DOC/DOCX）
+   * 是否排除源文档文件（PDF/DOC/DOCX/XLS/XLSX），文本标注默认启用
-   * 默认为 true，当 datasetTypeFilter 为 TEXT 时自动启用
    */
   excludeSourceDocuments?: boolean;
 }

frontend/src/hooks/useSliceUpload.tsx

@@ -1,5 +1,5 @@
 import { TaskItem } from "@/pages/DataManagement/dataset.model";
-import { calculateSHA256, checkIsFilesExist } from "@/utils/file.util";
+import { calculateSHA256, checkIsFilesExist, streamSplitAndUpload, StreamUploadResult } from "@/utils/file.util";
 import { App } from "antd";
 import { useRef, useState } from "react";
 
@@ -9,17 +9,18 @@ export function useFileSliceUpload(
     uploadChunk,
     cancelUpload,
   }: {
-    preUpload: (id: string, params: any) => Promise<{ data: number }>;
+    preUpload: (id: string, params: Record<string, unknown>) => Promise<{ data: number }>;
-    uploadChunk: (id: string, formData: FormData, config: any) => Promise<any>;
+    uploadChunk: (id: string, formData: FormData, config: Record<string, unknown>) => Promise<unknown>;
-    cancelUpload: ((reqId: number) => Promise<any>) | null;
+    cancelUpload: ((reqId: number) => Promise<unknown>) | null;
   },
-  showTaskCenter = true // 上传时是否显示任务中心
+  showTaskCenter = true, // 上传时是否显示任务中心
+  enableStreamUpload = true // 是否启用流式分割上传
 ) {
   const { message } = App.useApp();
   const [taskList, setTaskList] = useState<TaskItem[]>([]);
   const taskListRef = useRef<TaskItem[]>([]); // 用于固定任务顺序
 
-  const createTask = (detail: any = {}) => {
+  const createTask = (detail: Record<string, unknown> = {}) => {
     const { dataset } = detail;
     const title = `上传数据集: ${dataset.name} `;
     const controller = new AbortController();
@@ -37,6 +38,14 @@ export function useFileSliceUpload(
     taskListRef.current = [task, ...taskListRef.current];
 
     setTaskList(taskListRef.current);
+    
+    // 立即显示任务中心，让用户感知上传已开始
+    if (showTaskCenter) {
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
+    }
+    
     return task;
   };
 
@@ -60,7 +69,7 @@ export function useFileSliceUpload(
       // 携带前缀信息，便于刷新后仍停留在当前目录
       window.dispatchEvent(
         new CustomEvent(task.updateEvent, {
-          detail: { prefix: (task as any).prefix },
+          detail: { prefix: task.prefix },
         })
       );
     }
@@ -71,7 +80,7 @@ export function useFileSliceUpload(
     }
   };
 
-  async function buildFormData({ file, reqId, i, j }) {
+  async function buildFormData({ file, reqId, i, j }: { file: { slices: Blob[]; name: string; size: number }; reqId: number; i: number; j: number }) {
     const formData = new FormData();
     const { slices, name, size } = file;
     const checkSum = await calculateSHA256(slices[j]);
@@ -86,12 +95,18 @@ export function useFileSliceUpload(
     return formData;
   }
 
-  async function uploadSlice(task: TaskItem, fileInfo) {
+  async function uploadSlice(task: TaskItem, fileInfo: { loaded: number; i: number; j: number; files: { slices: Blob[]; name: string; size: number }[]; totalSize: number }) {
     if (!task) {
       return;
     }
-    const { reqId, key } = task;
+    const { reqId, key, controller } = task;
     const { loaded, i, j, files, totalSize } = fileInfo;
+    
+    // 检查是否已取消
+    if (controller.signal.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    
     const formData = await buildFormData({
       file: files[i],
       i,
@@ -101,6 +116,7 @@ export function useFileSliceUpload(
 
     let newTask = { ...task };
     await uploadChunk(key, formData, {
+      signal: controller.signal,
       onUploadProgress: (e) => {
         const loadedSize = loaded + e.loaded;
         const curPercent = Number((loadedSize / totalSize) * 100).toFixed(2);
@@ -116,7 +132,7 @@ export function useFileSliceUpload(
     });
   }
 
-  async function uploadFile({ task, files, totalSize }) {
+  async function uploadFile({ task, files, totalSize }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[]; totalSize: number }) {
     console.log('[useSliceUpload] Calling preUpload with prefix:', task.prefix);
     const { data: reqId } = await preUpload(task.key, {
       totalFileNum: files.length,
@@ -132,24 +148,29 @@ export function useFileSliceUpload(
       reqId,
       isCancel: false,
       cancelFn: () => {
-        task.controller.abort();
+        // 使用 newTask 的 controller 确保一致性
+        newTask.controller.abort();
         cancelUpload?.(reqId);
-        if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
+        if (newTask.updateEvent) window.dispatchEvent(new Event(newTask.updateEvent));
       },
     };
     updateTaskList(newTask);
-    if (showTaskCenter) {
+    // 注意：show:task-popover 事件已在 createTask 中触发，此处不再重复触发
-      window.dispatchEvent(
-        new CustomEvent("show:task-popover", { detail: { show: true } })
-      );
-    }
     // // 更新数据状态
     if (task.updateEvent) window.dispatchEvent(new Event(task.updateEvent));
 
     let loaded = 0;
     for (let i = 0; i < files.length; i++) {
+      // 检查是否已取消
+      if (newTask.controller.signal.aborted) {
+        throw new Error("Upload cancelled");
+      }
       const { slices } = files[i];
       for (let j = 0; j < slices.length; j++) {
+        // 检查是否已取消
+        if (newTask.controller.signal.aborted) {
+          throw new Error("Upload cancelled");
+        }
         await uploadSlice(newTask, {
           loaded,
           i,
@@ -163,7 +184,7 @@ export function useFileSliceUpload(
     removeTask(newTask);
   }
 
-  const handleUpload = async ({ task, files }) => {
+  const handleUpload = async ({ task, files }: { task: TaskItem; files: { slices: Blob[]; name: string; size: number; originFile: Blob }[] }) => {
     const isErrorFile = await checkIsFilesExist(files);
     if (isErrorFile) {
       message.error("文件被修改或删除，请重新选择文件上传");
@@ -189,10 +210,174 @@ export function useFileSliceUpload(
     }
   };
 
+  /**
+   * 流式分割上传处理
+   * 用于大文件按行分割并立即上传的场景
+   */
+  const handleStreamUpload = async ({ task, files }: { task: TaskItem; files: File[] }) => {
+    try {
+      console.log('[useSliceUpload] Starting stream upload for', files.length, 'files');
+      
+      const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+      
+      // 存储所有文件的 reqId，用于取消上传
+      const reqIds: number[] = [];
+      
+      const newTask: TaskItem = {
+        ...task,
+        reqId: -1,
+        isCancel: false,
+        cancelFn: () => {
+          // 使用 newTask 的 controller 确保一致性
+          newTask.controller.abort();
+          // 取消所有文件的预上传请求
+          reqIds.forEach(id => cancelUpload?.(id));
+          if (newTask.updateEvent) window.dispatchEvent(new Event(newTask.updateEvent));
+        },
+      };
+      updateTaskList(newTask);
+
+      let totalUploadedLines = 0;
+      let totalProcessedBytes = 0;
+      const results: StreamUploadResult[] = [];
+
+      // 逐个处理文件，每个文件单独调用 preUpload
+      for (let i = 0; i < files.length; i++) {
+        // 检查是否已取消
+        if (newTask.controller.signal.aborted) {
+          throw new Error("Upload cancelled");
+        }
+        
+        const file = files[i];
+        console.log(`[useSliceUpload] Processing file ${i + 1}/${files.length}: ${file.name}`);
+        
+        const result = await streamSplitAndUpload(
+          file,
+          (formData, config) => uploadChunk(task.key, formData, {
+            ...config,
+            signal: newTask.controller.signal,
+          }),
+          (currentBytes, totalBytes, uploadedLines) => {
+            // 检查是否已取消
+            if (newTask.controller.signal.aborted) {
+              return;
+            }
+            
+            // 更新进度
+            const overallBytes = totalProcessedBytes + currentBytes;
+            const curPercent = Number((overallBytes / totalSize) * 100).toFixed(2);
+            
+            const updatedTask: TaskItem = {
+              ...newTask,
+              ...taskListRef.current.find((item) => item.key === task.key),
+              size: overallBytes,
+              percent: curPercent >= 100 ? 99.99 : curPercent,
+              streamUploadInfo: {
+                currentFile: file.name,
+                fileIndex: i + 1,
+                totalFiles: files.length,
+                uploadedLines: totalUploadedLines + uploadedLines,
+              },
+            };
+            updateTaskList(updatedTask);
+          }, 
+          1024 * 1024, // 1MB chunk size
+          {
+            resolveReqId: async ({ totalFileNum, totalSize }) => {
+              const { data: reqId } = await preUpload(task.key, {
+                totalFileNum,
+                totalSize,
+                datasetId: task.key,
+                hasArchive: task.hasArchive,
+                prefix: task.prefix,
+              });
+              console.log(`[useSliceUpload] File ${file.name} preUpload response reqId:`, reqId);
+              reqIds.push(reqId);
+              return reqId;
+            },
+            hasArchive: newTask.hasArchive,
+            prefix: newTask.prefix,
+            signal: newTask.controller.signal,
+            maxConcurrency: 3,
+          }
+        );
+        
+        results.push(result);
+        totalUploadedLines += result.uploadedCount;
+        totalProcessedBytes += file.size;
+        
+        console.log(`[useSliceUpload] File ${file.name} processed, uploaded ${result.uploadedCount} lines`);
+      }
+
+      console.log('[useSliceUpload] Stream upload completed, total lines:', totalUploadedLines);
+      removeTask(newTask);
+      
+      message.success(`成功上传 ${totalUploadedLines} 个文件（按行分割）`);
+    } catch (err) {
+      console.error('[useSliceUpload] Stream upload error:', err);
+      if (err.message === "Upload cancelled") {
+        message.info("上传已取消");
+      } else {
+        message.error("文件上传失败，请稍后重试");
+      }
+      removeTask({
+        ...task,
+        isCancel: true,
+        ...taskListRef.current.find((item) => item.key === task.key),
+      });
+    }
+  };
+
+  /**
+   * 注册流式上传事件监听
+   * 返回注销函数
+   */
+  const registerStreamUploadListener = () => {
+    if (!enableStreamUpload) return () => {};
+
+    const streamUploadHandler = async (e: Event) => {
+      const customEvent = e as CustomEvent;
+      const { dataset, files, updateEvent, hasArchive, prefix } = customEvent.detail;
+      
+      const controller = new AbortController();
+      const task: TaskItem = {
+        key: dataset.id,
+        title: `上传数据集: ${dataset.name} (按行分割)`,
+        percent: 0,
+        reqId: -1,
+        controller,
+        size: 0,
+        updateEvent,
+        hasArchive,
+        prefix,
+      };
+      
+      taskListRef.current = [task, ...taskListRef.current];
+      setTaskList(taskListRef.current);
+      
+      // 显示任务中心
+      if (showTaskCenter) {
+        window.dispatchEvent(
+          new CustomEvent("show:task-popover", { detail: { show: true } })
+        );
+      }
+      
+      await handleStreamUpload({ task, files });
+    };
+
+    window.addEventListener("upload:dataset-stream", streamUploadHandler);
+    
+    return () => {
+      window.removeEventListener("upload:dataset-stream", streamUploadHandler);
+    };
+  };
+
   return {
     taskList,
     createTask,
     removeTask,
     handleUpload,
+    handleStreamUpload,
+    registerStreamUploadListener,
   };
 }

frontend/src/pages/ContentGeneration/ContentGenerationPage.tsx

@@ -3,7 +3,9 @@
  * 通过 iframe 加载外部页面
  */
 export default function ContentGenerationPage() {
-  const iframeUrl = "http://192.168.0.8:3000";
+  const iframeUrl = "/api#/meeting";
+
+  window.localStorage.setItem("geeker-user", '{"token":"123","userInfo":{"name":"xteam"},"loginFrom":null,"loginData":null}');
 
   return (
     <div className="h-full w-full flex flex-col">
@@ -16,6 +18,11 @@ export default function ContentGenerationPage() {
           className="w-full h-full border-0"
           title="内容生成"
           sandbox="allow-same-origin allow-scripts allow-popups allow-forms allow-downloads"
+	  style={{marginLeft: "-220px",
+		  marginTop: "-66px",
+	          width: "calc(100% + 233px)",
+		  height: "calc(100% + 108px)"
+	  }}
         />
       </div>
     </div>

frontend/src/pages/DataAnnotation/Annotate/LabelStudioTextEditor.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { App, Button, Card, List, Spin, Typography, Tag, Switch, Tree, Empty } from "antd";
+import { App, Button, Card, List, Spin, Typography, Tag, Empty } from "antd";
-import { LeftOutlined, ReloadOutlined, SaveOutlined, MenuFoldOutlined, MenuUnfoldOutlined, CheckOutlined } from "@ant-design/icons";
+import { LeftOutlined, ReloadOutlined, SaveOutlined, MenuFoldOutlined, MenuUnfoldOutlined } from "@ant-design/icons";
 import { useNavigate, useParams } from "react-router";
 
 import {
@@ -9,6 +9,7 @@ import {
   listEditorTasksUsingGet,
   upsertEditorAnnotationUsingPut,
 } from "../annotation.api";
+import { AnnotationResultStatus } from "../annotation.model";
 
 type EditorProjectInfo = {
   projectId: string;
@@ -26,6 +27,7 @@ type EditorTaskListItem = {
   fileType?: string | null;
   hasAnnotation: boolean;
   annotationUpdatedAt?: string | null;
+  annotationStatus?: AnnotationResultStatus | null;
 };
 
 type LsfMessage = {
@@ -33,16 +35,6 @@ type LsfMessage = {
   payload?: unknown;
 };
 
-type SegmentInfo = {
-  idx: number;
-  text: string;
-  start: number;
-  end: number;
-  hasAnnotation: boolean;
-  lineIndex: number;
-  chunkIndex: number;
-};
-
 type ApiResponse<T> = {
   code?: number;
   message?: string;
@@ -58,10 +50,11 @@ type EditorTaskPayload = {
 type EditorTaskResponse = {
   task?: EditorTaskPayload;
   segmented?: boolean;
-  segments?: SegmentInfo[];
+  totalSegments?: number;
   currentSegmentIndex?: number;
 };
 
+
 type EditorTaskListResponse = {
   content?: EditorTaskListItem[];
   totalElements?: number;
@@ -83,11 +76,16 @@ type ExportPayload = {
   requestId?: string | null;
 };
 
-type SwitchDecision = "save" | "discard" | "cancel";
-
 const LSF_IFRAME_SRC = "/lsf/lsf.html";
 const TASK_PAGE_START = 0;
 const TASK_PAGE_SIZE = 200;
+const NO_ANNOTATION_LABEL = "无标注";
+const NOT_APPLICABLE_LABEL = "不适用";
+const NO_ANNOTATION_CONFIRM_TITLE = "没有标注任何内容";
+const NO_ANNOTATION_CONFIRM_OK_TEXT = "设为无标注并保存";
+const NOT_APPLICABLE_CONFIRM_TEXT = "设为不适用并保存";
+const NO_ANNOTATION_CONFIRM_CANCEL_TEXT = "继续标注";
+const SAVE_AND_NEXT_LABEL = "保存并跳转到下一段/下一条";
 
 type NormalizedTaskList = {
   items: EditorTaskListItem[];
@@ -103,6 +101,17 @@ const resolveSegmentIndex = (value: unknown) => {
   return Number.isFinite(parsed) ? parsed : undefined;
 };
 
+const isSaveShortcut = (event: KeyboardEvent) => {
+  if (event.defaultPrevented || event.isComposing) return false;
+  const key = event.key;
+  const code = event.code;
+  const isS = key === "s" || key === "S" || code === "KeyS";
+  if (!isS) return false;
+  if (!(event.ctrlKey || event.metaKey)) return false;
+  if (event.shiftKey || event.altKey) return false;
+  return true;
+};
+
 const normalizePayload = (payload: unknown): ExportPayload | undefined => {
   if (!payload || typeof payload !== "object") return undefined;
   return payload as ExportPayload;
@@ -119,6 +128,30 @@ const resolvePayloadMessage = (payload: unknown) => {
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === "object" && !Array.isArray(value);
 
+const isAnnotationResultEmpty = (annotation?: Record<string, unknown>) => {
+  if (!annotation) return true;
+  if (!("result" in annotation)) return true;
+  const result = (annotation as { result?: unknown }).result;
+  if (!Array.isArray(result)) return false;
+  return result.length === 0;
+};
+
+const resolveTaskStatusMeta = (item: EditorTaskListItem) => {
+  if (!item.hasAnnotation) {
+    return { text: "未标注", type: "secondary" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.NO_ANNOTATION) {
+    return { text: NO_ANNOTATION_LABEL, type: "warning" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.NOT_APPLICABLE) {
+    return { text: NOT_APPLICABLE_LABEL, type: "warning" as const };
+  }
+  if (item.annotationStatus === AnnotationResultStatus.IN_PROGRESS) {
+    return { text: "标注中", type: "warning" as const };
+  }
+  return { text: "已标注", type: "success" as const };
+};
+
 const normalizeSnapshotValue = (value: unknown, seen: WeakSet<object>): unknown => {
   if (!value || typeof value !== "object") return value;
   const obj = value as object;
@@ -144,6 +177,7 @@ const stableStringify = (value: unknown) => {
 
 const buildAnnotationSnapshot = (annotation?: Record<string, unknown>) => {
   if (!annotation) return "";
+  if (isAnnotationResultEmpty(annotation)) return "";
   const cleaned: Record<string, unknown> = { ...annotation };
   delete cleaned.updated_at;
   delete cleaned.updatedAt;
@@ -202,7 +236,6 @@ export default function LabelStudioTextEditor() {
     resolve: (payload?: ExportPayload) => void;
     timer?: number;
   } | null>(null);
-  const exportCheckSeqRef = useRef(0);
   const savedSnapshotsRef = useRef<Record<string, string>>({});
   const pendingAutoAdvanceRef = useRef(false);
 
@@ -210,7 +243,6 @@ export default function LabelStudioTextEditor() {
   const [loadingTasks, setLoadingTasks] = useState(false);
   const [loadingTaskDetail, setLoadingTaskDetail] = useState(false);
   const [saving, setSaving] = useState(false);
-  const [segmentSwitching, setSegmentSwitching] = useState(false);
 
   const [iframeReady, setIframeReady] = useState(false);
   const [lsReady, setLsReady] = useState(false);
@@ -223,12 +255,11 @@ export default function LabelStudioTextEditor() {
   const [prefetching, setPrefetching] = useState(false);
   const [selectedFileId, setSelectedFileId] = useState<string>("");
   const [sidebarCollapsed, setSidebarCollapsed] = useState(false);
-  const [autoSaveOnSwitch, setAutoSaveOnSwitch] = useState(false);
 
   // 分段相关状态
   const [segmented, setSegmented] = useState(false);
-  const [segments, setSegments] = useState<SegmentInfo[]>([]);
   const [currentSegmentIndex, setCurrentSegmentIndex] = useState(0);
+  const [segmentTotal, setSegmentTotal] = useState(0);
   const isTextProject = useMemo(
     () => (project?.datasetType || "").toUpperCase() === "TEXT",
     [project?.datasetType],
@@ -247,6 +278,36 @@ export default function LabelStudioTextEditor() {
     win.postMessage({ type, payload }, origin);
   }, [origin]);
 
+  const confirmEmptyAnnotationStatus = useCallback(() => {
+    return new Promise<AnnotationResultStatus | null>((resolve) => {
+      let resolved = false;
+      let modalInstance: { destroy: () => void } | null = null;
+      const settle = (value: AnnotationResultStatus | null) => {
+        if (resolved) return;
+        resolved = true;
+        resolve(value);
+        if (modalInstance) modalInstance.destroy();
+      };
+      const handleNotApplicable = () => settle(AnnotationResultStatus.NOT_APPLICABLE);
+      modalInstance = modal.confirm({
+        title: NO_ANNOTATION_CONFIRM_TITLE,
+        content: (
+          <div className="flex flex-col gap-2">
+            <Typography.Text>当前未发现任何标注内容。</Typography.Text>
+            <Typography.Text type="secondary">如确认为无标注或不适用，可继续保存。</Typography.Text>
+            <Button type="link" style={{ padding: 0, height: "auto" }} onClick={handleNotApplicable}>
+              {NOT_APPLICABLE_CONFIRM_TEXT}
+            </Button>
+          </div>
+        ),
+        okText: NO_ANNOTATION_CONFIRM_OK_TEXT,
+        cancelText: NO_ANNOTATION_CONFIRM_CANCEL_TEXT,
+        onOk: () => settle(AnnotationResultStatus.NO_ANNOTATION),
+        onCancel: () => settle(null),
+      });
+    });
+  }, [modal]);
+
   const loadProject = useCallback(async () => {
     setLoadingProject(true);
     try {
@@ -268,8 +329,11 @@ export default function LabelStudioTextEditor() {
   }, [message, projectId]);
 
   const updateTaskSelection = useCallback((items: EditorTaskListItem[]) => {
+    const isCompleted = (item: EditorTaskListItem) => {
+      return item.hasAnnotation;
+    };
     const defaultFileId =
-      items.find((item) => !item.hasAnnotation)?.fileId || items[0]?.fileId || "";
+      items.find((item) => !isCompleted(item))?.fileId || items[0]?.fileId || "";
     setSelectedFileId((prev) => {
       if (prev && items.some((item) => item.fileId === prev)) return prev;
       return defaultFileId;
@@ -406,17 +470,19 @@ export default function LabelStudioTextEditor() {
       if (seq !== initSeqRef.current) return;
 
       // 更新分段状态
-      const segmentIndex = data?.segmented
+      const isSegmented = !!data?.segmented;
+      const segmentIndex = isSegmented
         ? resolveSegmentIndex(data.currentSegmentIndex) ?? 0
         : undefined;
-      if (data?.segmented) {
+      if (isSegmented) {
         setSegmented(true);
-        setSegments(data.segments || []);
         setCurrentSegmentIndex(segmentIndex ?? 0);
+        const totalSegments = Number(data?.totalSegments ?? 0);
+        setSegmentTotal(Number.isFinite(totalSegments) && totalSegments > 0 ? totalSegments : 0);
       } else {
         setSegmented(false);
-        setSegments([]);
         setCurrentSegmentIndex(0);
+        setSegmentTotal(0);
       }
 
       const taskData = {
@@ -480,15 +546,10 @@ export default function LabelStudioTextEditor() {
 
   const advanceAfterSave = useCallback(async (fileId: string, segmentIndex?: number) => {
     if (!fileId) return;
-    if (segmented && segments.length > 0) {
+    if (segmented && segmentTotal > 0) {
-      const sortedSegmentIndices = segments
+      const baseIndex = Math.max(segmentIndex ?? currentSegmentIndex, 0);
-        .map((seg) => seg.idx)
+      const nextSegmentIndex = baseIndex + 1;
-        .sort((a, b) => a - b);
+      if (nextSegmentIndex < segmentTotal) {
-      const baseIndex = segmentIndex ?? currentSegmentIndex;
-      const currentPos = sortedSegmentIndices.indexOf(baseIndex);
-      const nextSegmentIndex =
-        currentPos >= 0 ? sortedSegmentIndices[currentPos + 1] : sortedSegmentIndices[0];
-      if (nextSegmentIndex !== undefined) {
         await initEditorForFile(fileId, nextSegmentIndex);
         return;
       }
@@ -510,7 +571,7 @@ export default function LabelStudioTextEditor() {
     initEditorForFile,
     message,
     segmented,
-    segments,
+    segmentTotal,
     tasks,
   ]);
 
@@ -539,11 +600,31 @@ export default function LabelStudioTextEditor() {
           ? currentSegmentIndex
           : undefined;
 
+    const annotationRecord = annotation as Record<string, unknown>;
+    const currentTask = tasks.find((item) => item.fileId === String(fileId));
+    const currentStatus = currentTask?.annotationStatus;
+    let resolvedStatus: AnnotationResultStatus;
+    if (isAnnotationResultEmpty(annotationRecord)) {
+      if (
+        currentStatus === AnnotationResultStatus.NO_ANNOTATION ||
+        currentStatus === AnnotationResultStatus.NOT_APPLICABLE
+      ) {
+        resolvedStatus = currentStatus;
+      } else {
+        const selectedStatus = await confirmEmptyAnnotationStatus();
+        if (!selectedStatus) return false;
+        resolvedStatus = selectedStatus;
+      }
+    } else {
+      resolvedStatus = AnnotationResultStatus.ANNOTATED;
+    }
+
     setSaving(true);
     try {
       const resp = (await upsertEditorAnnotationUsingPut(projectId, String(fileId), {
         annotation,
         segmentIndex,
+        annotationStatus: resolvedStatus,
       })) as ApiResponse<UpsertAnnotationResponse>;
       const updatedAt = resp?.data?.updatedAt;
       message.success("标注已保存");
@@ -553,6 +634,7 @@ export default function LabelStudioTextEditor() {
             ? {
                 ...item,
                 hasAnnotation: true,
+                annotationStatus: resolvedStatus,
                 annotationUpdatedAt: updatedAt || item.annotationUpdatedAt,
               }
             : item
@@ -563,16 +645,6 @@ export default function LabelStudioTextEditor() {
       const snapshot = buildAnnotationSnapshot(isRecord(annotation) ? annotation : undefined);
       savedSnapshotsRef.current[snapshotKey] = snapshot;
 
-      // 分段模式下更新当前段落的标注状态
-      if (segmented && segmentIndex !== undefined) {
-        setSegments((prev) =>
-          prev.map((seg) =>
-            seg.idx === segmentIndex
-              ? { ...seg, hasAnnotation: true }
-              : seg
-          )
-        );
-      }
       if (options?.autoAdvance) {
         await advanceAfterSave(String(fileId), segmentIndex);
       }
@@ -586,154 +658,36 @@ export default function LabelStudioTextEditor() {
     }
   }, [
     advanceAfterSave,
+    confirmEmptyAnnotationStatus,
     currentSegmentIndex,
     message,
     projectId,
     segmented,
     selectedFileId,
+    tasks,
   ]);
 
-  const requestExportForCheck = useCallback(() => {
+  const requestExport = useCallback((autoAdvance: boolean) => {
-    if (!iframeReady || !lsReady) return Promise.resolve(undefined);
-    if (exportCheckRef.current) {
-      if (exportCheckRef.current.timer) {
-        window.clearTimeout(exportCheckRef.current.timer);
-      }
-      exportCheckRef.current.resolve(undefined);
-      exportCheckRef.current = null;
-    }
-    const requestId = `check_${Date.now()}_${++exportCheckSeqRef.current}`;
-    return new Promise<ExportPayload | undefined>((resolve) => {
-      const timer = window.setTimeout(() => {
-        if (exportCheckRef.current?.requestId === requestId) {
-          exportCheckRef.current = null;
-        }
-        resolve(undefined);
-      }, 3000);
-      exportCheckRef.current = {
-        requestId,
-        resolve,
-        timer,
-      };
-      postToIframe("LS_EXPORT_CHECK", { requestId });
-    });
-  }, [iframeReady, lsReady, postToIframe]);
-
-  const confirmSaveBeforeSwitch = useCallback(() => {
-    return new Promise<SwitchDecision>((resolve) => {
-      let resolved = false;
-      let modalInstance: { destroy: () => void } | null = null;
-      const settle = (decision: SwitchDecision) => {
-        if (resolved) return;
-        resolved = true;
-        resolve(decision);
-      };
-      const handleDiscard = () => {
-        if (modalInstance) modalInstance.destroy();
-        settle("discard");
-      };
-      modalInstance = modal.confirm({
-        title: "当前段落有未保存标注",
-        content: (
-          <div className="flex flex-col gap-2">
-            <Typography.Text>切换段落前请先保存当前标注。</Typography.Text>
-            <Button type="link" danger style={{ padding: 0, height: "auto" }} onClick={handleDiscard}>
-              放弃未保存并切换
-            </Button>
-          </div>
-        ),
-        okText: "保存并切换",
-        cancelText: "取消",
-        onOk: () => settle("save"),
-        onCancel: () => settle("cancel"),
-      });
-    });
-  }, [modal]);
-
-  const requestExport = () => {
     if (!selectedFileId) {
       message.warning("请先选择文件");
       return;
     }
-    pendingAutoAdvanceRef.current = true;
+    pendingAutoAdvanceRef.current = autoAdvance;
     postToIframe("LS_EXPORT", {});
-  };
+  }, [message, postToIframe, selectedFileId]);
 
-  // 段落切换处理
+  useEffect(() => {
-  const handleSegmentChange = useCallback(async (newIndex: number) => {
+    const handleSaveShortcut = (event: KeyboardEvent) => {
-    if (newIndex === currentSegmentIndex) return;
+      if (!isSaveShortcut(event) || event.repeat) return;
-    if (segmentSwitching || saving || loadingTaskDetail) return;
+      if (saving || loadingTaskDetail) return;
-    if (!iframeReady || !lsReady) {
+      if (!iframeReady || !lsReady) return;
-      message.warning("编辑器未就绪，无法切换段落");
+      event.preventDefault();
-      return;
+      event.stopPropagation();
-    }
+      requestExport(false);
-
+    };
-    setSegmentSwitching(true);
+    window.addEventListener("keydown", handleSaveShortcut);
-    try {
+    return () => window.removeEventListener("keydown", handleSaveShortcut);
-      const payload = await requestExportForCheck();
+  }, [iframeReady, loadingTaskDetail, lsReady, requestExport, saving]);
-      if (!payload) {
-        message.warning("无法读取当前标注，已取消切换");
-        return;
-      }
-
-      const payloadTaskId = payload.taskId;
-      if (expectedTaskIdRef.current && payloadTaskId) {
-        if (Number(payloadTaskId) !== expectedTaskIdRef.current) {
-          message.warning("已忽略过期的标注数据");
-          return;
-        }
-      }
-
-      const payloadFileId = payload.fileId || selectedFileId;
-      const payloadSegmentIndex = resolveSegmentIndex(payload.segmentIndex);
-      const resolvedSegmentIndex =
-        payloadSegmentIndex !== undefined
-          ? payloadSegmentIndex
-          : segmented
-            ? currentSegmentIndex
-            : undefined;
-      const annotation = isRecord(payload.annotation) ? payload.annotation : undefined;
-      const snapshotKey = payloadFileId
-        ? buildSnapshotKey(String(payloadFileId), resolvedSegmentIndex)
-        : undefined;
-      const latestSnapshot = buildAnnotationSnapshot(annotation);
-      const lastSnapshot = snapshotKey ? savedSnapshotsRef.current[snapshotKey] : undefined;
-      const hasUnsavedChange = snapshotKey !== undefined && lastSnapshot !== undefined && latestSnapshot !== lastSnapshot;
-
-      if (hasUnsavedChange) {
-        if (autoSaveOnSwitch) {
-          const saved = await saveFromExport(payload);
-          if (!saved) return;
-        } else {
-          const decision = await confirmSaveBeforeSwitch();
-          if (decision === "cancel") return;
-          if (decision === "save") {
-            const saved = await saveFromExport(payload);
-            if (!saved) return;
-          }
-        }
-      }
-
-      await initEditorForFile(selectedFileId, newIndex);
-    } finally {
-      setSegmentSwitching(false);
-    }
-  }, [
-    autoSaveOnSwitch,
-    confirmSaveBeforeSwitch,
-    currentSegmentIndex,
-    iframeReady,
-    initEditorForFile,
-    loadingTaskDetail,
-    lsReady,
-    message,
-    requestExportForCheck,
-    saveFromExport,
-    segmented,
-    selectedFileId,
-    segmentSwitching,
-    saving,
-  ]);
 
   useEffect(() => {
     setIframeReady(false);
@@ -751,8 +705,8 @@ export default function LabelStudioTextEditor() {
     expectedTaskIdRef.current = null;
     // 重置分段状态
     setSegmented(false);
-    setSegments([]);
     setCurrentSegmentIndex(0);
+    setSegmentTotal(0);
     savedSnapshotsRef.current = {};
     if (exportCheckRef.current?.timer) {
       window.clearTimeout(exportCheckRef.current.timer);
@@ -791,51 +745,6 @@ export default function LabelStudioTextEditor() {
     return () => window.removeEventListener("focus", handleWindowFocus);
   }, [focusIframe, lsReady]);
 
-  const segmentTreeData = useMemo(() => {
-    if (!segmented || segments.length === 0) return [];
-    const lineMap = new Map<number, SegmentInfo[]>();
-    segments.forEach((seg) => {
-      const list = lineMap.get(seg.lineIndex) || [];
-      list.push(seg);
-      lineMap.set(seg.lineIndex, list);
-    });
-    return Array.from(lineMap.entries())
-      .sort((a, b) => a[0] - b[0])
-      .map(([lineIndex, lineSegments]) => ({
-        key: `line-${lineIndex}`,
-        title: `第${lineIndex + 1}行`,
-        selectable: false,
-        children: lineSegments
-          .sort((a, b) => a.chunkIndex - b.chunkIndex)
-          .map((seg) => ({
-            key: `seg-${seg.idx}`,
-            title: (
-              <span className="flex items-center gap-1">
-                <span>{`片${seg.chunkIndex + 1}`}</span>
-                {seg.hasAnnotation && (
-                  <CheckOutlined style={{ fontSize: 10, color: "#52c41a" }} />
-                )}
-              </span>
-            ),
-          })),
-      }));
-  }, [segmented, segments]);
-
-  const segmentLineKeys = useMemo(
-    () => segmentTreeData.map((item) => String(item.key)),
-    [segmentTreeData]
-  );
-
-  const handleSegmentSelect = useCallback((keys: Array<string | number>) => {
-    const [first] = keys;
-    if (first === undefined || first === null) return;
-    const key = String(first);
-    if (!key.startsWith("seg-")) return;
-    const nextIndex = Number(key.replace("seg-", ""));
-    if (!Number.isFinite(nextIndex)) return;
-    handleSegmentChange(nextIndex);
-  }, [handleSegmentChange]);
-
   useEffect(() => {
     const handler = (event: MessageEvent<LsfMessage>) => {
       if (event.origin !== origin) return;
@@ -865,6 +774,12 @@ export default function LabelStudioTextEditor() {
         return;
       }
 
+      if (msg.type === "LS_SAVE_AND_NEXT") {
+        pendingAutoAdvanceRef.current = false;
+        saveFromExport(payload, { autoAdvance: true });
+        return;
+      }
+
       if (msg.type === "LS_EXPORT_CHECK_RESULT") {
         const pending = exportCheckRef.current;
         if (!pending) return;
@@ -897,6 +812,8 @@ export default function LabelStudioTextEditor() {
   }, [message, origin, saveFromExport]);
 
   const canLoadMore = taskTotalPages > 0 && taskPage + 1 < taskTotalPages;
+  const saveDisabled =
+    !iframeReady || !selectedFileId || saving || loadingTaskDetail;
   const loadMoreNode = canLoadMore ? (
     <div className="p-2 text-center">
       <Button
@@ -960,7 +877,7 @@ export default function LabelStudioTextEditor() {
   return (
     <div className="h-full flex flex-col">
       {/* 顶部工具栏 */}
-      <div className="flex items-center justify-between px-3 py-2 border-b border-gray-200 bg-white">
+      <div className="grid grid-cols-[1fr_auto_1fr] items-center px-3 py-2 border-b border-gray-200 bg-white">
         <div className="flex items-center gap-2">
           <Button icon={<LeftOutlined />} onClick={() => navigate("/data/annotation")}>
             返回
@@ -974,7 +891,18 @@ export default function LabelStudioTextEditor() {
             标注编辑器
           </Typography.Title>
         </div>
-        <div className="flex items-center gap-2">
+        <div className="flex items-center justify-center">
+          <Button
+            type="primary"
+            icon={<SaveOutlined />}
+            loading={saving}
+            disabled={saveDisabled}
+            onClick={() => requestExport(true)}
+          >
+            {SAVE_AND_NEXT_LABEL}
+          </Button>
+        </div>
+        <div className="flex items-center gap-2 justify-end">
           <Button
             icon={<ReloadOutlined />}
             loading={loadingTasks}
@@ -983,11 +911,10 @@ export default function LabelStudioTextEditor() {
             刷新
           </Button>
           <Button
-            type="primary"
             icon={<SaveOutlined />}
             loading={saving}
-            disabled={!iframeReady || !selectedFileId}
+            disabled={saveDisabled}
-            onClick={requestExport}
+            onClick={() => requestExport(false)}
           >
             保存
           </Button>
@@ -1001,8 +928,8 @@ export default function LabelStudioTextEditor() {
           className="border-r border-gray-200 bg-gray-50 flex flex-col transition-all duration-200 min-h-0"
           style={{ width: sidebarCollapsed ? 0 : 240, overflow: "hidden" }}
         >
-          <div className="px-3 py-2 border-b border-gray-200 bg-white font-medium text-sm">
+          <div className="px-3 py-2 border-b border-gray-200 bg-white font-medium text-sm flex items-center justify-between gap-2">
-            文件列表
+            <span>文件列表</span>
           </div>
           <div className="flex-1 min-h-0 overflow-auto">
             <List
@@ -1010,37 +937,39 @@ export default function LabelStudioTextEditor() {
               size="small"
               dataSource={tasks}
               loadMore={loadMoreNode}
-              renderItem={(item) => (
+              renderItem={(item) => {
-                <List.Item
+                const statusMeta = resolveTaskStatusMeta(item);
-                  key={item.fileId}
+                return (
-                  className="cursor-pointer hover:bg-blue-50"
+                  <List.Item
-                  style={{
+                    key={item.fileId}
-                    background: item.fileId === selectedFileId ? "#e6f4ff" : undefined,
+                    className="cursor-pointer hover:bg-blue-50"
-                    padding: "8px 12px",
+                    style={{
-                    borderBottom: "1px solid #f0f0f0",
+                      background: item.fileId === selectedFileId ? "#e6f4ff" : undefined,
-                  }}
+                      padding: "8px 12px",
-                  onClick={() => setSelectedFileId(item.fileId)}
+                      borderBottom: "1px solid #f0f0f0",
-                >
+                    }}
-                  <div className="flex flex-col w-full gap-1">
+                    onClick={() => setSelectedFileId(item.fileId)}
-                    <Typography.Text ellipsis style={{ fontSize: 13 }}>
+                  >
-                      {item.fileName}
+                    <div className="flex flex-col w-full gap-1">
-                    </Typography.Text>
+                        <Typography.Text ellipsis style={{ fontSize: 13 }}>
-                    <div className="flex items-center justify-between">
+                          {item.fileName}
-                      <Typography.Text
-                        type={item.hasAnnotation ? "success" : "secondary"}
-                        style={{ fontSize: 11 }}
-                      >
-                        {item.hasAnnotation ? "已标注" : "未标注"}
-                      </Typography.Text>
-                      {item.annotationUpdatedAt && (
-                        <Typography.Text type="secondary" style={{ fontSize: 10 }}>
-                          {item.annotationUpdatedAt}
                         </Typography.Text>
-                      )}
+                        <div className="flex items-center justify-between">
+                          <div className="flex items-center gap-2">
+                            <Typography.Text type={statusMeta.type} style={{ fontSize: 11 }}>
+                              {statusMeta.text}
+                            </Typography.Text>
+                          </div>
+                          {item.annotationUpdatedAt && (
+                            <Typography.Text type="secondary" style={{ fontSize: 10 }}>
+                              {item.annotationUpdatedAt}
+                            </Typography.Text>
+                          )}
+                      </div>
                     </div>
-                  </div>
+                  </List.Item>
-                </List.Item>
+                );
-              )}
+              }}
             />
           </div>
           {segmented && (
@@ -1048,21 +977,16 @@ export default function LabelStudioTextEditor() {
               <div className="px-3 py-2 border-b border-gray-200 bg-gray-50 font-medium text-sm flex items-center justify-between">
                 <span>段落/分段</span>
                 <Tag color="blue" style={{ margin: 0 }}>
-                  {currentSegmentIndex + 1} / {segments.length}
+                  {segmentTotal > 0 ? currentSegmentIndex + 1 : 0} / {segmentTotal}
                 </Tag>
               </div>
               <div className="flex-1 min-h-0 overflow-auto px-2 py-2">
-                {segments.length > 0 ? (
+                {segmentTotal > 0 ? (
-                  <Tree
+                  <div className="py-6">
-                    showLine
+                    <Typography.Text type="secondary" style={{ fontSize: 12 }}>
-                    blockNode
+                      分段列表已关闭，请使用“保存并跳转到下一段/下一条”顺序标注。
-                    selectedKeys={
+                    </Typography.Text>
-                      segmented ? [`seg-${currentSegmentIndex}`] : []
+                  </div>
-                    }
-                    expandedKeys={segmentLineKeys}
-                    onSelect={handleSegmentSelect}
-                    treeData={segmentTreeData}
-                  />
                 ) : (
                   <div className="py-6">
                     <Empty
@@ -1072,17 +996,6 @@ export default function LabelStudioTextEditor() {
                   </div>
                 )}
               </div>
-              <div className="px-3 py-2 border-t border-gray-200 flex items-center justify-between">
-                <Typography.Text style={{ fontSize: 12 }}>
-                  切段自动保存
-                </Typography.Text>
-                <Switch
-                  size="small"
-                  checked={autoSaveOnSwitch}
-                  onChange={(checked) => setAutoSaveOnSwitch(checked)}
-                  disabled={segmentSwitching || saving || loadingTaskDetail || !lsReady}
-                />
-              </div>
             </div>
           )}
         </div>

frontend/src/pages/DataAnnotation/Create/components/CreateAnnotationTaskDialog.tsx

@@ -19,7 +19,8 @@ import {
   queryAnnotationTemplatesUsingGet,
 } from "../../annotation.api";
 import { DatasetType, type Dataset } from "@/pages/DataManagement/dataset.model";
-import { DataType, type AnnotationTemplate, type AnnotationTask } from "../../annotation.model";
+import { DataType, type AnnotationTemplate } from "../../annotation.model";
+import type { AnnotationTaskListItem } from "../../annotation.const";
 import LabelStudioEmbed from "@/components/business/LabelStudioEmbed";
 import TemplateConfigurationTreeEditor from "../../components/TemplateConfigurationTreeEditor";
 import { useTagConfig } from "@/hooks/useTagConfig";
@@ -29,7 +30,7 @@ interface AnnotationTaskDialogProps {
   onClose: () => void;
   onRefresh: () => void;
   /** 编辑模式：传入要编辑的任务数据 */
-  editTask?: AnnotationTask | null;
+  editTask?: AnnotationTaskListItem | null;
 }
 
 type DatasetOption = Dataset & { icon?: ReactNode };
@@ -60,6 +61,7 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 
 const DEFAULT_SEGMENTATION_ENABLED = true;
 const FILE_PREVIEW_MAX_HEIGHT = 500;
+const PREVIEW_MODAL_WIDTH = "80vw";
 const SEGMENTATION_OPTIONS = [
   { label: "需要切片段", value: true },
   { label: "不需要切片段", value: false },
@@ -282,7 +284,7 @@ export default function CreateAnnotationTask({
     }
     setDatasetPreviewLoading(true);
     try {
-      // 对于文本数据集，排除已被转换为TXT的源文档文件（PDF/DOC/DOCX）
+      // 对于文本数据集，排除源文档文件（PDF/DOC/DOCX/XLS/XLSX）
       const params: { page: number; size: number; excludeSourceDocuments?: boolean } = { page: 0, size: 10 };
       if (isTextDataset) {
         params.excludeSourceDocuments = true;
@@ -828,7 +830,7 @@ export default function CreateAnnotationTask({
         open={showPreview}
         onCancel={() => setShowPreview(false)}
         title="标注界面预览"
-        width={1000}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => setShowPreview(false)}>
             关闭
@@ -853,7 +855,7 @@ export default function CreateAnnotationTask({
         open={datasetPreviewVisible}
         onCancel={() => setDatasetPreviewVisible(false)}
         title="数据集预览（前10条文件）"
-        width={700}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => setDatasetPreviewVisible(false)}>
             关闭
@@ -910,7 +912,7 @@ export default function CreateAnnotationTask({
           setFileContent("");
         }}
         title={`文件预览：${previewFileName}`}
-        width={previewFileType === "text" ? 800 : 700}
+        width={PREVIEW_MODAL_WIDTH}
         footer={[
           <Button key="close" onClick={() => {
             setFileContentVisible(false);

frontend/src/pages/DataAnnotation/Home/DataAnnotation.tsx

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { Card, Button, Table, message, Modal, Tabs } from "antd";
+import { Card, Button, Table, Tag, message, Modal, Tabs } from "antd";
 import {
   PlusOutlined,
   EditOutlined,
@@ -10,27 +10,39 @@ import {
 import { useNavigate } from "react-router";
 import { SearchControls } from "@/components/SearchControls";
 import CardView from "@/components/CardView";
-import type { AnnotationTask } from "../annotation.model";
 import useFetchData from "@/hooks/useFetchData";
 import {
   deleteAnnotationTaskByIdUsingDelete,
   queryAnnotationTasksUsingGet,
 } from "../annotation.api";
-import { mapAnnotationTask } from "../annotation.const";
+import {
+  AnnotationTypeMap,
+  mapAnnotationTask,
+  type AnnotationTaskListItem,
+} from "../annotation.const";
 import CreateAnnotationTask from "../Create/components/CreateAnnotationTaskDialog";
 import ExportAnnotationDialog from "./ExportAnnotationDialog";
 import { ColumnType } from "antd/es/table";
 import { TemplateList } from "../Template";
 // Note: DevelopmentInProgress intentionally not used here
 
+type AnnotationTaskRowKey = string | number;
+type AnnotationTaskOperation = {
+  key: string;
+  label: string;
+  icon: JSX.Element;
+  danger?: boolean;
+  onClick: (task: AnnotationTaskListItem) => void;
+};
+
 export default function DataAnnotation() {
   // return <DevelopmentInProgress showTime="2025.10.30" />;
   const navigate = useNavigate();
   const [activeTab, setActiveTab] = useState("tasks");
   const [viewMode, setViewMode] = useState<"list" | "card">("list");
   const [showCreateDialog, setShowCreateDialog] = useState(false);
-  const [exportTask, setExportTask] = useState<AnnotationTask | null>(null);
+  const [exportTask, setExportTask] = useState<AnnotationTaskListItem | null>(null);
-  const [editTask, setEditTask] = useState<AnnotationTask | null>(null);
+  const [editTask, setEditTask] = useState<AnnotationTaskListItem | null>(null);
 
   const {
     loading,
@@ -40,13 +52,16 @@ export default function DataAnnotation() {
     fetchData,
     handleFiltersChange,
     handleKeywordChange,
-  } = useFetchData(queryAnnotationTasksUsingGet, mapAnnotationTask, 30000, true, [], 0);
+  } = useFetchData<AnnotationTaskListItem>(queryAnnotationTasksUsingGet, mapAnnotationTask, 30000, true, [], 0);
 
-  const [selectedRowKeys, setSelectedRowKeys] = useState<(string | number)[]>([]);
+  const [selectedRowKeys, setSelectedRowKeys] = useState<AnnotationTaskRowKey[]>([]);
-  const [selectedRows, setSelectedRows] = useState<any[]>([]);
+  const [selectedRows, setSelectedRows] = useState<AnnotationTaskListItem[]>([]);
 
-  const handleAnnotate = (task: AnnotationTask) => {
+  const toSafeCount = (value: unknown) =>
-    const projectId = (task as any)?.id;
+    typeof value === "number" && Number.isFinite(value) ? value : 0;
+
+  const handleAnnotate = (task: AnnotationTaskListItem) => {
+    const projectId = task.id;
     if (!projectId) {
       message.error("无法进入标注：缺少标注项目ID");
       return;
@@ -54,15 +69,15 @@ export default function DataAnnotation() {
     navigate(`/data/annotation/annotate/${projectId}`);
   };
 
-  const handleExport = (task: AnnotationTask) => {
+  const handleExport = (task: AnnotationTaskListItem) => {
     setExportTask(task);
   };
 
-  const handleEdit = (task: AnnotationTask) => {
+  const handleEdit = (task: AnnotationTaskListItem) => {
     setEditTask(task);
   };
 
-  const handleDelete = (task: AnnotationTask) => {
+  const handleDelete = (task: AnnotationTaskListItem) => {
     Modal.confirm({
       title: `确认删除标注任务「${task.name}」吗？`,
       content: "删除标注任务不会删除对应数据集，但会删除该任务的所有标注结果。",
@@ -110,7 +125,7 @@ export default function DataAnnotation() {
     });
   };
 
-  const operations = [
+  const operations: AnnotationTaskOperation[] = [
     {
       key: "annotate",
       label: "标注",
@@ -142,24 +157,45 @@ export default function DataAnnotation() {
     },
   ];
 
-  const columns: ColumnType<any>[] = [
+  const columns: ColumnType<AnnotationTaskListItem>[] = [
+    {
+      title: "序号",
+      key: "index",
+      width: 80,
+      align: "center" as const,
+      render: (_value: unknown, _record: AnnotationTaskListItem, index: number) => {
+        const current = pagination.current ?? 1;
+        const pageSize = pagination.pageSize ?? tableData.length ?? 0;
+        return (current - 1) * pageSize + index + 1;
+      },
+    },
     {
       title: "任务名称",
       dataIndex: "name",
       key: "name",
       fixed: "left" as const,
     },
-    {
-      title: "任务ID",
-      dataIndex: "id",
-      key: "id",
-    },
     {
       title: "数据集",
       dataIndex: "datasetName",
       key: "datasetName",
       width: 180,
     },
+    {
+      title: "标注类型",
+      dataIndex: "labelingType",
+      key: "labelingType",
+      width: 160,
+      render: (value?: string) => {
+        if (!value) {
+          return "-";
+        }
+        const label =
+          AnnotationTypeMap[value as keyof typeof AnnotationTypeMap]?.label ||
+          value;
+        return <Tag color="geekblue">{label}</Tag>;
+      },
+    },
     {
       title: "数据量",
       dataIndex: "totalCount",
@@ -173,9 +209,21 @@ export default function DataAnnotation() {
       key: "annotatedCount",
       width: 100,
       align: "center" as const,
-      render: (value: number, record: any) => {
+      render: (value: number, record: AnnotationTaskListItem) => {
-        const total = record.totalCount || 0;
+        const total = toSafeCount(record.totalCount ?? record.total_count);
-        const annotated = value || 0;
+        const annotatedRaw = toSafeCount(
+          value ?? record.annotatedCount ?? record.annotated_count
+        );
+        const segmentationEnabled =
+          record.segmentationEnabled ?? record.segmentation_enabled;
+        const inProgressRaw = segmentationEnabled
+          ? toSafeCount(record.inProgressCount ?? record.in_progress_count)
+          : 0;
+        const shouldExcludeInProgress =
+          total > 0 && annotatedRaw + inProgressRaw > total;
+        const annotated = shouldExcludeInProgress
+          ? Math.max(annotatedRaw - inProgressRaw, 0)
+          : annotatedRaw;
         const percent = total > 0 ? Math.round((annotated / total) * 100) : 0;
         return (
           <span title={`${annotated}/${total} (${percent}%)`}>
@@ -184,6 +232,23 @@ export default function DataAnnotation() {
         );
       },
     },
+    {
+      title: "标注中",
+      dataIndex: "inProgressCount",
+      key: "inProgressCount",
+      width: 100,
+      align: "center" as const,
+      render: (value: number, record: AnnotationTaskListItem) => {
+        const segmentationEnabled =
+          record.segmentationEnabled ?? record.segmentation_enabled;
+        if (!segmentationEnabled) return "-";
+        const resolved =
+          Number.isFinite(value)
+            ? value
+            : record.inProgressCount ?? record.in_progress_count ?? 0;
+        return resolved;
+      },
+    },
     {
       title: "创建时间",
       dataIndex: "createdAt",
@@ -202,14 +267,14 @@ export default function DataAnnotation() {
       fixed: "right" as const,
       width: 150,
       dataIndex: "actions",
-      render: (_: any, task: any) => (
+      render: (_value: unknown, task: AnnotationTaskListItem) => (
         <div className="flex items-center justify-center space-x-1">
           {operations.map((operation) => (
             <Button
               key={operation.key}
               type="text"
               icon={operation.icon}
-              onClick={() => (operation?.onClick as any)?.(task)}
+              onClick={() => operation.onClick(task)}
               title={operation.label}
             />
           ))}
@@ -282,9 +347,9 @@ export default function DataAnnotation() {
                       pagination={pagination}
                       rowSelection={{
                         selectedRowKeys,
-                        onChange: (keys, rows) => {
+                        onChange: (keys: AnnotationTaskRowKey[], rows: AnnotationTaskListItem[]) => {
-                          setSelectedRowKeys(keys as (string | number)[]);
+                          setSelectedRowKeys(keys);
-                          setSelectedRows(rows as any[]);
+                          setSelectedRows(rows);
                         },
                       }}
                       scroll={{ x: "max-content", y: "calc(100vh - 24rem)" }}
@@ -293,7 +358,7 @@ export default function DataAnnotation() {
                 ) : (
                   <CardView
                     data={tableData}
-                    operations={operations as any}
+                    operations={operations}
                     pagination={pagination}
                     loading={loading}
                   />

frontend/src/pages/DataAnnotation/Home/ExportAnnotationDialog.tsx

@@ -178,14 +178,15 @@ export default function ExportAnnotationDialog({
             <Select
               options={FORMAT_OPTIONS.map((opt) => ({
                 label: (
-                  <div>
+                  <div className="py-1">
                     <div className="font-medium">{opt.label}</div>
                     <div className="text-xs text-gray-400">{opt.description}</div>
                   </div>
                 ),
                 value: opt.value,
+                simpleLabel: opt.label,
               }))}
-              optionLabelProp="label"
+              optionLabelProp="simpleLabel"
             />
           </Form.Item>
 

frontend/src/pages/DataAnnotation/Template/TemplateDetail.tsx

@@ -43,14 +43,6 @@ const TemplateDetail: React.FC<TemplateDetailProps> = ({
                 <Descriptions.Item label="样式">
                     {template.style}
                 </Descriptions.Item>
-                <Descriptions.Item label="类型">
-                    <Tag color={template.builtIn ? "gold" : "default"}>
-                        {template.builtIn ? "系统内置" : "自定义"}
-                    </Tag>
-                </Descriptions.Item>
-                <Descriptions.Item label="版本">
-                    {template.version}
-                </Descriptions.Item>
                 <Descriptions.Item label="创建时间" span={2}>
                     {new Date(template.createdAt).toLocaleString()}
                 </Descriptions.Item>

frontend/src/pages/DataAnnotation/Template/TemplateForm.tsx

@@ -36,6 +36,7 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
     const [form] = Form.useForm();
     const [loading, setLoading] = useState(false);
     const [labelConfig, setLabelConfig] = useState("");
+    const selectedDataType = Form.useWatch("dataType", form);
 
     useEffect(() => {
         if (visible && template && mode === "edit") {
@@ -96,8 +97,12 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
             } else {
                 message.error(response.message || `模板${mode === "create" ? "创建" : "更新"}失败`);
             }
-        } catch (error: any) {
+        } catch (error: unknown) {
-            if (error.errorFields) {
+            const hasErrorFields =
+                typeof error === "object" &&
+                error !== null &&
+                "errorFields" in error;
+            if (hasErrorFields) {
                 message.error("请填写所有必填字段");
             } else {
                 message.error(`模板${mode === "create" ? "创建" : "更新"}失败`);
@@ -195,6 +200,7 @@ const TemplateForm: React.FC<TemplateFormProps> = ({
                         value={labelConfig}
                         onChange={setLabelConfig}
                         height={420}
+                        dataType={selectedDataType}
                     />
                 </div>
             </Form>

frontend/src/pages/DataAnnotation/Template/TemplateList.tsx

@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React, { useState, useEffect } from "react";
 import {
     Button,
     Table,
@@ -32,7 +32,16 @@ import {
   TemplateTypeMap
 } from "@/pages/DataAnnotation/annotation.const.tsx";
 
+const TEMPLATE_ADMIN_KEY = "datamate_template_admin";
+
 const TemplateList: React.FC = () => {
+    const [isAdmin, setIsAdmin] = useState(false);
+
+    useEffect(() => {
+        // 检查 localStorage 中是否存在特殊键
+        const hasAdminKey = localStorage.getItem(TEMPLATE_ADMIN_KEY) !== null;
+        setIsAdmin(hasAdminKey);
+    }, []);
     const filterOptions = [
       {
         key: "category",
@@ -225,23 +234,7 @@ const TemplateList: React.FC = () => {
                 <Tag color={getCategoryColor(category)}>{ClassificationMap[category as keyof typeof ClassificationMap]?.label || category}</Tag>
             ),
         },
-        {
+
-            title: "类型",
-            dataIndex: "builtIn",
-            key: "builtIn",
-            width: 100,
-            render: (builtIn: boolean) => (
-                <Tag color={builtIn ? "gold" : "default"}>
-                    {builtIn ? "系统内置" : "自定义"}
-                </Tag>
-            ),
-        },
-        {
-            title: "版本",
-            dataIndex: "version",
-            key: "version",
-            width: 80,
-        },
         {
             title: "创建时间",
             dataIndex: "createdAt",
@@ -263,29 +256,31 @@ const TemplateList: React.FC = () => {
                             onClick={() => handleView(record)}
                         />
                     </Tooltip>
-                    <>
+                    {isAdmin && (
-                        <Tooltip title="编辑">
+                        <>
-                            <Button
+                            <Tooltip title="编辑">
-                                type="link"
-                                icon={<EditOutlined />}
-                                onClick={() => handleEdit(record)}
-                            />
-                        </Tooltip>
-                        <Popconfirm
-                            title="确定要删除这个模板吗？"
-                            onConfirm={() => handleDelete(record.id)}
-                            okText="确定"
-                            cancelText="取消"
-                        >
-                            <Tooltip title="删除">
                                 <Button
                                     type="link"
-                                    danger
+                                    icon={<EditOutlined />}
-                                    icon={<DeleteOutlined />}
+                                    onClick={() => handleEdit(record)}
                                 />
                             </Tooltip>
-                        </Popconfirm>
+                            <Popconfirm
-                    </>
+                                title="确定要删除这个模板吗？"
+                                onConfirm={() => handleDelete(record.id)}
+                                okText="确定"
+                                cancelText="取消"
+                            >
+                                <Tooltip title="删除">
+                                    <Button
+                                        type="link"
+                                        danger
+                                        icon={<DeleteOutlined />}
+                                    />
+                                </Tooltip>
+                            </Popconfirm>
+                        </>
+                    )}
                 </Space>
             ),
         },
@@ -310,11 +305,13 @@ const TemplateList: React.FC = () => {
                 </div>
 
                 {/* Right side: Create button */}
-                <div className="flex items-center gap-2">
+                {isAdmin && (
-                    <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
+                    <div className="flex items-center gap-2">
-                        创建模板
+                        <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
-                    </Button>
+                            创建模板
-                </div>
+                        </Button>
+                    </div>
+                )}
             </div>
 
             <Card>

frontend/src/pages/DataAnnotation/Template/VisualTemplateBuilder.tsx

@@ -18,6 +18,7 @@ import {
 import { TagBrowser } from "./components";
 
 const { Paragraph } = Typography;
+const PREVIEW_DRAWER_WIDTH = "80vw";
 
 interface VisualTemplateBuilderProps {
     onSave?: (templateCode: string) => void;
@@ -129,7 +130,7 @@ const VisualTemplateBuilder: React.FC<VisualTemplateBuilderProps> = ({
             <Drawer
                 title="模板代码预览"
                 placement="right"
-                width={600}
+                width={PREVIEW_DRAWER_WIDTH}
                 open={previewVisible}
                 onClose={() => setPreviewVisible(false)}
             >

frontend/src/pages/DataAnnotation/annotation.api.ts

@@ -3,16 +3,19 @@ import { get, post, put, del, download } from "@/utils/request";
 // 导出格式类型
 export type ExportFormat = "json" | "jsonl" | "csv" | "coco" | "yolo";
 
+type RequestParams = Record<string, unknown>;
+type RequestPayload = Record<string, unknown>;
+
 // 标注任务管理相关接口
-export function queryAnnotationTasksUsingGet(params?: any) {
+export function queryAnnotationTasksUsingGet(params?: RequestParams) {
   return get("/api/annotation/project", params);
 }
 
-export function createAnnotationTaskUsingPost(data: any) {
+export function createAnnotationTaskUsingPost(data: RequestPayload) {
   return post("/api/annotation/project", data);
 }
 
-export function syncAnnotationTaskUsingPost(data: any) {
+export function syncAnnotationTaskUsingPost(data: RequestPayload) {
   return post(`/api/annotation/task/sync`, data);
 }
 
@@ -25,7 +28,7 @@ export function getAnnotationTaskByIdUsingGet(taskId: string) {
   return get(`/api/annotation/project/${taskId}`);
 }
 
-export function updateAnnotationTaskByIdUsingPut(taskId: string, data: any) {
+export function updateAnnotationTaskByIdUsingPut(taskId: string, data: RequestPayload) {
   return put(`/api/annotation/project/${taskId}`, data);
 }
 
@@ -35,17 +38,17 @@ export function getTagConfigUsingGet() {
 }
 
 // 标注模板管理
-export function queryAnnotationTemplatesUsingGet(params?: any) {
+export function queryAnnotationTemplatesUsingGet(params?: RequestParams) {
   return get("/api/annotation/template", params);
 }
 
-export function createAnnotationTemplateUsingPost(data: any) {
+export function createAnnotationTemplateUsingPost(data: RequestPayload) {
   return post("/api/annotation/template", data);
 }
 
 export function updateAnnotationTemplateByIdUsingPut(
   templateId: string | number,
-  data: any
+  data: RequestPayload
 ) {
   return put(`/api/annotation/template/${templateId}`, data);
 }
@@ -65,7 +68,7 @@ export function getEditorProjectInfoUsingGet(projectId: string) {
   return get(`/api/annotation/editor/projects/${projectId}`);
 }
 
-export function listEditorTasksUsingGet(projectId: string, params?: any) {
+export function listEditorTasksUsingGet(projectId: string, params?: RequestParams) {
   return get(`/api/annotation/editor/projects/${projectId}/tasks`, params);
 }
 
@@ -77,11 +80,19 @@ export function getEditorTaskUsingGet(
   return get(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}`, params);
 }
 
+export function getEditorTaskSegmentUsingGet(
+  projectId: string,
+  fileId: string,
+  params: { segmentIndex: number }
+) {
+  return get(`/api/annotation/editor/projects/${projectId}/tasks/${fileId}/segments`, params);
+}
+
 export function upsertEditorAnnotationUsingPut(
   projectId: string,
   fileId: string,
   data: {
-    annotation: any;
+    annotation: Record<string, unknown>;
     expectedUpdatedAt?: string;
     segmentIndex?: number;
   }

frontend/src/pages/DataAnnotation/annotation.const.tsx

@@ -6,6 +6,71 @@ import {
   CloseCircleOutlined,
 } from "@ant-design/icons";
 
+type AnnotationTaskStatistics = {
+  accuracy?: number | string;
+  averageTime?: number | string;
+  reviewCount?: number | string;
+};
+
+type AnnotationTaskPayload = {
+  id?: string;
+  labelingProjId?: string;
+  labelingProjectId?: string;
+  projId?: string;
+  labeling_project_id?: string;
+  name?: string;
+  description?: string;
+  datasetId?: string;
+  datasetName?: string;
+  dataset_name?: string;
+  labelingType?: string;
+  labeling_type?: string;
+  template?: {
+    labelingType?: string;
+    labeling_type?: string;
+  };
+  totalCount?: number;
+  total_count?: number;
+  annotatedCount?: number;
+  annotated_count?: number;
+  inProgressCount?: number;
+  in_progress_count?: number;
+  segmentationEnabled?: boolean;
+  segmentation_enabled?: boolean;
+  createdAt?: string;
+  created_at?: string;
+  updatedAt?: string;
+  updated_at?: string;
+  status?: string;
+  statistics?: AnnotationTaskStatistics;
+  [key: string]: unknown;
+};
+
+export type AnnotationTaskListItem = {
+  id?: string;
+  labelingProjId?: string;
+  projId?: string;
+  name?: string;
+  description?: string;
+  datasetId?: string;
+  datasetName?: string;
+  labelingType?: string;
+  totalCount?: number;
+  annotatedCount?: number;
+  inProgressCount?: number;
+  segmentationEnabled?: boolean;
+  createdAt?: string;
+  updatedAt?: string;
+  icon?: JSX.Element;
+  iconColor?: string;
+  status?: {
+    label: string;
+    color: string;
+  };
+  statistics?: { label: string; value: string | number }[];
+  [key: string]: unknown;
+};
+
 export const AnnotationTaskStatusMap = {
   [AnnotationTaskStatus.ACTIVE]: {
     label: "活跃",
@@ -27,9 +92,16 @@ export const AnnotationTaskStatusMap = {
   },
 };
 
-export function mapAnnotationTask(task: any) {
+export function mapAnnotationTask(task: AnnotationTaskPayload): AnnotationTaskListItem {
   // Normalize labeling project id from possible backend field names
   const labelingProjId = task?.labelingProjId || task?.labelingProjectId || task?.projId || task?.labeling_project_id || "";
+  const segmentationEnabled = task?.segmentationEnabled ?? task?.segmentation_enabled ?? false;
+  const inProgressCount = task?.inProgressCount ?? task?.in_progress_count ?? 0;
+  const labelingType =
+    task?.labelingType ||
+    task?.labeling_type ||
+    task?.template?.labelingType ||
+    task?.template?.labeling_type;
 
   const statsArray = task?.statistics
     ? [
@@ -45,6 +117,9 @@ export function mapAnnotationTask(task: any) {
     // provide consistent field for components
     labelingProjId,
     projId: labelingProjId,
+    segmentationEnabled,
+    inProgressCount,
+    labelingType,
     name: task.name,
     description: task.description || "",
     datasetName: task.datasetName || task.dataset_name || "-",

frontend/src/pages/DataAnnotation/annotation.model.ts

@@ -8,6 +8,13 @@ export enum AnnotationTaskStatus {
   SKIPPED = "skipped",
 }
 
+export enum AnnotationResultStatus {
+  ANNOTATED = "ANNOTATED",
+  IN_PROGRESS = "IN_PROGRESS",
+  NO_ANNOTATION = "NO_ANNOTATION",
+  NOT_APPLICABLE = "NOT_APPLICABLE",
+}
+
 export interface AnnotationTask {
   id: string;
   name: string;
@@ -52,7 +59,7 @@ export interface ObjectDefinition {
 export interface TemplateConfiguration {
   labels: LabelDefinition[];
   objects: ObjectDefinition[];
-  metadata?: Record<string, any>;
+  metadata?: Record<string, unknown>;
 }
 
 export interface AnnotationTemplate {

frontend/src/pages/DataAnnotation/components/TemplateConfigurationTreeEditor.tsx

@@ -22,6 +22,7 @@ import {
   getObjectDisplayName,
   type LabelStudioTagConfig,
 } from "../annotation.tagconfig";
+import { DataType } from "../annotation.model";
 
 const { Text, Title } = Typography;
 
@@ -44,10 +45,22 @@ interface TemplateConfigurationTreeEditorProps {
   readOnly?: boolean;
   readOnlyStructure?: boolean;
   height?: number | string;
+  dataType?: DataType;
 }
 
 const DEFAULT_ROOT_TAG = "View";
 const CHILD_TAGS = ["Label", "Choice", "Relation", "Item", "Path", "Channel"];
+const OBJECT_TAGS_BY_DATA_TYPE: Record<DataType, string[]> = {
+  [DataType.TEXT]: ["Text", "Paragraphs", "Markdown"],
+  [DataType.IMAGE]: ["Image", "Bitmask"],
+  [DataType.AUDIO]: ["Audio", "AudioPlus"],
+  [DataType.VIDEO]: ["Video"],
+  [DataType.PDF]: ["PDF"],
+  [DataType.TIMESERIES]: ["Timeseries", "TimeSeries", "Vector"],
+  [DataType.CHAT]: ["Chat"],
+  [DataType.HTML]: ["HyperText", "Markdown"],
+  [DataType.TABLE]: ["Table", "Vector"],
+};
 
 const createId = () =>
   `node_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -247,18 +260,34 @@ const createNode = (
     attrs[attr] = "";
   });
 
-  if (objectConfig && attrs.name !== undefined) {
+  if (objectConfig) {
     const name = getDefaultName(tag);
-    attrs.name = name;
+    if (!attrs.name) {
-    if (attrs.value !== undefined) {
+      attrs.name = name;
-      attrs.value = `$${name}`;
+    }
+    if (!attrs.value) {
+      attrs.value = `$${attrs.name}`;
     }
   }
 
-  if (controlConfig && attrs.name !== undefined) {
+  if (controlConfig) {
-    attrs.name = getDefaultName(tag);
+    const isLabeling = controlConfig.category === "labeling";
-    if (attrs.toName !== undefined) {
+
-      attrs.toName = objectNames[0] || "";
+    if (isLabeling) {
+      if (!attrs.name) {
+        attrs.name = getDefaultName(tag);
+      }
+      if (!attrs.toName) {
+        attrs.toName = objectNames[0] || "";
+      }
+    } else {
+      // For layout controls, only fill if required
+      if (attrs.name !== undefined && !attrs.name) {
+        attrs.name = getDefaultName(tag);
+      }
+      if (attrs.toName !== undefined && !attrs.toName) {
+        attrs.toName = objectNames[0] || "";
+      }
     }
   }
 
@@ -420,14 +449,13 @@ const TemplateConfigurationTreeEditor = ({
   readOnly = false,
   readOnlyStructure = false,
   height = 420,
+  dataType,
 }: TemplateConfigurationTreeEditorProps) => {
   const { config } = useTagConfig(false);
   const [tree, setTree] = useState<XmlNode>(() => createEmptyTree());
   const [selectedId, setSelectedId] = useState<string>(tree.id);
   const [parseError, setParseError] = useState<string | null>(null);
   const lastSerialized = useRef<string>("");
-  const [addChildTag, setAddChildTag] = useState<string | undefined>();
-  const [addSiblingTag, setAddSiblingTag] = useState<string | undefined>();
 
   useEffect(() => {
     if (!value) {
@@ -498,11 +526,17 @@ const TemplateConfigurationTreeEditor = ({
 
   const objectOptions = useMemo(() => {
     if (!config?.objects) return [];
-    return Object.keys(config.objects).map((tag) => ({
+    const options = Object.keys(config.objects).map((tag) => ({
       value: tag,
       label: getObjectDisplayName(tag),
     }));
-  }, [config]);
+    if (!dataType) return options;
+    const allowedTags = OBJECT_TAGS_BY_DATA_TYPE[dataType];
+    if (!allowedTags) return options;
+    const allowedSet = new Set(allowedTags);
+    const filtered = options.filter((option) => allowedSet.has(option.value));
+    return filtered.length > 0 ? filtered : options;
+  }, [config, dataType]);
 
   const tagOptions = useMemo(() => {
     const options = [] as {
@@ -763,9 +797,8 @@ const TemplateConfigurationTreeEditor = ({
             <Select
               placeholder="添加子节点"
               options={tagOptions}
-              value={addChildTag}
+              value={null}
               onChange={(value) => {
-                setAddChildTag(undefined);
                 handleAddNode(value, "child");
               }}
               disabled={isStructureLocked}
@@ -773,9 +806,8 @@ const TemplateConfigurationTreeEditor = ({
             <Select
               placeholder="添加同级节点"
               options={tagOptions}
-              value={addSiblingTag}
+              value={null}
               onChange={(value) => {
-                setAddSiblingTag(undefined);
                 handleAddNode(value, "sibling");
               }}
               disabled={isStructureLocked || selectedNode.id === tree.id}

frontend/src/pages/DataEvaluation/Create/PreviewPrompt.tsx

@@ -7,6 +7,8 @@ interface PreviewPromptModalProps {
   evaluationPrompt: string;
 }
 
+const PREVIEW_MODAL_WIDTH = "80vw";
+
 const PreviewPromptModal: React.FC<PreviewPromptModalProps> = ({ previewVisible, onCancel, evaluationPrompt }) => {
   return (
     <Modal
@@ -24,7 +26,7 @@ const PreviewPromptModal: React.FC<PreviewPromptModalProps> = ({ previewVisible,
           关闭
         </Button>
       ]}
-      width={800}
+      width={PREVIEW_MODAL_WIDTH}
     >
       <div style={{
         background: '#f5f5f5',

frontend/src/pages/DataManagement/Create/components/BasicInformation.tsx

@@ -11,10 +11,12 @@ export default function BasicInformation({
   data,
   setData,
   hidden = [],
+  datasetTypeOptions = datasetTypes,
 }: {
   data: DatasetFormData;
   setData: Dispatch<SetStateAction<DatasetFormData>>;
   hidden?: string[];
+  datasetTypeOptions?: DatasetTypeOption[];
 }) {
   const [tagOptions, setTagOptions] = useState<DatasetTagOption[]>([]);
   const [collectionOptions, setCollectionOptions] = useState<SelectOption[]>([]);
@@ -119,7 +121,7 @@ export default function BasicInformation({
           rules={[{ required: true, message: "请选择数据集类型" }]}
         >
           <RadioCard
-            options={datasetTypes}
+            options={datasetTypeOptions}
             value={data.type}
             onChange={(datasetType) => setData({ ...data, datasetType })}
           />
@@ -149,6 +151,8 @@ type DatasetFormData = Partial<Dataset> & {
   parentDatasetId?: string;
 };
 
+type DatasetTypeOption = (typeof datasetTypes)[number];
+
 type DatasetTagOption = {
   label: string;
   value: string;

frontend/src/pages/DataManagement/Detail/DatasetDetail.tsx

@@ -28,8 +28,10 @@ import Overview from "./components/Overview";
 import { Activity, Clock, File, FileType } from "lucide-react";
 import EditDataset from "../Create/EditDataset";
 import ImportConfiguration from "./components/ImportConfiguration";
+import CardView from "@/components/CardView";
 
 const SIMILAR_DATASET_LIMIT = 4;
+const SIMILAR_TAGS_PREVIEW_LIMIT = 3;
 
 export default function DatasetDetail() {
   const { id } = useParams(); // 获取动态路由参数
@@ -97,6 +99,19 @@ export default function DatasetDetail() {
       }
     }
   };
+
+  const similarTagsSummary = useMemo(() => {
+    if (!similarTagNames || similarTagNames.length === 0) {
+      return "";
+    }
+    const visibleTags = similarTagNames.slice(0, SIMILAR_TAGS_PREVIEW_LIMIT);
+    const hiddenCount = similarTagNames.length - visibleTags.length;
+    if (hiddenCount > 0) {
+      return `${visibleTags.join("、")} 等 ${similarTagNames.length} 个`;
+    }
+    return visibleTags.join("、");
+  }, [similarTagNames]);
+
   const navigateItems = useMemo(() => {
     const items = [
       {
@@ -183,8 +198,14 @@ export default function DatasetDetail() {
       return;
     }
     fetchDataset();
-    filesOperation.fetchFiles("", 1, 10); // 从根目录开始，第一页
   }, [id]);
+
+  useEffect(() => {
+    if (dataset?.id) {
+      filesOperation.fetchFiles("", 1, 10); // 从根目录开始，第一页
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [dataset?.id]);
   useEffect(() => {
     if (dataset?.parentDatasetId && activeTab === "children") {
       setActiveTab("overview");
@@ -362,7 +383,7 @@ export default function DatasetDetail() {
   ];
 
   return (
-    <div className="h-full flex flex-col gap-4">
+    <div className="h-full flex flex-col gap-4 overflow-hidden">
       <Breadcrumb items={navigateItems} />
       {/* Header */}
       <DetailHeader
@@ -398,40 +419,65 @@ export default function DatasetDetail() {
           },
         }}
       />
-      <div className="flex-overflow-auto p-6 pt-2 bg-white rounded-md shadow">
+      <div className="flex-1 overflow-auto">
-        <Tabs activeKey={activeTab} items={tabList} onChange={setActiveTab} />
+        <div className="p-6 pt-2 bg-white rounded-md shadow mb-4">
-        <div className="h-full overflow-auto">
+          <Tabs activeKey={activeTab} items={tabList} onChange={setActiveTab} />
-          {activeTab === "overview" && (
+          <div className="">
-            <Overview
+            {activeTab === "overview" && (
-              dataset={dataset}
+              <Overview
-              filesOperation={filesOperation}
+                dataset={dataset}
-              fetchDataset={fetchDataset}
+                filesOperation={filesOperation}
-              onUpload={() => setShowUploadDialog(true)}
+                fetchDataset={fetchDataset}
-              similarDatasets={similarDatasets}
+                onUpload={() => setShowUploadDialog(true)}
-              similarDatasetsLoading={similarDatasetsLoading}
-              similarTags={similarTagNames}
-            />
-          )}
-          {activeTab === "children" && (
-            <div className="pt-4">
-              <div className="flex items-center justify-between mb-3">
-                <h2 className="text-base font-semibold">关联数据集</h2>
-                <span className="text-xs text-gray-500">
-                  共 {childDatasets.length} 个
-                </span>
-              </div>
-              <Table
-                rowKey="id"
-                columns={childColumns}
-                dataSource={childDatasets}
-                loading={childDatasetsLoading}
-                pagination={false}
-                locale={{ emptyText: "暂无关联数据集" }}
               />
-            </div>
+            )}
-          )}
+            {activeTab === "children" && (
-          {activeTab === "lineage" && <DataLineageFlow dataset={dataset} />}
+              <div className="pt-4">
-          {activeTab === "quality" && <DataQuality />}
+                <div className="flex items-center justify-between mb-3">
+                  <h2 className="text-base font-semibold">关联数据集</h2>
+                  <span className="text-xs text-gray-500">
+                    共 {childDatasets.length} 个
+                  </span>
+                </div>
+                <Table
+                  rowKey="id"
+                  columns={childColumns}
+                  dataSource={childDatasets}
+                  loading={childDatasetsLoading}
+                  pagination={false}
+                  locale={{ emptyText: "暂无关联数据集" }}
+                />
+              </div>
+            )}
+            {activeTab === "lineage" && <DataLineageFlow dataset={dataset} />}
+            {activeTab === "quality" && <DataQuality />}
+          </div>
+        </div>
+
+        {/* 相似数据集 */}
+        <div className="bg-white rounded-md shadow p-6 mb-4">
+          <div className="flex items-center justify-between mb-3">
+            <h2 className="text-base font-semibold">相似数据集</h2>
+            {similarTagsSummary && (
+              <span className="text-xs text-gray-500">
+                匹配标签：{similarTagsSummary}
+              </span>
+            )}
+          </div>
+          <CardView
+            data={similarDatasets}
+            loading={similarDatasetsLoading}
+            operations={[]}
+            pagination={{
+              current: 1,
+              pageSize: similarDatasets.length || 10,
+              total: similarDatasets.length || 0,
+              style: { display: "none" },
+            }}
+            onView={(item) => {
+              navigate(`/data/management/detail/${item.id}`);
+            }}
+          />
         </div>
       </div>
       <ImportConfiguration

frontend/src/pages/DataManagement/Detail/components/ImportConfiguration.tsx

@@ -1,19 +1,83 @@
 import { Select, Input, Form, Radio, Modal, Button, UploadFile, Switch, Tooltip } from "antd";
 import { InboxOutlined, QuestionCircleOutlined } from "@ant-design/icons";
 import { dataSourceOptions } from "../../dataset.const";
-import { Dataset, DataSource } from "../../dataset.model";
+import { Dataset, DatasetType, DataSource } from "../../dataset.model";
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import { queryTasksUsingGet } from "@/pages/DataCollection/collection.apis";
 import { updateDatasetByIdUsingPut } from "../../dataset.api";
-import { sliceFile } from "@/utils/file.util";
+import { sliceFile, shouldStreamUpload } from "@/utils/file.util";
 import Dragger from "antd/es/upload/Dragger";
 
+const TEXT_FILE_MIME_PREFIX = "text/";
+const TEXT_FILE_MIME_TYPES = new Set([
+  "application/json",
+  "application/xml",
+  "application/csv",
+  "application/ndjson",
+  "application/x-ndjson",
+  "application/x-yaml",
+  "application/yaml",
+  "application/javascript",
+  "application/x-javascript",
+  "application/sql",
+]);
+const TEXT_FILE_EXTENSIONS = new Set([
+  ".txt",
+  ".md",
+  ".csv",
+  ".tsv",
+  ".json",
+  ".jsonl",
+  ".ndjson",
+  ".log",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".sql",
+]);
+
+function getUploadFileName(file: UploadFile): string {
+  if (file.name) return file.name;
+  const originFile = file.originFileObj;
+  if (originFile instanceof File && originFile.name) {
+    return originFile.name;
+  }
+  return "";
+}
+
+function getUploadFileType(file: UploadFile): string {
+  if (file.type) return file.type;
+  const originFile = file.originFileObj;
+  if (originFile instanceof File && typeof originFile.type === "string") {
+    return originFile.type;
+  }
+  return "";
+}
+
+function isTextUploadFile(file: UploadFile): boolean {
+  const mimeType = getUploadFileType(file).toLowerCase();
+  if (mimeType) {
+    if (mimeType.startsWith(TEXT_FILE_MIME_PREFIX)) return true;
+    if (TEXT_FILE_MIME_TYPES.has(mimeType)) return true;
+  }
+
+  const fileName = getUploadFileName(file);
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex < 0) return false;
+  const ext = fileName.slice(dotIndex).toLowerCase();
+  return TEXT_FILE_EXTENSIONS.has(ext);
+}
+
 /**
  * 按行分割文件
  * @param file 原始文件
  * @returns 分割后的文件列表，每行一个文件
  */
 async function splitFileByLines(file: UploadFile): Promise<UploadFile[]> {
+  if (!isTextUploadFile(file)) {
+    return [file];
+  }
+
   const originFile = file.originFileObj ?? file;
   if (!(originFile instanceof File) || typeof originFile.text !== "function") {
     return [file];
@@ -26,14 +90,16 @@ async function splitFileByLines(file: UploadFile): Promise<UploadFile[]> {
   const lines = text.split(/\r?\n/).filter((line: string) => line.trim() !== "");
   if (lines.length === 0) return [];
 
-  // 生成文件名：原文件名_序号.扩展名
+  // 生成文件名：原文件名_序号（不保留后缀）
   const nameParts = file.name.split(".");
-  const ext = nameParts.length > 1 ? "." + nameParts.pop() : "";
+  if (nameParts.length > 1) {
+    nameParts.pop();
+  }
   const baseName = nameParts.join(".");
   const padLength = String(lines.length).length;
 
   return lines.map((line: string, index: number) => {
-    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}${ext}`;
+    const newFileName = `${baseName}_${String(index + 1).padStart(padLength, "0")}`;
     const blob = new Blob([line], { type: "text/plain" });
     const newFile = new File([blob], newFileName, { type: "text/plain" });
     return {
@@ -90,21 +156,85 @@ export default function ImportConfiguration({
     splitByLine: false,
   });
   const [currentPrefix, setCurrentPrefix] = useState<string>("");
+  const hasNonTextFile = useMemo(() => {
+    const files = importConfig.files ?? [];
+    if (files.length === 0) return false;
+    return files.some((file) => !isTextUploadFile(file));
+  }, [importConfig.files]);
+  const isTextDataset = data?.datasetType === DatasetType.TEXT;
 
   // 本地上传文件相关逻辑
 
   const handleUpload = async (dataset: Dataset) => {
-    let filesToUpload =
+    const filesToUpload =
       (form.getFieldValue("files") as UploadFile[] | undefined) || [];
 
-    // 如果启用分行分割，处理文件
+    // 如果启用分行分割，对大文件使用流式处理
-    if (importConfig.splitByLine) {
+    if (importConfig.splitByLine && !hasNonTextFile) {
-      const splitResults = await Promise.all(
+      // 检查是否有大文件需要流式分割上传
-        filesToUpload.map((file) => splitFileByLines(file))
+      const filesForStreamUpload: File[] = [];
-      );
+      const filesForNormalUpload: UploadFile[] = [];
-      filesToUpload = splitResults.flat();
+
+      for (const file of filesToUpload) {
+        const originFile = file.originFileObj ?? file;
+        if (originFile instanceof File && shouldStreamUpload(originFile)) {
+          filesForStreamUpload.push(originFile);
+        } else {
+          filesForNormalUpload.push(file);
+        }
+      }
+
+      // 大文件使用流式分割上传
+      if (filesForStreamUpload.length > 0) {
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset-stream", {
+            detail: {
+              dataset,
+              files: filesForStreamUpload,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+
+      // 小文件使用传统分割方式
+      if (filesForNormalUpload.length > 0) {
+        const splitResults = await Promise.all(
+          filesForNormalUpload.map((file) => splitFileByLines(file))
+        );
+        const smallFilesToUpload = splitResults.flat();
+        
+        // 计算分片列表
+        const sliceList = smallFilesToUpload.map((file) => {
+          const originFile = (file.originFileObj ?? file) as Blob;
+          const slices = sliceFile(originFile);
+          return {
+            originFile: originFile,
+            slices,
+            name: file.name,
+            size: originFile.size || 0,
+          };
+        });
+
+        console.log("[ImportConfiguration] Uploading small files with currentPrefix:", currentPrefix);
+        window.dispatchEvent(
+          new CustomEvent("upload:dataset", {
+            detail: {
+              dataset,
+              files: sliceList,
+              updateEvent,
+              hasArchive: importConfig.hasArchive,
+              prefix: currentPrefix,
+            },
+          })
+        );
+      }
+      return;
     }
 
+    // 未启用分行分割，使用普通上传
     // 计算分片列表
     const sliceList = filesToUpload.map((file) => {
       const originFile = (file.originFileObj ?? file) as Blob;
@@ -131,7 +261,7 @@ export default function ImportConfiguration({
     );
   };
 
-  const fetchCollectionTasks = async () => {
+  const fetchCollectionTasks = useCallback(async () => {
     if (importConfig.source !== DataSource.COLLECTION) return;
     try {
       const res = await queryTasksUsingGet({ page: 0, size: 100 });
@@ -146,9 +276,9 @@ export default function ImportConfiguration({
     } catch (error) {
       console.error("Error fetching collection tasks:", error);
     }
-  };
+  }, [importConfig.source]);
 
-  const resetState = () => {
+  const resetState = useCallback(() => {
     console.log('[ImportConfiguration] resetState called, preserving currentPrefix:', currentPrefix);
     form.resetFields();
     form.setFieldsValue({ files: null });
@@ -158,12 +288,16 @@ export default function ImportConfiguration({
       splitByLine: false,
     });
     console.log('[ImportConfiguration] resetState done, currentPrefix still:', currentPrefix);
-  };
+  }, [currentPrefix, form]);
 
   const handleImportData = async () => {
     if (!data) return;
     console.log('[ImportConfiguration] handleImportData called, currentPrefix:', currentPrefix);
     if (importConfig.source === DataSource.UPLOAD) {
+      // 立即显示任务中心，让用户感知上传已开始（在文件分割等耗时操作之前）
+      window.dispatchEvent(
+        new CustomEvent("show:task-popover", { detail: { show: true } })
+      );
       await handleUpload(data);
     } else if (importConfig.source === DataSource.COLLECTION) {
       await updateDatasetByIdUsingPut(data.id, {
@@ -180,14 +314,22 @@ export default function ImportConfiguration({
       resetState();
       fetchCollectionTasks();
     }
-  }, [open]);
+  }, [fetchCollectionTasks, open, prefix, resetState]);
+
+  useEffect(() => {
+    if (!importConfig.files?.length) return;
+    if (!importConfig.splitByLine) return;
+    if (!hasNonTextFile) return;
+    form.setFieldsValue({ splitByLine: false });
+    setImportConfig((prev) => ({ ...prev, splitByLine: false }));
+  }, [form, hasNonTextFile, importConfig.files, importConfig.splitByLine]);
 
   // Separate effect for fetching collection tasks when source changes
   useEffect(() => {
     if (open && importConfig.source === DataSource.COLLECTION) {
       fetchCollectionTasks();
     }
-  }, [importConfig.source]);
+  }, [fetchCollectionTasks, importConfig.source, open]);
 
   return (
     <Modal
@@ -286,20 +428,28 @@ export default function ImportConfiguration({
             >
               <Switch />
             </Form.Item>
-            <Form.Item
+            {isTextDataset && (
-              label={
+              <Form.Item
-                <span>
+                label={
-                  按分行分割{" "}
+                  <span>
-                  <Tooltip title="选中后，文本文件的每一行将被分割成独立文件">
+                    按分行分割{" "}
-                    <QuestionCircleOutlined style={{ color: "#999" }} />
+                    <Tooltip
-                  </Tooltip>
+                      title={
-                </span>
+                        hasNonTextFile
-              }
+                          ? "已选择非文本文件，无法按行分割"
-              name="splitByLine"
+                          : "选中后，文本文件的每一行将被分割成独立文件"
-              valuePropName="checked"
+                      }
-            >
+                    >
-              <Switch />
+                      <QuestionCircleOutlined style={{ color: "#999" }} />
-            </Form.Item>
+                    </Tooltip>
+                  </span>
+                }
+                name="splitByLine"
+                valuePropName="checked"
+              >
+                <Switch disabled={hasNonTextFile} />
+              </Form.Item>
+            )}
             <Form.Item
               label="上传文件"
               name="files"

frontend/src/pages/DataManagement/Detail/components/Overview.tsx

@@ -4,15 +4,14 @@ import {
   Descriptions,
   DescriptionsProps,
   Modal,
+  Spin,
   Table,
   Input,
-  Tag,
 } from "antd";
 import { formatBytes, formatDateTime } from "@/utils/unit";
 import { Download, Trash2, Folder, File } from "lucide-react";
 import { datasetTypeMap } from "../../dataset.const";
 import type { Dataset, DatasetFile } from "@/pages/DataManagement/dataset.model";
-import { Link } from "react-router";
 import type { useFilesOperation } from "../useFilesOperation";
 
 type DatasetFileRow = DatasetFile & {
@@ -23,23 +22,18 @@ type DatasetFileRow = DatasetFile & {
 
 const PREVIEW_MAX_HEIGHT = 500;
 const PREVIEW_MODAL_WIDTH = {
-  text: 800,
+  text: "80vw",
-  media: 700,
+  media: "80vw",
 };
 const PREVIEW_TEXT_FONT_SIZE = 12;
 const PREVIEW_TEXT_PADDING = 12;
 const PREVIEW_AUDIO_PADDING = 40;
-const SIMILAR_TAGS_PREVIEW_LIMIT = 3;
-const SIMILAR_DATASET_TAG_PREVIEW_LIMIT = 4;
 
 type OverviewProps = {
   dataset: Dataset;
   filesOperation: ReturnType<typeof useFilesOperation>;
   fetchDataset: () => void;
   onUpload?: () => void;
-  similarDatasets: Dataset[];
-  similarDatasetsLoading: boolean;
-  similarTags: string[];
 };
 
 export default function Overview({
@@ -47,9 +41,6 @@ export default function Overview({
   filesOperation,
   fetchDataset,
   onUpload,
-  similarDatasets,
-  similarDatasetsLoading,
-  similarTags,
 }: OverviewProps) {
   const { modal, message } = App.useApp();
   const {
@@ -62,6 +53,8 @@ export default function Overview({
     previewFileType,
     previewMediaUrl,
     previewLoading,
+    officePreviewStatus,
+    officePreviewError,
     closePreview,
     handleDeleteFile,
     handleDownloadFile,
@@ -72,82 +65,6 @@ export default function Overview({
     handleDeleteDirectory,
     handlePreviewFile,
   } = filesOperation;
-  const similarTagsSummary = (() => {
-    if (!similarTags || similarTags.length === 0) {
-      return "";
-    }
-    const visibleTags = similarTags.slice(0, SIMILAR_TAGS_PREVIEW_LIMIT);
-    const hiddenCount = similarTags.length - visibleTags.length;
-    if (hiddenCount > 0) {
-      return `${visibleTags.join("、")} 等 ${similarTags.length} 个`;
-    }
-    return visibleTags.join("、");
-  })();
-  const renderDatasetTags = (
-    tags?: Array<string | { name?: string; color?: string } | null>
-  ) => {
-    if (!tags || tags.length === 0) {
-      return "-";
-    }
-    const visibleTags = tags.slice(0, SIMILAR_DATASET_TAG_PREVIEW_LIMIT);
-    const hiddenCount = tags.length - visibleTags.length;
-    return (
-      <div className="flex flex-wrap gap-1">
-        {visibleTags.map((tag, index) => {
-          const tagName = typeof tag === "string" ? tag : tag?.name;
-          if (!tagName) {
-            return null;
-          }
-          const tagColor = typeof tag === "string" ? undefined : tag?.color;
-          return (
-            <Tag key={`${tagName}-${index}`} color={tagColor}>
-              {tagName}
-            </Tag>
-          );
-        })}
-        {hiddenCount > 0 && <Tag>+{hiddenCount}</Tag>}
-      </div>
-    );
-  };
-  const similarColumns = [
-    {
-      title: "名称",
-      dataIndex: "name",
-      key: "name",
-      render: (_: string, record: Dataset) => (
-        <Link to={`/data/management/detail/${record.id}`}>{record.name}</Link>
-      ),
-    },
-    {
-      title: "标签",
-      dataIndex: "tags",
-      key: "tags",
-      render: (tags: Array<string | { name?: string; color?: string }>) =>
-        renderDatasetTags(tags),
-    },
-    {
-      title: "类型",
-      dataIndex: "datasetType",
-      key: "datasetType",
-      width: 120,
-      render: (_: string, record: Dataset) =>
-        datasetTypeMap[record.datasetType as keyof typeof datasetTypeMap]?.label ||
-        "未知",
-    },
-    {
-      title: "文件数",
-      dataIndex: "fileCount",
-      key: "fileCount",
-      width: 120,
-      render: (value?: number) => value ?? 0,
-    },
-    {
-      title: "更新时间",
-      dataIndex: "updatedAt",
-      key: "updatedAt",
-      width: 180,
-    },
-  ];
 
   // 基本信息
   const items: DescriptionsProps["items"] = [
@@ -375,31 +292,6 @@ export default function Overview({
           column={5}
         />
 
-        {/* 相似数据集 */}
-        <div className="mt-8">
-          <div className="flex items-center justify-between mb-3">
-            <h2 className="text-base font-semibold">相似数据集</h2>
-            {similarTagsSummary && (
-              <span className="text-xs text-gray-500">
-                匹配标签：{similarTagsSummary}
-              </span>
-            )}
-          </div>
-          <Table
-            size="small"
-            rowKey="id"
-            columns={similarColumns}
-            dataSource={similarDatasets}
-            loading={similarDatasetsLoading}
-            pagination={false}
-            locale={{
-              emptyText: similarTags?.length
-                ? "暂无相似数据集"
-                : "当前数据集未设置标签",
-            }}
-          />
-        </div>
-
         {/* 文件列表 */}
         <div className="flex items-center justify-between mt-8 mb-2">
           <h2 className="text-base font-semibold">文件列表</h2>
@@ -558,11 +450,39 @@ export default function Overview({
           </div>
         )}
         {previewFileType === "pdf" && (
-          <iframe
+          <>
-            src={previewMediaUrl}
+            {previewMediaUrl ? (
-            title={previewFileName || "PDF 预览"}
+              <iframe
-            style={{ width: "100%", height: `${PREVIEW_MAX_HEIGHT}px`, border: "none" }}
+                src={previewMediaUrl}
-          />
+                title={previewFileName || "PDF 预览"}
+                style={{ width: "100%", height: `${PREVIEW_MAX_HEIGHT}px`, border: "none" }}
+              />
+            ) : (
+              <div
+                style={{
+                  height: `${PREVIEW_MAX_HEIGHT}px`,
+                  display: "flex",
+                  flexDirection: "column",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  gap: 12,
+                  color: "#666",
+                }}
+              >
+                {officePreviewStatus === "FAILED" ? (
+                  <>
+                    <div>转换失败</div>
+                    <div>{officePreviewError || "请稍后重试"}</div>
+                  </>
+                ) : (
+                  <>
+                    <Spin />
+                    <div>正在转换，请稍候...</div>
+                  </>
+                )}
+              </div>
+            )}
+          </>
         )}
         {previewFileType === "video" && (
           <div style={{ textAlign: "center" }}>

frontend/src/pages/DataManagement/Detail/useFilesOperation.ts

@@ -3,7 +3,7 @@ import type {
   DatasetFile,
 } from "@/pages/DataManagement/dataset.model";
 import { App } from "antd";
-import { useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import {
   PREVIEW_TEXT_MAX_LENGTH,
   resolvePreviewFileType,
@@ -18,9 +18,33 @@ import {
   createDatasetDirectoryUsingPost,
   downloadDirectoryUsingGet,
   deleteDirectoryUsingDelete,
+  queryDatasetFilePreviewStatusUsingGet,
+  convertDatasetFilePreviewUsingPost,
 } from "../dataset.api";
 import { useParams } from "react-router";
 
+const OFFICE_FILE_EXTENSIONS = [".doc", ".docx"];
+const OFFICE_PREVIEW_POLL_INTERVAL = 2000;
+const OFFICE_PREVIEW_POLL_MAX_TIMES = 60;
+
+type OfficePreviewStatus = "UNSET" | "PENDING" | "PROCESSING" | "READY" | "FAILED";
+
+const isOfficeFileName = (fileName?: string) => {
+  const lowerName = (fileName || "").toLowerCase();
+  return OFFICE_FILE_EXTENSIONS.some((ext) => lowerName.endsWith(ext));
+};
+
+const normalizeOfficePreviewStatus = (status?: string): OfficePreviewStatus => {
+  if (!status) {
+    return "UNSET";
+  }
+  const upper = status.toUpperCase();
+  if (upper === "PENDING" || upper === "PROCESSING" || upper === "READY" || upper === "FAILED") {
+    return upper as OfficePreviewStatus;
+  }
+  return "UNSET";
+};
+
 
 export function useFilesOperation(dataset: Dataset) {
   const { message } = App.useApp();
@@ -43,6 +67,23 @@ export function useFilesOperation(dataset: Dataset) {
   const [previewFileType, setPreviewFileType] = useState<PreviewFileType>("text");
   const [previewMediaUrl, setPreviewMediaUrl] = useState("");
   const [previewLoading, setPreviewLoading] = useState(false);
+  const [officePreviewStatus, setOfficePreviewStatus] = useState<OfficePreviewStatus | null>(null);
+  const [officePreviewError, setOfficePreviewError] = useState("");
+  const officePreviewPollingRef = useRef<number | null>(null);
+  const officePreviewFileRef = useRef<string | null>(null);
+
+  const clearOfficePreviewPolling = useCallback(() => {
+    if (officePreviewPollingRef.current) {
+      window.clearTimeout(officePreviewPollingRef.current);
+      officePreviewPollingRef.current = null;
+    }
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      clearOfficePreviewPolling();
+    };
+  }, [clearOfficePreviewPolling]);
 
   const fetchFiles = async (
     prefix?: string,
@@ -57,6 +98,7 @@ export function useFilesOperation(dataset: Dataset) {
       size: pageSize !== undefined ? pageSize : pagination.pageSize,
       isWithDirectory: true,
       prefix: targetPrefix,
+      excludeDerivedFiles: true,
     };
 
     const { data } = await queryDatasetFilesUsingGet(id!, params);
@@ -110,17 +152,61 @@ export function useFilesOperation(dataset: Dataset) {
       return;
     }
 
+    const previewUrl = `/api/data-management/datasets/${datasetId}/files/${file.id}/preview`;
+    setPreviewFileName(file.fileName);
+    setPreviewContent("");
+    setPreviewMediaUrl("");
+
+    if (isOfficeFileName(file?.fileName)) {
+      setPreviewFileType("pdf");
+      setPreviewVisible(true);
+      setPreviewLoading(true);
+      setOfficePreviewStatus("PROCESSING");
+      setOfficePreviewError("");
+      officePreviewFileRef.current = file.id;
+      try {
+        const { data: statusData } = await queryDatasetFilePreviewStatusUsingGet(datasetId, file.id);
+        const currentStatus = normalizeOfficePreviewStatus(statusData?.status);
+        if (currentStatus === "READY") {
+          setPreviewMediaUrl(previewUrl);
+          setOfficePreviewStatus("READY");
+          setPreviewLoading(false);
+          return;
+        }
+        if (currentStatus === "PROCESSING") {
+          pollOfficePreviewStatus(datasetId, file.id, 0);
+          return;
+        }
+        const { data } = await convertDatasetFilePreviewUsingPost(datasetId, file.id);
+        const status = normalizeOfficePreviewStatus(data?.status);
+        if (status === "READY") {
+          setPreviewMediaUrl(previewUrl);
+          setOfficePreviewStatus("READY");
+        } else if (status === "FAILED") {
+          setOfficePreviewStatus("FAILED");
+          setOfficePreviewError(data?.previewError || "转换失败，请稍后重试");
+        } else {
+          setOfficePreviewStatus("PROCESSING");
+          pollOfficePreviewStatus(datasetId, file.id, 0);
+          return;
+        }
+      } catch (error) {
+        console.error("触发预览转换失败", error);
+        message.error({ content: "触发预览转换失败" });
+        setOfficePreviewStatus("FAILED");
+        setOfficePreviewError("触发预览转换失败");
+      } finally {
+        setPreviewLoading(false);
+      }
+      return;
+    }
+
     const fileType = resolvePreviewFileType(file?.fileName);
     if (!fileType) {
       message.warning({ content: "不支持预览该文件类型" });
       return;
     }
-
-    const previewUrl = `/api/data-management/datasets/${datasetId}/files/${file.id}/preview`;
-    setPreviewFileName(file.fileName);
     setPreviewFileType(fileType);
-    setPreviewContent("");
-    setPreviewMediaUrl("");
 
     if (fileType === "text") {
       setPreviewLoading(true);
@@ -146,13 +232,62 @@ export function useFilesOperation(dataset: Dataset) {
   };
 
   const closePreview = () => {
+    clearOfficePreviewPolling();
+    officePreviewFileRef.current = null;
     setPreviewVisible(false);
     setPreviewContent("");
     setPreviewMediaUrl("");
     setPreviewFileName("");
     setPreviewFileType("text");
+    setOfficePreviewStatus(null);
+    setOfficePreviewError("");
   };
 
+  const pollOfficePreviewStatus = useCallback(
+    async (datasetId: string, fileId: string, attempt: number) => {
+      clearOfficePreviewPolling();
+      officePreviewPollingRef.current = window.setTimeout(async () => {
+        if (officePreviewFileRef.current !== fileId) {
+          return;
+        }
+        try {
+          const { data } = await queryDatasetFilePreviewStatusUsingGet(datasetId, fileId);
+          const status = normalizeOfficePreviewStatus(data?.status);
+          if (status === "READY") {
+            setPreviewMediaUrl(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview`);
+            setOfficePreviewStatus("READY");
+            setOfficePreviewError("");
+            setPreviewLoading(false);
+            return;
+          }
+          if (status === "FAILED") {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError(data?.previewError || "转换失败，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          if (attempt >= OFFICE_PREVIEW_POLL_MAX_TIMES - 1) {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError("转换超时，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          pollOfficePreviewStatus(datasetId, fileId, attempt + 1);
+        } catch (error) {
+          console.error("轮询预览状态失败", error);
+          if (attempt >= OFFICE_PREVIEW_POLL_MAX_TIMES - 1) {
+            setOfficePreviewStatus("FAILED");
+            setOfficePreviewError("转换超时，请稍后重试");
+            setPreviewLoading(false);
+            return;
+          }
+          pollOfficePreviewStatus(datasetId, fileId, attempt + 1);
+        }
+      }, OFFICE_PREVIEW_POLL_INTERVAL);
+    },
+    [clearOfficePreviewPolling]
+  );
+
   const handleDeleteFile = async (file: DatasetFile) => {
     try {
       await deleteDatasetFileUsingDelete(dataset.id, file.id);
@@ -195,6 +330,8 @@ export function useFilesOperation(dataset: Dataset) {
     previewFileType,
     previewMediaUrl,
     previewLoading,
+    officePreviewStatus,
+    officePreviewError,
     closePreview,
     fetchFiles,
     setFileList,
@@ -245,4 +382,5 @@ interface DatasetFilesQueryParams {
   size: number;
   isWithDirectory: boolean;
   prefix: string;
+  excludeDerivedFiles?: boolean;
 }

frontend/src/pages/DataManagement/Home/DataManagement.tsx

@@ -329,7 +329,7 @@ export default function DatasetManagementPage() {
     <div className="gap-4 h-full flex flex-col">
       {/* Header */}
       <div className="flex items-center justify-between">
-        <h1 className="text-xl font-bold">数据管理</h1>
+        <h1 className="text-xl font-bold">数据集统计</h1>
         <div className="flex gap-2 items-center">
           {/* tasks */}
           <TagManager

frontend/src/pages/DataManagement/dataset.api.ts

@@ -119,6 +119,22 @@ export function downloadFileByIdUsingGet(
   );
 }
 
+// 数据集文件预览状态
+export function queryDatasetFilePreviewStatusUsingGet(
+  datasetId: string | number,
+  fileId: string | number
+) {
+  return get(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview/status`);
+}
+
+// 触发数据集文件预览转换
+export function convertDatasetFilePreviewUsingPost(
+  datasetId: string | number,
+  fileId: string | number
+) {
+  return post(`/api/data-management/datasets/${datasetId}/files/${fileId}/preview/convert`, {});
+}
+
 // 删除数据集文件
 export function deleteDatasetFileUsingDelete(
   datasetId: string | number,

frontend/src/pages/DataManagement/dataset.model.ts

@@ -102,6 +102,13 @@ export interface DatasetTask {
   executionHistory?: { time: string; status: string }[];
 }
 
+export interface StreamUploadInfo {
+  currentFile: string;
+  fileIndex: number;
+  totalFiles: number;
+  uploadedLines: number;
+}
+
 export interface TaskItem {
   key: string;
   title: string;
@@ -113,4 +120,6 @@ export interface TaskItem {
   updateEvent?: string;
   size?: number;
   hasArchive?: boolean;
+  prefix?: string;
+  streamUploadInfo?: StreamUploadInfo;
 }

frontend/src/pages/KnowledgeManagement/Home/KnowledgeManagementPage.tsx

@@ -1,5 +1,5 @@
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
-import { Card, Button, Table, Tooltip, Tag, App } from "antd";
+import { Card, Button, Table, Tooltip, Tag, App, Statistic } from "antd";
 import { DeleteOutlined, EditOutlined } from "@ant-design/icons";
 import { useNavigate } from "react-router";
 import CardView from "@/components/CardView";
@@ -8,6 +8,7 @@ import TagManager from "@/components/business/TagManagement";
 import useFetchData from "@/hooks/useFetchData";
 import {
   deleteKnowledgeSetByIdUsingDelete,
+  getKnowledgeManagementStatisticsUsingGet,
   queryKnowledgeSetsUsingGet,
 } from "../knowledge-management.api";
 import {
@@ -15,7 +16,7 @@ import {
   mapKnowledgeSet,
   KnowledgeSetView,
 } from "../knowledge-management.const";
-import { KnowledgeSet } from "../knowledge-management.model";
+import { KnowledgeManagementStatistics, KnowledgeSet } from "../knowledge-management.model";
 import CreateKnowledgeSet from "../components/CreateKnowledgeSet";
 import {
   createDatasetTagUsingPost,
@@ -23,6 +24,31 @@ import {
   queryDatasetTagsUsingGet,
   updateDatasetTagUsingPut,
 } from "@/pages/DataManagement/dataset.api";
+import { formatBytes } from "@/utils/unit";
+
+type StatisticsItem = {
+  title: string;
+  value: number | string;
+};
+
+const DEFAULT_STATISTICS: StatisticsItem[] = [
+  {
+    title: "知识集总数",
+    value: 0,
+  },
+  {
+    title: "知识类别",
+    value: 0,
+  },
+  {
+    title: "文件总数",
+    value: 0,
+  },
+  {
+    title: "总大小",
+    value: "0 B",
+  },
+];
 
 export default function KnowledgeManagementPage() {
   const navigate = useNavigate();
@@ -31,6 +57,9 @@ export default function KnowledgeManagementPage() {
   const [isEdit, setIsEdit] = useState(false);
   const [currentSet, setCurrentSet] = useState<KnowledgeSet | null>(null);
   const [tags, setTags] = useState<string[]>([]);
+  const [statisticsData, setStatisticsData] = useState<StatisticsItem[]>(
+    DEFAULT_STATISTICS
+  );
 
   useEffect(() => {
     const fetchTags = async () => {
@@ -75,10 +104,49 @@ export default function KnowledgeManagementPage() {
     0
   );
 
+  const fetchStatistics = useCallback(async () => {
+    try {
+      const { data } = await getKnowledgeManagementStatisticsUsingGet();
+      const stats = data as KnowledgeManagementStatistics | undefined;
+      setStatisticsData([
+        {
+          title: "知识集总数",
+          value: stats?.totalKnowledgeSets ?? 0,
+        },
+        {
+          title: "知识类别",
+          value: stats?.totalTags ?? 0,
+        },
+        {
+          title: "文件总数",
+          value: stats?.totalFiles ?? 0,
+        },
+        {
+          title: "总大小",
+          value: formatBytes(stats?.totalSize ?? 0),
+        },
+      ]);
+    } catch {
+      message.error("统计数据加载失败");
+      setStatisticsData(DEFAULT_STATISTICS);
+    }
+  }, [message]);
+
+  const refreshAll = useCallback(
+    async (extraParams: Record<string, unknown> = {}) => {
+      await Promise.all([fetchData(extraParams), fetchStatistics()]);
+    },
+    [fetchData, fetchStatistics]
+  );
+
+  useEffect(() => {
+    fetchStatistics();
+  }, [fetchStatistics]);
+
   const handleDeleteSet = async (setId: string) => {
     await deleteKnowledgeSetByIdUsingDelete(setId);
     message.success("知识集删除成功");
-    fetchData({ pageOffset: 0 });
+    await refreshAll({ pageOffset: 0 });
   };
 
   const operations = [
@@ -189,8 +257,11 @@ export default function KnowledgeManagementPage() {
   return (
     <div className="h-full flex flex-col gap-4">
       <div className="flex items-center justify-between">
-        <h1 className="text-xl font-bold">知识管理</h1>
+        <h1 className="text-xl font-bold">知识集</h1>
         <div className="flex gap-2 items-center">
+          <Button onClick={() => navigate("/data/knowledge-management/search")}>
+            全库搜索
+          </Button>
           <TagManager
             onCreate={createDatasetTagUsingPost}
             onDelete={(ids: string) => deleteDatasetTagUsingDelete({ ids })}
@@ -201,7 +272,7 @@ export default function KnowledgeManagementPage() {
             isEdit={isEdit}
             data={currentSet}
             onUpdate={() => {
-              fetchData();
+              refreshAll();
             }}
             onClose={() => {
               setIsEdit(false);
@@ -211,6 +282,20 @@ export default function KnowledgeManagementPage() {
         </div>
       </div>
 
+      <div className="grid grid-cols-1 gap-4">
+        <Card>
+          <div className="grid grid-cols-4">
+            {statisticsData.map((item) => (
+              <Statistic
+                title={item.title}
+                key={item.title}
+                value={`${item.value}`}
+              />
+            ))}
+          </div>
+        </Card>
+      </div>
+
       <SearchControls
         searchTerm={searchParams.keyword}
         onSearchChange={handleKeywordChange}
@@ -221,7 +306,7 @@ export default function KnowledgeManagementPage() {
         viewMode={viewMode}
         onViewModeChange={setViewMode}
         showViewToggle
-        onReload={fetchData}
+        onReload={refreshAll}
       />
 
       {viewMode === "card" ? (

frontend/src/pages/KnowledgeManagement/Search/KnowledgeManagementSearch.tsx

@@ -0,0 +1,212 @@
+import { useCallback, useMemo, useState } from "react";
+import { App, Breadcrumb, Button, Input, Table } from "antd";
+import { useNavigate } from "react-router";
+import {
+  KnowledgeContentType,
+  KnowledgeItemSearchResult,
+  KnowledgeSourceType,
+} from "../knowledge-management.model";
+import {
+  knowledgeContentTypeOptions,
+  knowledgeSourceTypeOptions,
+} from "../knowledge-management.const";
+import { searchKnowledgeItemsUsingGet } from "../knowledge-management.api";
+import { formatBytes, formatDateTime } from "@/utils/unit";
+
+const buildOptionMap = (options: { label: string; value: string }[]) =>
+  options.reduce<Record<string, string>>((acc, option) => {
+    acc[option.value] = option.label;
+    return acc;
+  }, {});
+
+export default function KnowledgeManagementSearch() {
+  const navigate = useNavigate();
+  const { message } = App.useApp();
+  const [searchTerm, setSearchTerm] = useState("");
+  const [activeKeyword, setActiveKeyword] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [searched, setSearched] = useState(false);
+  const [results, setResults] = useState<KnowledgeItemSearchResult[]>([]);
+  const [pagination, setPagination] = useState({
+    current: 1,
+    pageSize: 10,
+    total: 0,
+  });
+
+  const contentTypeMap = useMemo(
+    () => buildOptionMap(knowledgeContentTypeOptions),
+    []
+  );
+  const sourceTypeMap = useMemo(
+    () => buildOptionMap(knowledgeSourceTypeOptions),
+    []
+  );
+
+  const fetchResults = useCallback(
+    async (keyword: string, page?: number, pageSize?: number) => {
+      const resolvedPage = page ?? pagination.current;
+      const resolvedPageSize = pageSize ?? pagination.pageSize;
+      if (!keyword) {
+        setResults([]);
+        setPagination((prev) => ({ ...prev, total: 0, current: resolvedPage }));
+        setSearched(false);
+        return;
+      }
+      setLoading(true);
+      try {
+        const { data } = await searchKnowledgeItemsUsingGet({
+          keyword,
+          page: Math.max(resolvedPage - 1, 0),
+          size: resolvedPageSize,
+        });
+        const content = Array.isArray(data?.content) ? data.content : [];
+        setResults(content);
+        setPagination({
+          current: resolvedPage,
+          pageSize: resolvedPageSize,
+          total: data?.totalElements ?? 0,
+        });
+        setSearched(true);
+      } catch (error) {
+        console.error("Failed to search knowledge items:", error);
+        message.error("检索失败，请稍后重试");
+      } finally {
+        setLoading(false);
+      }
+    },
+    [message, pagination]
+  );
+
+  const handleSearch = (value?: string) => {
+    const keyword = (value ?? searchTerm).trim();
+    if (!keyword) {
+      message.warning("请输入文件名");
+      return;
+    }
+    setActiveKeyword(keyword);
+    fetchResults(keyword, 1, pagination.pageSize);
+  };
+
+  const columns = useMemo(
+    () => [
+      {
+        title: "知识集",
+        dataIndex: "setName",
+        key: "setName",
+        width: 220,
+        ellipsis: true,
+        render: (text: string) => text || "-",
+      },
+      {
+        title: "文件名",
+        dataIndex: "fileName",
+        key: "fileName",
+        width: 220,
+        ellipsis: true,
+        render: (_: string, record: KnowledgeItemSearchResult) =>
+          record.fileName || record.sourceFileId || "-",
+      },
+      {
+        title: "来源类型",
+        dataIndex: "sourceType",
+        key: "sourceType",
+        width: 140,
+        render: (value: KnowledgeSourceType) =>
+          sourceTypeMap[value] || value || "-",
+      },
+      {
+        title: "内容类型",
+        dataIndex: "contentType",
+        key: "contentType",
+        width: 120,
+        render: (value: KnowledgeContentType) =>
+          contentTypeMap[value] || value || "-",
+      },
+      {
+        title: "大小",
+        dataIndex: "fileSize",
+        key: "fileSize",
+        width: 120,
+        render: (value?: number) => formatBytes(value ?? 0),
+      },
+      {
+        title: "更新时间",
+        dataIndex: "updatedAt",
+        key: "updatedAt",
+        width: 180,
+        ellipsis: true,
+        render: (value: string) => formatDateTime(value) || "-",
+      },
+      {
+        title: "操作",
+        key: "action",
+        width: 120,
+        align: "right" as const,
+        render: (_: unknown, record: KnowledgeItemSearchResult) => (
+          <Button
+            type="link"
+            onClick={() => {
+              navigate(`/data/knowledge-management/detail/${record.setId}`);
+            }}
+          >
+            定位
+          </Button>
+        ),
+      },
+    ],
+    [contentTypeMap, navigate, sourceTypeMap]
+  );
+
+  return (
+    <div className="h-full flex flex-col gap-4">
+      <Breadcrumb>
+        <Breadcrumb.Item>
+          <a onClick={() => navigate("/data/knowledge-management")}>知识管理</a>
+        </Breadcrumb.Item>
+        <Breadcrumb.Item>全库搜索</Breadcrumb.Item>
+      </Breadcrumb>
+      <div className="flex items-center justify-between">
+        <h1 className="text-xl font-bold">知识管理全库检索</h1>
+      </div>
+      <div className="flex items-center gap-3">
+        <Input.Search
+          allowClear
+          value={searchTerm}
+          onChange={(event) => setSearchTerm(event.target.value)}
+          onSearch={handleSearch}
+          placeholder="输入文件名，回车或点击搜索"
+          enterButton="搜索"
+          loading={loading}
+        />
+      </div>
+      <Table
+        rowKey="id"
+        loading={loading}
+        columns={columns}
+        dataSource={results}
+        pagination={{
+          current: pagination.current,
+          pageSize: pagination.pageSize,
+          total: pagination.total,
+          showTotal: (total) => `共 ${total} 条`,
+          onChange: (page, pageSize) => {
+            const nextKeyword = activeKeyword.trim();
+            if (!nextKeyword) {
+              message.warning("请输入文件名");
+              return;
+            }
+            fetchResults(nextKeyword, page, pageSize || pagination.pageSize);
+          },
+        }}
+        locale={{
+          emptyText: searched ? "暂无匹配文件" : "请输入文件名开始检索",
+        }}
+        onRow={(record) => ({
+          onClick: () => {
+            navigate(`/data/knowledge-management/detail/${record.setId}`);
+          },
+        })}
+      />
+    </div>
+  );
+}

frontend/src/pages/KnowledgeManagement/components/CreateKnowledgeSet.tsx

@@ -9,6 +9,7 @@ import {
 import {
   knowledgeSourceTypeOptions,
   knowledgeStatusOptions,
+  // sensitivityOptions,
 } from "../knowledge-management.const";
 import {
   KnowledgeSet,
@@ -169,9 +170,9 @@ export default function CreateKnowledgeSet({
             <Form.Item label="负责人" name="owner">
               <Input placeholder="请输入负责人" />
             </Form.Item>
-            <Form.Item label="敏感级别" name="sensitivity">
+            {/* <Form.Item label="敏感级别" name="sensitivity">
-              <Input placeholder="请输入敏感级别" />
+              <Select options={sensitivityOptions} placeholder="请选择敏感级别" />
-            </Form.Item>
+            </Form.Item> */}
           </div>
           <div className="grid grid-cols-2 gap-4">
             <Form.Item label="有效期开始" name="validFrom">
@@ -191,9 +192,6 @@ export default function CreateKnowledgeSet({
               placeholder="请选择或输入标签"
             />
           </Form.Item>
-          <Form.Item label="扩展元数据" name="metadata">
-            <Input.TextArea placeholder="请输入元数据（JSON）" rows={3} />
-          </Form.Item>
         </Form>
       </Modal>
     </>

frontend/src/pages/KnowledgeManagement/components/KnowledgeItemEditor.tsx

@@ -16,6 +16,7 @@ export default function KnowledgeItemEditor({
   open,
   setId,
   data,
+  parentPrefix,
   onCancel,
   onSuccess,
   readOnly,
@@ -23,12 +24,14 @@ export default function KnowledgeItemEditor({
   open: boolean;
   setId: string;
   data?: Partial<KnowledgeItem> | null;
+  parentPrefix?: string;
   readOnly?: boolean;
   onCancel: () => void;
   onSuccess: () => void;
 }) {
   const [fileList, setFileList] = useState<UploadFile[]>([]);
   const [replaceFileList, setReplaceFileList] = useState<UploadFile[]>([]);
+  const [loading, setLoading] = useState(false);
   const isFileItem =
     data?.contentType === KnowledgeContentType.FILE ||
     data?.sourceType === KnowledgeSourceType.FILE_UPLOAD;
@@ -49,7 +52,6 @@ export default function KnowledgeItemEditor({
         originFileObj: file,
       },
     ]);
-    message.success("文件已就绪，可提交创建条目");
     return false;
   };
 
@@ -95,6 +97,7 @@ export default function KnowledgeItemEditor({
           message.warning("请先选择文件");
           return;
         }
+        setLoading(true);
         const formData = new FormData();
         fileList.forEach((file) => {
           const origin = file.originFileObj as File | undefined;
@@ -102,6 +105,9 @@ export default function KnowledgeItemEditor({
             formData.append("files", origin);
           }
         });
+        if (parentPrefix) {
+          formData.append("parentPrefix", parentPrefix);
+        }
         await uploadKnowledgeItemsUsingPost(setId, formData);
         message.success(`已创建 ${fileList.length} 个知识条目`);
       } else {
@@ -121,6 +127,7 @@ export default function KnowledgeItemEditor({
           message.warning("请先选择要替换的文件");
           return;
         }
+        setLoading(true);
         const formData = new FormData();
         formData.append("file", replaceFile);
         await replaceKnowledgeItemFileUsingPut(setId, data.id, formData);
@@ -132,6 +139,8 @@ export default function KnowledgeItemEditor({
       onSuccess();
     } catch {
       message.error("操作失败，请重试");
+    } finally {
+      setLoading(false);
     }
   };
 
@@ -148,6 +157,7 @@ export default function KnowledgeItemEditor({
       width={860}
       maskClosable={false}
       okButtonProps={{ disabled: readOnly }}
+      confirmLoading={loading}
     >
       <Form layout="vertical" disabled={readOnly}>
         {isCreateMode && (

frontend/src/pages/KnowledgeManagement/knowledge-management.api.ts

@@ -5,6 +5,11 @@ export function queryKnowledgeSetsUsingGet(params?: Record<string, unknown>) {
   return get("/api/data-management/knowledge-sets", params);
 }
 
+// 知识管理统计
+export function getKnowledgeManagementStatisticsUsingGet() {
+  return get("/api/data-management/knowledge-sets/statistics");
+}
+
 // 创建知识集
 export function createKnowledgeSetUsingPost(data: Record<string, unknown>) {
   return post("/api/data-management/knowledge-sets", data);
@@ -30,6 +35,27 @@ export function queryKnowledgeItemsUsingGet(setId: string, params?: Record<strin
   return get(`/api/data-management/knowledge-sets/${setId}/items`, params);
 }
 
+// 知识条目目录列表
+export function queryKnowledgeDirectoriesUsingGet(setId: string, params?: Record<string, unknown>) {
+  return get(`/api/data-management/knowledge-sets/${setId}/directories`, params);
+}
+
+// 创建知识条目目录
+export function createKnowledgeDirectoryUsingPost(setId: string, data: Record<string, unknown>) {
+  return post(`/api/data-management/knowledge-sets/${setId}/directories`, data);
+}
+
+// 删除知识条目目录
+export function deleteKnowledgeDirectoryUsingDelete(setId: string, relativePath: string) {
+  const query = new URLSearchParams({ relativePath }).toString();
+  return del(`/api/data-management/knowledge-sets/${setId}/directories?${query}`);
+}
+
+// 知识条目文件搜索
+export function searchKnowledgeItemsUsingGet(params?: Record<string, unknown>) {
+  return get("/api/data-management/knowledge-items/search", params);
+}
+
 // 创建知识条目
 export function createKnowledgeItemUsingPost(setId: string, data: Record<string, unknown>) {
   return post(`/api/data-management/knowledge-sets/${setId}/items`, data);
@@ -60,6 +86,11 @@ export function deleteKnowledgeItemByIdUsingDelete(setId: string, itemId: string
   return del(`/api/data-management/knowledge-sets/${setId}/items/${itemId}`);
 }
 
+// 批量删除知识条目
+export function deleteKnowledgeItemsByIdsUsingPost(setId: string, data: { ids: string[] }) {
+  return post(`/api/data-management/knowledge-sets/${setId}/items/batch-delete`, data);
+}
+
 // 上传知识条目文件
 export function uploadKnowledgeItemsUsingPost(setId: string, data: FormData) {
   return post(`/api/data-management/knowledge-sets/${setId}/items/upload`, data);
@@ -70,6 +101,16 @@ export function downloadKnowledgeItemFileUsingGet(setId: string, itemId: string,
   return download(`/api/data-management/knowledge-sets/${setId}/items/${itemId}/file`, null, fileName || "");
 }
 
+// 知识条目预览状态
+export function queryKnowledgeItemPreviewStatusUsingGet(setId: string, itemId: string) {
+  return get(`/api/data-management/knowledge-sets/${setId}/items/${itemId}/preview/status`);
+}
+
+// 触发知识条目预览转换
+export function convertKnowledgeItemPreviewUsingPost(setId: string, itemId: string) {
+  return post(`/api/data-management/knowledge-sets/${setId}/items/${itemId}/preview/convert`, {});
+}
+
 // 导出知识条目
 export function exportKnowledgeItemsUsingGet(setId: string) {
   return download(`/api/data-management/knowledge-sets/${setId}/items/export`);

frontend/src/pages/KnowledgeManagement/knowledge-management.const.tsx

@@ -66,6 +66,11 @@ export const knowledgeSourceTypeOptions = [
   { label: "文件上传", value: KnowledgeSourceType.FILE_UPLOAD },
 ];
 
+// export const sensitivityOptions = [
+//   { label: "敏感", value: "敏感" },
+//   { label: "不敏感", value: "不敏感" },
+// ];
+
 export type KnowledgeSetView = {
   id: string;
   name: string;
@@ -106,6 +111,7 @@ export type KnowledgeItemView = {
   sensitivity?: string;
   sourceDatasetId?: string;
   sourceFileId?: string;
+  relativePath?: string;
   metadata?: string;
   createdAt?: string;
   updatedAt?: string;
@@ -153,6 +159,7 @@ export function mapKnowledgeItem(data: KnowledgeItem): KnowledgeItemView {
     sensitivity: data.sensitivity,
     sourceDatasetId: data.sourceDatasetId,
     sourceFileId: data.sourceFileId,
+    relativePath: data.relativePath,
     metadata: data.metadata,
     createdAt: data.createdAt ? formatDateTime(data.createdAt) : "",
     updatedAt: data.updatedAt ? formatDateTime(data.updatedAt) : "",

frontend/src/pages/KnowledgeManagement/knowledge-management.model.ts

@@ -61,9 +61,41 @@ export interface KnowledgeItem {
   sensitivity?: string;
   sourceDatasetId?: string;
   sourceFileId?: string;
+  relativePath?: string;
   metadata?: string;
   createdAt?: string;
   updatedAt?: string;
   createdBy?: string;
   updatedBy?: string;
 }
+
+export interface KnowledgeDirectory {
+  id: string;
+  setId: string;
+  name: string;
+  relativePath: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface KnowledgeManagementStatistics {
+  totalKnowledgeSets: number;
+  totalFiles: number;
+  totalSize: number;
+  totalTags: number;
+}
+
+export interface KnowledgeItemSearchResult {
+  id: string;
+  setId: string;
+  setName: string;
+  contentType: KnowledgeContentType;
+  sourceType: KnowledgeSourceType;
+  sourceDatasetId?: string;
+  sourceFileId?: string;
+  fileName?: string;
+  fileSize?: number;
+  relativePath?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}

frontend/src/pages/Layout/Sidebar.tsx

@@ -4,6 +4,7 @@ import {
   CloseOutlined,
   MenuOutlined,
   SettingOutlined,
+  LogoutOutlined,
 } from "@ant-design/icons";
 import { ClipboardList, X } from "lucide-react";
 import { menuItems } from "@/pages/Layout/menu";
@@ -12,6 +13,7 @@ import TaskUpload from "./TaskUpload";
 import SettingsPage from "../SettingsPage/SettingsPage";
 import { useAppSelector, useAppDispatch } from "@/store/hooks";
 import { showSettings, hideSettings } from "@/store/slices/settingsSlice";
+import { logout } from "@/store/slices/authSlice";
 
 const isPathMatch = (currentPath: string, targetPath: string) =>
   currentPath === targetPath || currentPath.startsWith(`${targetPath}/`);
@@ -67,6 +69,11 @@ const AsiderAndHeaderLayout = () => {
     };
   }, []);
 
+  const handleLogout = () => {
+    dispatch(logout());
+    navigate("/login");
+  };
+
   return (
     <div
       className={`${
@@ -148,6 +155,9 @@ const AsiderAndHeaderLayout = () => {
             >
               设置
             </Button>
+            <Button block danger onClick={handleLogout}>
+              退出登录
+            </Button>
           </div>
         ) : (
           <div className="space-y-2">
@@ -175,6 +185,7 @@ const AsiderAndHeaderLayout = () => {
             >
               <SettingOutlined />
             </Button>
+            <Button block danger onClick={handleLogout} icon={<LogoutOutlined />} />
           </div>
         )}
       </div>

frontend/src/pages/Layout/TaskUpload.tsx

@@ -3,25 +3,28 @@ import {
   preUploadUsingPost,
   uploadFileChunkUsingPost,
 } from "@/pages/DataManagement/dataset.api";
-import { Button, Empty, Progress } from "antd";
+import { Button, Empty, Progress, Tag } from "antd";
-import { DeleteOutlined } from "@ant-design/icons";
+import { DeleteOutlined, FileTextOutlined } from "@ant-design/icons";
 import { useEffect } from "react";
 import { useFileSliceUpload } from "@/hooks/useSliceUpload";
 
 export default function TaskUpload() {
-  const { createTask, taskList, removeTask, handleUpload } = useFileSliceUpload(
+  const { createTask, taskList, removeTask, handleUpload, registerStreamUploadListener } = useFileSliceUpload(
     {
       preUpload: preUploadUsingPost,
       uploadChunk: uploadFileChunkUsingPost,
       cancelUpload: cancelUploadUsingPut,
-    }
+    },
+    true, // showTaskCenter
+    true  // enableStreamUpload
   );
 
   useEffect(() => {
-    const uploadHandler = (e: any) => {
+    const uploadHandler = (e: Event) => {
-      console.log('[TaskUpload] Received upload event detail:', e.detail);
+      const customEvent = e as CustomEvent;
-      const { files } = e.detail;
+      console.log('[TaskUpload] Received upload event detail:', customEvent.detail);
-      const task = createTask(e.detail);
+      const { files } = customEvent.detail;
+      const task = createTask(customEvent.detail);
       console.log('[TaskUpload] Created task with prefix:', task.prefix);
       handleUpload({ task, files });
     };
@@ -29,7 +32,13 @@ export default function TaskUpload() {
     return () => {
       window.removeEventListener("upload:dataset", uploadHandler);
     };
-  }, []);
+  }, [createTask, handleUpload]);
+
+  // 注册流式上传监听器
+  useEffect(() => {
+    const unregister = registerStreamUploadListener();
+    return unregister;
+  }, [registerStreamUploadListener]);
 
   return (
     <div
@@ -55,7 +64,22 @@ export default function TaskUpload() {
               ></Button>
             </div>
 
-            <Progress size="small" percent={task.percent} />
+            <Progress size="small" percent={Number(task.percent)} />
+            {task.streamUploadInfo && (
+              <div className="flex items-center gap-2 text-xs text-gray-500 mt-1">
+                <Tag icon={<FileTextOutlined />} size="small">
+                  按行分割
+                </Tag>
+                <span>
+                  已上传: {task.streamUploadInfo.uploadedLines} 行
+                </span>
+                {task.streamUploadInfo.totalFiles > 1 && (
+                  <span>
+                    ({task.streamUploadInfo.fileIndex}/{task.streamUploadInfo.totalFiles} 文件)
+                  </span>
+                )}
+              </div>
+            )}
           </div>
         ))}
       {taskList.length === 0 && (

frontend/src/pages/Layout/menu.tsx

@@ -24,11 +24,25 @@ export const menuItems = [
   // },
   {
     id: "management",
-    title: "数据管理",
+    title: "数集管理",
     icon: FolderOpen,
     description: "创建、导入和管理数据集",
     color: "bg-blue-500",
   },
+  {
+    id: "annotation",
+    title: "数据标注",
+    icon: Tag,
+    description: "对数据进行标注和标记",
+    color: "bg-green-500",
+  },
+  {
+    id: "content-generation",
+    title: "内容生成",
+    icon: Sparkles,
+    description: "智能内容生成与创作",
+    color: "bg-purple-500",
+  },
   {
     id: "knowledge-management",
     title: "知识管理",
@@ -43,20 +57,6 @@ export const menuItems = [
   //   description: "数据清洗和预处理",
   //   color: "bg-purple-500",
   // },
-  {
-    id: "annotation",
-    title: "数据标注",
-    icon: Tag,
-    description: "对数据进行标注和标记",
-    color: "bg-green-500",
-  },
-  {
-    id: "content-generation",
-    title: "内容生成",
-    icon: Sparkles,
-    description: "智能内容生成与创作",
-    color: "bg-purple-500",
-  },
   // {
   //   id: "synthesis",
   //   title: "数据合成",

frontend/src/pages/Login/LoginPage.tsx

@@ -0,0 +1,114 @@
+import React, { useState } from 'react';
+import { useNavigate, useLocation } from 'react-router';
+import { Form, Input, Button, Typography, message, Card } from 'antd';
+import { UserOutlined, LockOutlined } from '@ant-design/icons';
+import { useAppDispatch, useAppSelector } from '@/store/hooks';
+import { loginLocal } from '@/store/slices/authSlice';
+
+const { Title, Text } = Typography;
+
+const LoginPage: React.FC = () => {
+  const navigate = useNavigate();
+  const location = useLocation();
+  const dispatch = useAppDispatch();
+  const { loading, error } = useAppSelector((state) => state.auth);
+  const [messageApi, contextHolder] = message.useMessage();
+
+  const from = location.state?.from?.pathname || '/data';
+
+  const onFinish = (values: any) => {
+    dispatch(loginLocal(values));
+    // The reducer updates state synchronously.
+    if (values.username === 'admin' && values.password === '123456') {
+        messageApi.success('登录成功');
+        navigate(from, { replace: true });
+    } else {
+        messageApi.error('账号或密码错误');
+    }
+  };
+
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-[#050b14] relative overflow-hidden">
+      {contextHolder}
+
+      {/* Background Effects */}
+      <div className="absolute inset-0 z-0">
+        <div className="absolute top-0 left-0 w-full h-full bg-[radial-gradient(ellipse_at_center,_var(--tw-gradient-stops))] from-blue-900/20 via-[#050b14] to-[#050b14]"></div>
+        {/* Simple grid pattern if possible, or just gradient */}
+      </div>
+
+      <div className="absolute top-1/4 left-1/4 w-72 h-72 bg-blue-500/10 rounded-full blur-3xl animate-pulse"></div>
+      <div className="absolute bottom-1/4 right-1/4 w-96 h-96 bg-cyan-500/10 rounded-full blur-3xl animate-pulse delay-700"></div>
+
+      <div className="z-10 w-full max-w-md p-8 animate-[fadeIn_0.5s_ease-out_forwards]">
+        <div className="backdrop-blur-xl bg-white/5 border border-white/10 rounded-2xl shadow-2xl p-8 relative overflow-hidden">
+          {/* Decorative line */}
+          <div className="absolute top-0 left-0 w-full h-1 bg-gradient-to-r from-transparent via-blue-500 to-transparent"></div>
+
+          <div className="text-center mb-8">
+            <div className="inline-flex items-center justify-center w-16 h-16 rounded-full bg-blue-500/20 mb-4 border border-blue-500/30">
+              <svg className="w-8 h-8 text-blue-400" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
+              </svg>
+            </div>
+            <Title level={2} className="!text-white !mb-2 tracking-wide font-bold">
+              DataBuilder
+            </Title>
+            <Text className="text-gray-400! text-sm tracking-wider">
+              一站式数据工作平台
+            </Text>
+          </div>
+
+          <Form
+            name="login"
+            initialValues={{ remember: true, username: 'admin', password: '123456' }}
+            onFinish={onFinish}
+            layout="vertical"
+            size="large"
+          >
+            <Form.Item
+              name="username"
+              rules={[{ required: true, message: '请输入账号！' }]}
+            >
+              <Input
+                prefix={<UserOutlined className="text-blue-400" />}
+                placeholder="账号"
+                className="!bg-white/5 !border-white/10 !text-white placeholder:!text-gray-600 hover:!border-blue-500/50 focus:!border-blue-500 !rounded-lg"
+              />
+            </Form.Item>
+            <Form.Item
+              name="password"
+              rules={[{ required: true, message: '请输入密码！' }]}
+            >
+              <Input.Password
+                prefix={<LockOutlined className="text-blue-400" />}
+                type="password"
+                placeholder="密码"
+                className="!bg-white/5 !border-white/10 !text-white placeholder:!text-gray-600 hover:!border-blue-500/50 focus:!border-blue-500 !rounded-lg"
+              />
+            </Form.Item>
+
+            <Form.Item className="mb-2">
+              <Button
+                type="primary"
+                htmlType="submit"
+                className="w-full bg-gradient-to-r from-blue-600 to-cyan-600 hover:from-blue-500 hover:to-cyan-500 border-none h-12 rounded-lg font-semibold tracking-wide shadow-lg shadow-blue-900/20"
+                loading={loading}
+              >
+                登录系统
+              </Button>
+            </Form.Item>
+
+            <div className="text-center mt-4">
+              <Text className="text-gray-600! text-xs">
+                数据处理平台 · 安全接入
+              </Text>
+            </div>
+          </Form>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default LoginPage;